replace old password generator

pwman/tests/db_tests.py

@@ -20,7 +20,7 @@
 from pwman.data import factory
 #from pwman.data.drivers.sqlite import DatabaseException
 from pwman.util.config import get_pass_conf
-from pwman.util.generator import leetlist
+#from pwman.util.generator import leetlist
 from pwman.util.crypto_engine import CryptoEngine
 from pwman.ui import get_ui_platform
 from pwman.ui.tools import CMDLoop, CliMenuItem
@@ -195,15 +195,15 @@ class CLITests(unittest.TestCase):
         password = self.tester.cli.get_password(None, length=7)
         self.assertEqual(len(password), 7)
 
-    def test_random_leet_password(self):
-        password = self.tester.cli.get_password(None, leetify=True, length=7)
-        l_num = 0
-        for v in leetlist.values():
-            if v in password:
-                l_num += 1
+    #def test_random_leet_password(self):
+    #    password = self.tester.cli.get_password(None, leetify=True, length=7)
+    #    l_num = 0
+    #    for v in leetlist.values():
+    #        if v in password:
+    #            l_num += 1
         # sometime despite all efforts, randomness dictates that no
         # leetifying happens ...
-        self.assertTrue(l_num >= 0)
+    #    self.assertTrue(l_num >= 0)
 
     def test_leet_password(self):
         password = self.tester.cli.get_password(None, leetify=True,

pwman/ui/tools.py

@@ -20,18 +20,16 @@
 Define the CLI interface for pwman3 and the helper functions
 """
 from __future__ import print_function
-from pwman.util.callback import Callback
 import subprocess as sp
 import getpass
 import sys
 import struct
 import os
 import colorama
-#from pwman.data.tags import TagNew as Tag
 from pwman.util.config import get_pass_conf
-import pwman.util.generator as generator
+from pwman.util.callback import Callback
 
-if sys.version_info.major > 2:
+if sys.version_info.major > 2:  # pragma: no cover
     raw_input = input
 
 if sys.platform != 'win32':
@@ -158,11 +156,11 @@ def getpassword(question, argsgiven=None,
             except ValueError:
                 print("please enter a proper integer")
 
-        password, dumpme = generator.generate_password(
-            length, length, True, symbols=leetify, numerics=numerics,
-            special_chars=special_signs)
-        print ("New password: %s" % (password))
-        return password
+        #password, dumpme = generator.generate_password(
+        #    length, length, True, symbols=leetify, numerics=numerics,
+        #    special_chars=special_signs)
+        #print ("New password: %s" % (password))
+        #return password
     # no args given
     while True:
         a1 = reader(question.ljust(width))
@@ -174,7 +172,7 @@ def getpassword(question, argsgiven=None,
         a2 = reader("[Repeat] %s" % (question.ljust(width)))
         if a1 == a2:
             if leetify:
-                return generator.leetify(a1)
+                pass  # return generator.leetify(a1)
             else:
                 return a1
         else:

pwman/util/crypto_engine.py

@@ -18,16 +18,17 @@
 # ============================================================================
 
 from __future__ import print_function
-from Crypto.Cipher import AES
-from Crypto.Protocol.KDF import PBKDF2
 import base64
+import ctypes
+import string
 import os
 import sys
 import binascii
 import time
+import random
+from Crypto.Cipher import AES
+from Crypto.Protocol.KDF import PBKDF2
 from pwman.util.callback import Callback
-import ctypes
-
 if sys.version_info.major > 2:  # pragma: no cover
     raw_input = input
 
@@ -35,6 +36,23 @@ EncodeAES = lambda c, s: base64.b64encode(c.encrypt(s))
 DecodeAES = lambda c, e: c.decrypt(base64.b64decode(e)).rstrip()
 
 
+def generate_password(pass_len=8, uppercase=True, lowercase=True, digits=True,
+                      special_chars=True):
+    allowed = ''
+    if lowercase:
+        allowed = allowed + string.ascii_lowercase
+    if uppercase:
+        allowed = allowed + string.ascii_uppercase
+    if digits:
+        allowed = allowed + string.digits
+    if special_chars:
+        allowed = allowed + string.punctuation
+
+    password = ''.join(random.SystemRandom().choice(allowed)
+                       for _ in range(pass_len))
+    return password
+
+
 def zerome(string):
     """
     securely erase strings ...

pwman/util/generator.py

@@ -1,2369 +0,0 @@
-#============================================================================
-# This file is part of Pwman3.
-#
-# Pwman3 is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License, version 2
-# as published by the Free Software Foundation;
-#
-# Pwman3 is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Pwman3; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-#============================================================================
-# Copyright (C) 2012 Oz Nahum <nahumoz@gmail.com>
-#============================================================================
-#============================================================================
-# Copyright (C) 2006 Ivan Kelly <ivan@ivankelly.net>
-#============================================================================
-
-"""
-Functions to generate passwords.
-Based heavily on passogva.py (c) 2004 Mo-Tsuki, LLC.
-http://dev.mosuki.com/passogva/
-
-Usage:
-import pwman.util.generator as PwGen
-minlen = 6
-maxlen = 8
-(word, hypenated_word) = PwGen.generate_password(minlen, maxlen)
-"""
-from Crypto.Random import random
-
-class PasswordGenerationException(Exception):
-    def __init__(self, message):
-        self.message = message
-
-    def __str__(self):
-        return self.message
-
-def generate_password(minlen, maxlen, capitals = True, symbols = False, \
-    numerics = False, special_chars = False):
-    (password, hyphenated) = generate_password_shazel(minlen, maxlen)
-    if (capitals):
-        password = randomly_capitalize(password)
-    if (symbols):
-        password = leetify(password)
-    if (numerics):
-        password = change_numerics(password)
-    if (special_chars):
-        password = random_special_sign(password)
-    return (password, hyphenated)
-
-def randomly_capitalize(password):
-    newpassword = str()
-    for l in password:
-        if random.randint(0, 1):
-            l = l.upper()
-        newpassword = newpassword + l
-    return newpassword
-
-def leetify(password):
-    newpassword = str()
-    for l in password:
-        if random.randint(0, 1):
-            l = leetify_char(l)
-        newpassword = newpassword + l
-    return newpassword
-
-def random_special_sign(password):
-    """
-    replace one letter with a special sign,
-    this will do the following:
-    In [203]: for i in range(10):
-    print random_special_sign("secret")
-    .....:
-    secre%
-    sec\et
-    secre?
-    s;cret
-    se$ret
-    secr}t
-    secr*t
-    ;ecret
-    s%cret
-    secre(
-    note: numbers are not replaced:
-    In [5]: for i in range(10):
-    print random_special_sign(password)
-   ...:
-    s3cr?t
-    s3cr$t
-    s3cre#
-    $3cret
-    s3c\et
-    s3cr-t
-    }3cret
-    s3*ret
-    s3cre:
-    s3cr@t
-
-    In [6]: password = "v3r71mp0rt4nt"
-
-    In [7]: for i in range(10):
-        print random_special_sign(password)
-   ...:
-    v3r71mp0rt4)t
-    v3r71m&0rt4nt
-    v3r71mp0rt4-t
-    v3r71mp0rt4&t
-    v3^71mp0rt4nt
-    v3r71@p0rt4nt
-    v3}71mp0rt4nt
-    v3r71m}0rt4nt
-    v3r71mp0r*4nt
-    v3^71mp0rt4nt
-    """
-    newpass = str()
-    specialsigns = ["@", "#", "?", "!", '\\', "|", "$",
-                     "%", "^", "&", "*", "(", ")", ":", ";",
-                     "{", "}", "+","-"]
-
-    place = int(random.randint(0, len(password)-1))
-    while password[place].isdigit():
-        place = int(random.randint(0, len(password)-1))
-
-    randomsign = specialsigns[int(random.randint(0, len(specialsigns)-1))]
-    for idx, letter in enumerate(password):
-        if not idx == place:
-            newpass = newpass + letter
-        if idx == place:
-            newpass = newpass + randomsign
-    return newpass
-
-def change_numerics(password):
-    newpassword = str()
-    for l in password:
-        if random.randint(0, 1):
-            l = change_numerics_char(l)
-        newpassword = newpassword + l
-    return newpassword
-#
-# Dictionary of mappings for leetness
-#
-leetlist = {
-    'w': "\/\/", 'W': "\/\/", 'e': '3', 'E': '3', 't': '+', 'T': '7',
-    'i': '1', 'I': '1', 'o': '0', 'O': '0', 'A': '4', 's': '5', 'S': '$',
-    'g': '9', 'K': '|<', 'k': '|<', 'x': '><', 'X': '><', 'c': '<', 'C': '<',
-    'v': '\/', 'V': '\/', 'n': '|\|', 'N': '|\|', 'm': '|\/|', 'M': '|\/|'
-    }
-
-def leetify_char(l):
-    try:
-        return leetlist[l]
-    except KeyError:
-        return l
-
-numericlist = {
-    'e': '3', 'E': '3', 'T': '7',
-    'i': '1', 'I': '1', 'o': '0', 'O': '0', 'A': '4', 's': '5', 'S': '5',
-    'g': '9', 'q': '9', 'l': '1'
-    }
-
-def change_numerics_char(l):
-    try:
-        return numericlist[l]
-    except KeyError:
-        return l
-#
-# Beyond this point layeth Steve Hazel's code
-# Steven Hazel <sah@mosuki.com>
-#
-# I've added exceptions
-#
-MIN_LENGTH_PASSWORD = 6
-MAX_LENGTH_PASSWORD = 14
-
-grams = ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
-         'm', 'n', 'o', 'p', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y',
-         'z', 'ch', 'gh', 'ph', 'rh', 'sh', 'th', 'wh', 'qu', 'ck')
-
-vowel_grams = ('a', 'e', 'i', 'o', 'u', 'y')
-
-occurrence_frequencies = {
-    'a'  : 10,      'b'  :  8,      'c'  : 12,      'd'  : 12,
-    'e'  : 12,      'f'  :  8,      'g'  :  8,      'h'  :  6,
-    'i'  : 10,      'j'  :  8,      'k'  :  8,      'l'  :  6,
-    'm'  :  6,      'n'  : 10,      'o'  : 10,      'p'  :  6,
-    'r'  : 10,      's'  :  8,      't'  : 10,      'u'  :  6,
-    'v'  :  8,      'w'  :  8,      'x'  :  1,      'y'  :  8,
-    'z'  :  1,      'ch' :  1,      'gh' :  1,      'ph' :  1,
-    'rh' :  1,      'sh' :  2,      'th' :  1,      'wh' :  1,
-    'qu' :  1,      'ck' :  1}
-
-numbers = []
-for gram in grams:
-    for i in range(occurrence_frequencies[gram]):
-        numbers.append(gram)
-
-
-
-vowel_numbers = []
-for gram in vowel_grams:
-    for i in range(occurrence_frequencies[gram]):
-        vowel_numbers.append(gram)
-
-
-
-#
-# Bit flags
-#
-
-MAX_UNACCEPTABLE = 20
-
-# gram rules:
-NOT_BEGIN_SYLLABLE = 0x08
-NO_FINAL_SPLIT = 0x04
-VOWEL = 0x02
-ALTERNATE_VOWEL = 0x01
-NO_SPECIAL_RULE = 0x00
-
-# digram rules:
-BEGIN = 0x80
-NOT_BEGIN = 0x40
-BREAK = 0x20
-PREFIX = 0x10
-ILLEGAL_PAIR = 0x08
-SUFFIX = 0x04
-END = 0x02
-NOT_END = 0x01
-ANY_COMBINATION = 0x00
-
-gram_rules = dict()
-for gram in grams:
-    gram_rules[ gram ] = NO_SPECIAL_RULE
-
-for gram in vowel_grams:
-    gram_rules[ gram ] = VOWEL
-
-
-gram_rules['e'] |= NO_FINAL_SPLIT
-gram_rules['y'] |= ALTERNATE_VOWEL
-
-gram_rules['x']  = NOT_BEGIN_SYLLABLE
-gram_rules['ck'] = NOT_BEGIN_SYLLABLE
-
-
-
-digram_rules = dict()
-
-###############################################################################
-# BEGIN DIGRAM RULES
-###############################################################################
-
-digram_rules['a'] = dict()
-digram_rules['a']['a'] = ILLEGAL_PAIR
-digram_rules['a']['b'] = ANY_COMBINATION
-digram_rules['a']['c'] = ANY_COMBINATION
-digram_rules['a']['d'] = ANY_COMBINATION
-digram_rules['a']['e'] = ILLEGAL_PAIR
-digram_rules['a']['f'] = ANY_COMBINATION
-digram_rules['a']['g'] = ANY_COMBINATION
-digram_rules['a']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['a']['i'] = ANY_COMBINATION
-digram_rules['a']['j'] = ANY_COMBINATION
-digram_rules['a']['k'] = ANY_COMBINATION
-digram_rules['a']['l'] = ANY_COMBINATION
-digram_rules['a']['m'] = ANY_COMBINATION
-digram_rules['a']['n'] = ANY_COMBINATION
-digram_rules['a']['o'] = ILLEGAL_PAIR
-digram_rules['a']['p'] = ANY_COMBINATION
-digram_rules['a']['r'] = ANY_COMBINATION
-digram_rules['a']['s'] = ANY_COMBINATION
-digram_rules['a']['t'] = ANY_COMBINATION
-digram_rules['a']['u'] = ANY_COMBINATION
-digram_rules['a']['v'] = ANY_COMBINATION
-digram_rules['a']['w'] = ANY_COMBINATION
-digram_rules['a']['x'] = ANY_COMBINATION
-digram_rules['a']['y'] = ANY_COMBINATION
-digram_rules['a']['z'] = ANY_COMBINATION
-digram_rules['a']['ch'] = ANY_COMBINATION
-digram_rules['a']['gh'] = ILLEGAL_PAIR
-digram_rules['a']['ph'] = ANY_COMBINATION
-digram_rules['a']['rh'] = ILLEGAL_PAIR
-digram_rules['a']['sh'] = ANY_COMBINATION
-digram_rules['a']['th'] = ANY_COMBINATION
-digram_rules['a']['wh'] = ILLEGAL_PAIR
-digram_rules['a']['qu'] = BREAK | NOT_END
-digram_rules['a']['ck'] = ANY_COMBINATION
-
-digram_rules['b'] = dict()
-digram_rules['b']['a'] = ANY_COMBINATION
-digram_rules['b']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['d'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['e'] = ANY_COMBINATION
-digram_rules['b']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['g'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['i'] = ANY_COMBINATION
-digram_rules['b']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['k'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['l'] = BEGIN | SUFFIX | NOT_END
-digram_rules['b']['m'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['n'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['o'] = ANY_COMBINATION
-digram_rules['b']['p'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['r'] = BEGIN | END
-digram_rules['b']['s'] = NOT_BEGIN
-digram_rules['b']['t'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['u'] = ANY_COMBINATION
-digram_rules['b']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['x'] = ILLEGAL_PAIR
-digram_rules['b']['y'] = ANY_COMBINATION
-digram_rules['b']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['ch'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['gh'] = ILLEGAL_PAIR
-digram_rules['b']['ph'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['rh'] = ILLEGAL_PAIR
-digram_rules['b']['sh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['th'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['wh'] = ILLEGAL_PAIR
-digram_rules['b']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['b']['ck'] = ILLEGAL_PAIR
-
-digram_rules['c'] = dict()
-digram_rules['c']['a'] = ANY_COMBINATION
-digram_rules['c']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['c']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['c']['d'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['c']['e'] = ANY_COMBINATION
-digram_rules['c']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['c']['g'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['c']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['c']['i'] = ANY_COMBINATION
-digram_rules['c']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['c']['k'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['c']['l'] = SUFFIX | NOT_END
-digram_rules['c']['m'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['c']['n'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['c']['o'] = ANY_COMBINATION
-digram_rules['c']['p'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['c']['r'] = NOT_END
-digram_rules['c']['s'] = NOT_BEGIN | END
-digram_rules['c']['t'] = NOT_BEGIN | PREFIX
-digram_rules['c']['u'] = ANY_COMBINATION
-digram_rules['c']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['c']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['c']['x'] = ILLEGAL_PAIR
-digram_rules['c']['y'] = ANY_COMBINATION
-digram_rules['c']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['c']['ch'] = ILLEGAL_PAIR
-digram_rules['c']['gh'] = ILLEGAL_PAIR
-digram_rules['c']['ph'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['c']['rh'] = ILLEGAL_PAIR
-digram_rules['c']['sh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['c']['th'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['c']['wh'] = ILLEGAL_PAIR
-digram_rules['c']['qu'] = NOT_BEGIN | SUFFIX | NOT_END
-digram_rules['c']['ck'] = ILLEGAL_PAIR
-
-digram_rules['d'] = dict()
-digram_rules['d']['a'] = ANY_COMBINATION
-digram_rules['d']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['d']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['d']['d'] = NOT_BEGIN
-digram_rules['d']['e'] = ANY_COMBINATION
-digram_rules['d']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['d']['g'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['d']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['d']['i'] = ANY_COMBINATION
-digram_rules['d']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['d']['k'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['d']['l'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['d']['m'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['d']['n'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['d']['o'] = ANY_COMBINATION
-digram_rules['d']['p'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['d']['r'] = BEGIN | NOT_END
-digram_rules['d']['s'] = NOT_BEGIN | END
-digram_rules['d']['t'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['d']['u'] = ANY_COMBINATION
-digram_rules['d']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['d']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['d']['x'] = ILLEGAL_PAIR
-digram_rules['d']['y'] = ANY_COMBINATION
-digram_rules['d']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['d']['ch'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['d']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['d']['ph'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['d']['rh'] = ILLEGAL_PAIR
-digram_rules['d']['sh'] = NOT_BEGIN | NOT_END
-digram_rules['d']['th'] = NOT_BEGIN | PREFIX
-digram_rules['d']['wh'] = ILLEGAL_PAIR
-digram_rules['d']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['d']['ck'] = ILLEGAL_PAIR
-
-digram_rules['e'] = dict()
-digram_rules['e']['a'] = ANY_COMBINATION
-digram_rules['e']['b'] = ANY_COMBINATION
-digram_rules['e']['c'] = ANY_COMBINATION
-digram_rules['e']['d'] = ANY_COMBINATION
-digram_rules['e']['e'] = ANY_COMBINATION
-digram_rules['e']['f'] = ANY_COMBINATION
-digram_rules['e']['g'] = ANY_COMBINATION
-digram_rules['e']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['e']['i'] = NOT_END
-digram_rules['e']['j'] = ANY_COMBINATION
-digram_rules['e']['k'] = ANY_COMBINATION
-digram_rules['e']['l'] = ANY_COMBINATION
-digram_rules['e']['m'] = ANY_COMBINATION
-digram_rules['e']['n'] = ANY_COMBINATION
-digram_rules['e']['o'] = BREAK
-digram_rules['e']['p'] = ANY_COMBINATION
-digram_rules['e']['r'] = ANY_COMBINATION
-digram_rules['e']['s'] = ANY_COMBINATION
-digram_rules['e']['t'] = ANY_COMBINATION
-digram_rules['e']['u'] = ANY_COMBINATION
-digram_rules['e']['v'] = ANY_COMBINATION
-digram_rules['e']['w'] = ANY_COMBINATION
-digram_rules['e']['x'] = ANY_COMBINATION
-digram_rules['e']['y'] = ANY_COMBINATION
-digram_rules['e']['z'] = ANY_COMBINATION
-digram_rules['e']['ch'] = ANY_COMBINATION
-digram_rules['e']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['e']['ph'] = ANY_COMBINATION
-digram_rules['e']['rh'] = ILLEGAL_PAIR
-digram_rules['e']['sh'] = ANY_COMBINATION
-digram_rules['e']['th'] = ANY_COMBINATION
-digram_rules['e']['wh'] = ILLEGAL_PAIR
-digram_rules['e']['qu'] = BREAK | NOT_END
-digram_rules['e']['ck'] = ANY_COMBINATION
-
-digram_rules['f'] = dict()
-digram_rules['f']['a'] = ANY_COMBINATION
-digram_rules['f']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['f']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['f']['d'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['f']['e'] = ANY_COMBINATION
-digram_rules['f']['f'] = NOT_BEGIN
-digram_rules['f']['g'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['f']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['f']['i'] = ANY_COMBINATION
-digram_rules['f']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['f']['k'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['f']['l'] = BEGIN | SUFFIX | NOT_END
-digram_rules['f']['m'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['f']['n'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['f']['o'] = ANY_COMBINATION
-digram_rules['f']['p'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['f']['r'] = BEGIN | NOT_END
-digram_rules['f']['s'] = NOT_BEGIN
-digram_rules['f']['t'] = NOT_BEGIN
-digram_rules['f']['u'] = ANY_COMBINATION
-digram_rules['f']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['f']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['f']['x'] = ILLEGAL_PAIR
-digram_rules['f']['y'] = NOT_BEGIN
-digram_rules['f']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['f']['ch'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['f']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['f']['ph'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['f']['rh'] = ILLEGAL_PAIR
-digram_rules['f']['sh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['f']['th'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['f']['wh'] = ILLEGAL_PAIR
-digram_rules['f']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['f']['ck'] = ILLEGAL_PAIR
-
-digram_rules['g'] = dict()
-digram_rules['g']['a'] = ANY_COMBINATION
-digram_rules['g']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['g']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['g']['d'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['g']['e'] = ANY_COMBINATION
-digram_rules['g']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['g']['g'] = NOT_BEGIN
-digram_rules['g']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['g']['i'] = ANY_COMBINATION
-digram_rules['g']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['g']['k'] = ILLEGAL_PAIR
-digram_rules['g']['l'] = BEGIN | SUFFIX | NOT_END
-digram_rules['g']['m'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['g']['n'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['g']['o'] = ANY_COMBINATION
-digram_rules['g']['p'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['g']['r'] = BEGIN | NOT_END
-digram_rules['g']['s'] = NOT_BEGIN | END
-digram_rules['g']['t'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['g']['u'] = ANY_COMBINATION
-digram_rules['g']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['g']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['g']['x'] = ILLEGAL_PAIR
-digram_rules['g']['y'] = NOT_BEGIN
-digram_rules['g']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['g']['ch'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['g']['gh'] = ILLEGAL_PAIR
-digram_rules['g']['ph'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['g']['rh'] = ILLEGAL_PAIR
-digram_rules['g']['sh'] = NOT_BEGIN
-digram_rules['g']['th'] = NOT_BEGIN
-digram_rules['g']['wh'] = ILLEGAL_PAIR
-digram_rules['g']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['g']['ck'] = ILLEGAL_PAIR
-
-digram_rules['h'] = dict()
-digram_rules['h']['a'] = ANY_COMBINATION
-digram_rules['h']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['d'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['e'] = ANY_COMBINATION
-digram_rules['h']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['g'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['h'] = ILLEGAL_PAIR
-digram_rules['h']['i'] = ANY_COMBINATION
-digram_rules['h']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['k'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['l'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['m'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['n'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['o'] = ANY_COMBINATION
-digram_rules['h']['p'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['r'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['s'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['t'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['u'] = ANY_COMBINATION
-digram_rules['h']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['x'] = ILLEGAL_PAIR
-digram_rules['h']['y'] = ANY_COMBINATION
-digram_rules['h']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['ch'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['ph'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['rh'] = ILLEGAL_PAIR
-digram_rules['h']['sh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['th'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['wh'] = ILLEGAL_PAIR
-digram_rules['h']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['h']['ck'] = ILLEGAL_PAIR
-
-digram_rules['i'] = dict()
-digram_rules['i']['a'] = ANY_COMBINATION
-digram_rules['i']['b'] = ANY_COMBINATION
-digram_rules['i']['c'] = ANY_COMBINATION
-digram_rules['i']['d'] = ANY_COMBINATION
-digram_rules['i']['e'] = NOT_BEGIN
-digram_rules['i']['f'] = ANY_COMBINATION
-digram_rules['i']['g'] = ANY_COMBINATION
-digram_rules['i']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['i']['i'] = ILLEGAL_PAIR
-digram_rules['i']['j'] = ANY_COMBINATION
-digram_rules['i']['k'] = ANY_COMBINATION
-digram_rules['i']['l'] = ANY_COMBINATION
-digram_rules['i']['m'] = ANY_COMBINATION
-digram_rules['i']['n'] = ANY_COMBINATION
-digram_rules['i']['o'] = BREAK
-digram_rules['i']['p'] = ANY_COMBINATION
-digram_rules['i']['r'] = ANY_COMBINATION
-digram_rules['i']['s'] = ANY_COMBINATION
-digram_rules['i']['t'] = ANY_COMBINATION
-digram_rules['i']['u'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['i']['v'] = ANY_COMBINATION
-digram_rules['i']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['i']['x'] = ANY_COMBINATION
-digram_rules['i']['y'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['i']['z'] = ANY_COMBINATION
-digram_rules['i']['ch'] = ANY_COMBINATION
-digram_rules['i']['gh'] = NOT_BEGIN
-digram_rules['i']['ph'] = ANY_COMBINATION
-digram_rules['i']['rh'] = ILLEGAL_PAIR
-digram_rules['i']['sh'] = ANY_COMBINATION
-digram_rules['i']['th'] = ANY_COMBINATION
-digram_rules['i']['wh'] = ILLEGAL_PAIR
-digram_rules['i']['qu'] = BREAK | NOT_END
-digram_rules['i']['ck'] = ANY_COMBINATION
-
-digram_rules['j'] = dict()
-digram_rules['j']['a'] = ANY_COMBINATION
-digram_rules['j']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['d'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['e'] = ANY_COMBINATION
-digram_rules['j']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['g'] = ILLEGAL_PAIR
-digram_rules['j']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['i'] = ANY_COMBINATION
-digram_rules['j']['j'] = ILLEGAL_PAIR
-digram_rules['j']['k'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['l'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['m'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['n'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['o'] = ANY_COMBINATION
-digram_rules['j']['p'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['r'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['s'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['t'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['u'] = ANY_COMBINATION
-digram_rules['j']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['x'] = ILLEGAL_PAIR
-digram_rules['j']['y'] = NOT_BEGIN
-digram_rules['j']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['ch'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['ph'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['rh'] = ILLEGAL_PAIR
-digram_rules['j']['sh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['th'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['wh'] = ILLEGAL_PAIR
-digram_rules['j']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['j']['ck'] = ILLEGAL_PAIR
-
-digram_rules['k'] = dict()
-digram_rules['k']['a'] = ANY_COMBINATION
-digram_rules['k']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['k']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['k']['d'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['k']['e'] = ANY_COMBINATION
-digram_rules['k']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['k']['g'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['k']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['k']['i'] = ANY_COMBINATION
-digram_rules['k']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['k']['k'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['k']['l'] = SUFFIX | NOT_END
-digram_rules['k']['m'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['k']['n'] = BEGIN | SUFFIX | NOT_END
-digram_rules['k']['o'] = ANY_COMBINATION
-digram_rules['k']['p'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['k']['r'] = SUFFIX | NOT_END
-digram_rules['k']['s'] = NOT_BEGIN | END
-digram_rules['k']['t'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['k']['u'] = ANY_COMBINATION
-digram_rules['k']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['k']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['k']['x'] = ILLEGAL_PAIR
-digram_rules['k']['y'] = NOT_BEGIN
-digram_rules['k']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['k']['ch'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['k']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['k']['ph'] = NOT_BEGIN | PREFIX
-digram_rules['k']['rh'] = ILLEGAL_PAIR
-digram_rules['k']['sh'] = NOT_BEGIN
-digram_rules['k']['th'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['k']['wh'] = ILLEGAL_PAIR
-digram_rules['k']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['k']['ck'] = ILLEGAL_PAIR
-
-digram_rules['l'] = dict()
-digram_rules['l']['a'] = ANY_COMBINATION
-digram_rules['l']['b'] = NOT_BEGIN | PREFIX
-digram_rules['l']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['l']['d'] = NOT_BEGIN | PREFIX
-digram_rules['l']['e'] = ANY_COMBINATION
-digram_rules['l']['f'] = NOT_BEGIN | PREFIX
-digram_rules['l']['g'] = NOT_BEGIN | PREFIX
-digram_rules['l']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['l']['i'] = ANY_COMBINATION
-digram_rules['l']['j'] = NOT_BEGIN | PREFIX
-digram_rules['l']['k'] = NOT_BEGIN | PREFIX
-digram_rules['l']['l'] = NOT_BEGIN | PREFIX
-digram_rules['l']['m'] = NOT_BEGIN | PREFIX
-digram_rules['l']['n'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['l']['o'] = ANY_COMBINATION
-digram_rules['l']['p'] = NOT_BEGIN | PREFIX
-digram_rules['l']['r'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['l']['s'] = NOT_BEGIN
-digram_rules['l']['t'] = NOT_BEGIN | PREFIX
-digram_rules['l']['u'] = ANY_COMBINATION
-digram_rules['l']['v'] = NOT_BEGIN | PREFIX
-digram_rules['l']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['l']['x'] = ILLEGAL_PAIR
-digram_rules['l']['y'] = ANY_COMBINATION
-digram_rules['l']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['l']['ch'] = NOT_BEGIN | PREFIX
-digram_rules['l']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['l']['ph'] = NOT_BEGIN | PREFIX
-digram_rules['l']['rh'] = ILLEGAL_PAIR
-digram_rules['l']['sh'] = NOT_BEGIN | PREFIX
-digram_rules['l']['th'] = NOT_BEGIN | PREFIX
-digram_rules['l']['wh'] = ILLEGAL_PAIR
-digram_rules['l']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['l']['ck'] = ILLEGAL_PAIR
-
-digram_rules['m'] = dict()
-digram_rules['m']['a'] = ANY_COMBINATION
-digram_rules['m']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['m']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['m']['d'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['m']['e'] = ANY_COMBINATION
-digram_rules['m']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['m']['g'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['m']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['m']['i'] = ANY_COMBINATION
-digram_rules['m']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['m']['k'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['m']['l'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['m']['m'] = NOT_BEGIN
-digram_rules['m']['n'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['m']['o'] = ANY_COMBINATION
-digram_rules['m']['p'] = NOT_BEGIN
-digram_rules['m']['r'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['m']['s'] = NOT_BEGIN
-digram_rules['m']['t'] = NOT_BEGIN
-digram_rules['m']['u'] = ANY_COMBINATION
-digram_rules['m']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['m']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['m']['x'] = ILLEGAL_PAIR
-digram_rules['m']['y'] = ANY_COMBINATION
-digram_rules['m']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['m']['ch'] = NOT_BEGIN | PREFIX
-digram_rules['m']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['m']['ph'] = NOT_BEGIN
-digram_rules['m']['rh'] = ILLEGAL_PAIR
-digram_rules['m']['sh'] = NOT_BEGIN
-digram_rules['m']['th'] = NOT_BEGIN
-digram_rules['m']['wh'] = ILLEGAL_PAIR
-digram_rules['m']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['m']['ck'] = ILLEGAL_PAIR
-
-digram_rules['n'] = dict()
-digram_rules['n']['a'] = ANY_COMBINATION
-digram_rules['n']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['n']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['n']['d'] = NOT_BEGIN
-digram_rules['n']['e'] = ANY_COMBINATION
-digram_rules['n']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['n']['g'] = NOT_BEGIN | PREFIX
-digram_rules['n']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['n']['i'] = ANY_COMBINATION
-digram_rules['n']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['n']['k'] = NOT_BEGIN | PREFIX
-digram_rules['n']['l'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['n']['m'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['n']['n'] = NOT_BEGIN
-digram_rules['n']['o'] = ANY_COMBINATION
-digram_rules['n']['p'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['n']['r'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['n']['s'] = NOT_BEGIN
-digram_rules['n']['t'] = NOT_BEGIN
-digram_rules['n']['u'] = ANY_COMBINATION
-digram_rules['n']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['n']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['n']['x'] = ILLEGAL_PAIR
-digram_rules['n']['y'] = NOT_BEGIN
-digram_rules['n']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['n']['ch'] = NOT_BEGIN | PREFIX
-digram_rules['n']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['n']['ph'] = NOT_BEGIN | PREFIX
-digram_rules['n']['rh'] = ILLEGAL_PAIR
-digram_rules['n']['sh'] = NOT_BEGIN
-digram_rules['n']['th'] = NOT_BEGIN
-digram_rules['n']['wh'] = ILLEGAL_PAIR
-digram_rules['n']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['n']['ck'] = NOT_BEGIN | PREFIX
-
-digram_rules['o'] = dict()
-digram_rules['o']['a'] = ANY_COMBINATION
-digram_rules['o']['b'] = ANY_COMBINATION
-digram_rules['o']['c'] = ANY_COMBINATION
-digram_rules['o']['d'] = ANY_COMBINATION
-digram_rules['o']['e'] = ILLEGAL_PAIR
-digram_rules['o']['f'] = ANY_COMBINATION
-digram_rules['o']['g'] = ANY_COMBINATION
-digram_rules['o']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['o']['i'] = ANY_COMBINATION
-digram_rules['o']['j'] = ANY_COMBINATION
-digram_rules['o']['k'] = ANY_COMBINATION
-digram_rules['o']['l'] = ANY_COMBINATION
-digram_rules['o']['m'] = ANY_COMBINATION
-digram_rules['o']['n'] = ANY_COMBINATION
-digram_rules['o']['o'] = ANY_COMBINATION
-digram_rules['o']['p'] = ANY_COMBINATION
-digram_rules['o']['r'] = ANY_COMBINATION
-digram_rules['o']['s'] = ANY_COMBINATION
-digram_rules['o']['t'] = ANY_COMBINATION
-digram_rules['o']['u'] = ANY_COMBINATION
-digram_rules['o']['v'] = ANY_COMBINATION
-digram_rules['o']['w'] = ANY_COMBINATION
-digram_rules['o']['x'] = ANY_COMBINATION
-digram_rules['o']['y'] = ANY_COMBINATION
-digram_rules['o']['z'] = ANY_COMBINATION
-digram_rules['o']['ch'] = ANY_COMBINATION
-digram_rules['o']['gh'] = NOT_BEGIN
-digram_rules['o']['ph'] = ANY_COMBINATION
-digram_rules['o']['rh'] = ILLEGAL_PAIR
-digram_rules['o']['sh'] = ANY_COMBINATION
-digram_rules['o']['th'] = ANY_COMBINATION
-digram_rules['o']['wh'] = ILLEGAL_PAIR
-digram_rules['o']['qu'] = BREAK | NOT_END
-digram_rules['o']['ck'] = ANY_COMBINATION
-
-digram_rules['p'] = dict()
-digram_rules['p']['a'] = ANY_COMBINATION
-digram_rules['p']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['p']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['p']['d'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['p']['e'] = ANY_COMBINATION
-digram_rules['p']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['p']['g'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['p']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['p']['i'] = ANY_COMBINATION
-digram_rules['p']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['p']['k'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['p']['l'] = SUFFIX | NOT_END
-digram_rules['p']['m'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['p']['n'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['p']['o'] = ANY_COMBINATION
-digram_rules['p']['p'] = NOT_BEGIN | PREFIX
-digram_rules['p']['r'] = NOT_END
-digram_rules['p']['s'] = NOT_BEGIN | END
-digram_rules['p']['t'] = NOT_BEGIN | END
-digram_rules['p']['u'] = NOT_BEGIN | END
-digram_rules['p']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['p']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['p']['x'] = ILLEGAL_PAIR
-digram_rules['p']['y'] = ANY_COMBINATION
-digram_rules['p']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['p']['ch'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['p']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['p']['ph'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['p']['rh'] = ILLEGAL_PAIR
-digram_rules['p']['sh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['p']['th'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['p']['wh'] = ILLEGAL_PAIR
-digram_rules['p']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['p']['ck'] = ILLEGAL_PAIR
-
-digram_rules['r'] = dict()
-digram_rules['r']['a'] = ANY_COMBINATION
-digram_rules['r']['b'] = NOT_BEGIN | PREFIX
-digram_rules['r']['c'] = NOT_BEGIN | PREFIX
-digram_rules['r']['d'] = NOT_BEGIN | PREFIX
-digram_rules['r']['e'] = ANY_COMBINATION
-digram_rules['r']['f'] = NOT_BEGIN | PREFIX
-digram_rules['r']['g'] = NOT_BEGIN | PREFIX
-digram_rules['r']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['r']['i'] = ANY_COMBINATION
-digram_rules['r']['j'] = NOT_BEGIN | PREFIX
-digram_rules['r']['k'] = NOT_BEGIN | PREFIX
-digram_rules['r']['l'] = NOT_BEGIN | PREFIX
-digram_rules['r']['m'] = NOT_BEGIN | PREFIX
-digram_rules['r']['n'] = NOT_BEGIN | PREFIX
-digram_rules['r']['o'] = ANY_COMBINATION
-digram_rules['r']['p'] = NOT_BEGIN | PREFIX
-digram_rules['r']['r'] = NOT_BEGIN | PREFIX
-digram_rules['r']['s'] = NOT_BEGIN | PREFIX
-digram_rules['r']['t'] = NOT_BEGIN | PREFIX
-digram_rules['r']['u'] = ANY_COMBINATION
-digram_rules['r']['v'] = NOT_BEGIN | PREFIX
-digram_rules['r']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['r']['x'] = ILLEGAL_PAIR
-digram_rules['r']['y'] = ANY_COMBINATION
-digram_rules['r']['z'] = NOT_BEGIN | PREFIX
-digram_rules['r']['ch'] = NOT_BEGIN | PREFIX
-digram_rules['r']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['r']['ph'] = NOT_BEGIN | PREFIX
-digram_rules['r']['rh'] = ILLEGAL_PAIR
-digram_rules['r']['sh'] = NOT_BEGIN | PREFIX
-digram_rules['r']['th'] = NOT_BEGIN | PREFIX
-digram_rules['r']['wh'] = ILLEGAL_PAIR
-digram_rules['r']['qu'] = NOT_BEGIN | PREFIX | NOT_END
-digram_rules['r']['ck'] = NOT_BEGIN | PREFIX
-
-digram_rules['s'] = dict()
-digram_rules['s']['a'] = ANY_COMBINATION
-digram_rules['s']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['s']['c'] = NOT_END
-digram_rules['s']['d'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['s']['e'] = ANY_COMBINATION
-digram_rules['s']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['s']['g'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['s']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['s']['i'] = ANY_COMBINATION
-digram_rules['s']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['s']['k'] = ANY_COMBINATION
-digram_rules['s']['l'] = BEGIN | SUFFIX | NOT_END
-digram_rules['s']['m'] = SUFFIX | NOT_END
-digram_rules['s']['n'] = PREFIX | SUFFIX | NOT_END
-digram_rules['s']['o'] = ANY_COMBINATION
-digram_rules['s']['p'] = ANY_COMBINATION
-digram_rules['s']['r'] = NOT_BEGIN | NOT_END
-digram_rules['s']['s'] = NOT_BEGIN | PREFIX
-digram_rules['s']['t'] = ANY_COMBINATION
-digram_rules['s']['u'] = ANY_COMBINATION
-digram_rules['s']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['s']['w'] = BEGIN | SUFFIX | NOT_END
-digram_rules['s']['x'] = ILLEGAL_PAIR
-digram_rules['s']['y'] = ANY_COMBINATION
-digram_rules['s']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['s']['ch'] = BEGIN | SUFFIX | NOT_END
-digram_rules['s']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['s']['ph'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['s']['rh'] = ILLEGAL_PAIR
-digram_rules['s']['sh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['s']['th'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['s']['wh'] = ILLEGAL_PAIR
-digram_rules['s']['qu'] = SUFFIX | NOT_END
-digram_rules['s']['ck'] = NOT_BEGIN
-
-digram_rules['t'] = dict()
-digram_rules['t']['a'] = ANY_COMBINATION
-digram_rules['t']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['t']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['t']['d'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['t']['e'] = ANY_COMBINATION
-digram_rules['t']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['t']['g'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['t']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['t']['i'] = ANY_COMBINATION
-digram_rules['t']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['t']['k'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['t']['l'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['t']['m'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['t']['n'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['t']['o'] = ANY_COMBINATION
-digram_rules['t']['p'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['t']['r'] = NOT_END
-digram_rules['t']['s'] = NOT_BEGIN | END
-digram_rules['t']['t'] = NOT_BEGIN | PREFIX
-digram_rules['t']['u'] = ANY_COMBINATION
-digram_rules['t']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['t']['w'] = BEGIN | SUFFIX | NOT_END
-digram_rules['t']['x'] = ILLEGAL_PAIR
-digram_rules['t']['y'] = ANY_COMBINATION
-digram_rules['t']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['t']['ch'] = NOT_BEGIN
-digram_rules['t']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['t']['ph'] = NOT_BEGIN | END
-digram_rules['t']['rh'] = ILLEGAL_PAIR
-digram_rules['t']['sh'] = NOT_BEGIN | END
-digram_rules['t']['th'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['t']['wh'] = ILLEGAL_PAIR
-digram_rules['t']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['t']['ck'] = ILLEGAL_PAIR
-
-digram_rules['u'] = dict()
-digram_rules['u']['a'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['u']['b'] = ANY_COMBINATION
-digram_rules['u']['c'] = ANY_COMBINATION
-digram_rules['u']['d'] = ANY_COMBINATION
-digram_rules['u']['e'] = NOT_BEGIN
-digram_rules['u']['f'] = ANY_COMBINATION
-digram_rules['u']['g'] = ANY_COMBINATION
-digram_rules['u']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['u']['i'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['u']['j'] = ANY_COMBINATION
-digram_rules['u']['k'] = ANY_COMBINATION
-digram_rules['u']['l'] = ANY_COMBINATION
-digram_rules['u']['m'] = ANY_COMBINATION
-digram_rules['u']['n'] = ANY_COMBINATION
-digram_rules['u']['o'] = NOT_BEGIN | BREAK
-digram_rules['u']['p'] = ANY_COMBINATION
-digram_rules['u']['r'] = ANY_COMBINATION
-digram_rules['u']['s'] = ANY_COMBINATION
-digram_rules['u']['t'] = ANY_COMBINATION
-digram_rules['u']['u'] = ILLEGAL_PAIR
-digram_rules['u']['v'] = ANY_COMBINATION
-digram_rules['u']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['u']['x'] = ANY_COMBINATION
-digram_rules['u']['y'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['u']['z'] = ANY_COMBINATION
-digram_rules['u']['ch'] = ANY_COMBINATION
-digram_rules['u']['gh'] = NOT_BEGIN | PREFIX
-digram_rules['u']['ph'] = ANY_COMBINATION
-digram_rules['u']['rh'] = ILLEGAL_PAIR
-digram_rules['u']['sh'] = ANY_COMBINATION
-digram_rules['u']['th'] = ANY_COMBINATION
-digram_rules['u']['wh'] = ILLEGAL_PAIR
-digram_rules['u']['qu'] = BREAK | NOT_END
-digram_rules['u']['ck'] = ANY_COMBINATION
-
-digram_rules['v'] = dict()
-digram_rules['v']['a'] = ANY_COMBINATION
-digram_rules['v']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['d'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['e'] = ANY_COMBINATION
-digram_rules['v']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['g'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['i'] = ANY_COMBINATION
-digram_rules['v']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['k'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['l'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['m'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['n'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['o'] = ANY_COMBINATION
-digram_rules['v']['p'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['r'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['s'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['t'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['u'] = ANY_COMBINATION
-digram_rules['v']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['x'] = ILLEGAL_PAIR
-digram_rules['v']['y'] = NOT_BEGIN
-digram_rules['v']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['ch'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['ph'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['rh'] = ILLEGAL_PAIR
-digram_rules['v']['sh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['th'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['wh'] = ILLEGAL_PAIR
-digram_rules['v']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['v']['ck'] = ILLEGAL_PAIR
-
-digram_rules['w'] = dict()
-digram_rules['w']['a'] = ANY_COMBINATION
-digram_rules['w']['b'] = NOT_BEGIN | PREFIX
-digram_rules['w']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['w']['d'] = NOT_BEGIN | PREFIX | END
-digram_rules['w']['e'] = ANY_COMBINATION
-digram_rules['w']['f'] = NOT_BEGIN | PREFIX
-digram_rules['w']['g'] = NOT_BEGIN | PREFIX | END
-digram_rules['w']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['w']['i'] = ANY_COMBINATION
-digram_rules['w']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['w']['k'] = NOT_BEGIN | PREFIX
-digram_rules['w']['l'] = NOT_BEGIN | PREFIX | SUFFIX
-digram_rules['w']['m'] = NOT_BEGIN | PREFIX
-digram_rules['w']['n'] = NOT_BEGIN | PREFIX
-digram_rules['w']['o'] = ANY_COMBINATION
-digram_rules['w']['p'] = NOT_BEGIN | PREFIX
-digram_rules['w']['r'] = BEGIN | SUFFIX | NOT_END
-digram_rules['w']['s'] = NOT_BEGIN | PREFIX
-digram_rules['w']['t'] = NOT_BEGIN | PREFIX
-digram_rules['w']['u'] = ANY_COMBINATION
-digram_rules['w']['v'] = NOT_BEGIN | PREFIX
-digram_rules['w']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['w']['x'] = NOT_BEGIN | PREFIX
-digram_rules['w']['y'] = ANY_COMBINATION
-digram_rules['w']['z'] = NOT_BEGIN | PREFIX
-digram_rules['w']['ch'] = NOT_BEGIN
-digram_rules['w']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['w']['ph'] = NOT_BEGIN
-digram_rules['w']['rh'] = ILLEGAL_PAIR
-digram_rules['w']['sh'] = NOT_BEGIN
-digram_rules['w']['th'] = NOT_BEGIN
-digram_rules['w']['wh'] = ILLEGAL_PAIR
-digram_rules['w']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['w']['ck'] = NOT_BEGIN
-
-digram_rules['x'] = dict()
-digram_rules['x']['a'] = NOT_BEGIN
-digram_rules['x']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['d'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['e'] = NOT_BEGIN
-digram_rules['x']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['g'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['i'] = NOT_BEGIN
-digram_rules['x']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['k'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['l'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['m'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['n'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['o'] = NOT_BEGIN
-digram_rules['x']['p'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['r'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['s'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['t'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['u'] = NOT_BEGIN
-digram_rules['x']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['x'] = ILLEGAL_PAIR
-digram_rules['x']['y'] = NOT_BEGIN
-digram_rules['x']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['ch'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['ph'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['rh'] = ILLEGAL_PAIR
-digram_rules['x']['sh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['th'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['wh'] = ILLEGAL_PAIR
-digram_rules['x']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['x']['ck'] = ILLEGAL_PAIR
-
-digram_rules['y'] = dict()
-digram_rules['y']['a'] = ANY_COMBINATION
-digram_rules['y']['b'] = NOT_BEGIN
-digram_rules['y']['c'] = NOT_BEGIN | NOT_END
-digram_rules['y']['d'] = NOT_BEGIN
-digram_rules['y']['e'] = ANY_COMBINATION
-digram_rules['y']['f'] = NOT_BEGIN | NOT_END
-digram_rules['y']['g'] = NOT_BEGIN
-digram_rules['y']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['y']['i'] = BEGIN | NOT_END
-digram_rules['y']['j'] = NOT_BEGIN | NOT_END
-digram_rules['y']['k'] = NOT_BEGIN
-digram_rules['y']['l'] = NOT_BEGIN | NOT_END
-digram_rules['y']['m'] = NOT_BEGIN
-digram_rules['y']['n'] = NOT_BEGIN
-digram_rules['y']['o'] = ANY_COMBINATION
-digram_rules['y']['p'] = NOT_BEGIN
-digram_rules['y']['r'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['y']['s'] = NOT_BEGIN
-digram_rules['y']['t'] = NOT_BEGIN
-digram_rules['y']['u'] = ANY_COMBINATION
-digram_rules['y']['v'] = NOT_BEGIN | NOT_END
-digram_rules['y']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['y']['x'] = NOT_BEGIN
-digram_rules['y']['y'] = ILLEGAL_PAIR
-digram_rules['y']['z'] = NOT_BEGIN
-digram_rules['y']['ch'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['y']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['y']['ph'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['y']['rh'] = ILLEGAL_PAIR
-digram_rules['y']['sh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['y']['th'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['y']['wh'] = ILLEGAL_PAIR
-digram_rules['y']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['y']['ck'] = ILLEGAL_PAIR
-
-digram_rules['z'] = dict()
-digram_rules['z']['a'] = ANY_COMBINATION
-digram_rules['z']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['d'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['e'] = ANY_COMBINATION
-digram_rules['z']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['g'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['i'] = ANY_COMBINATION
-digram_rules['z']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['k'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['l'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['m'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['n'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['o'] = ANY_COMBINATION
-digram_rules['z']['p'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['r'] = NOT_BEGIN | NOT_END
-digram_rules['z']['s'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['t'] = NOT_BEGIN
-digram_rules['z']['u'] = ANY_COMBINATION
-digram_rules['z']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['w'] = SUFFIX | NOT_END
-digram_rules['z']['x'] = ILLEGAL_PAIR
-digram_rules['z']['y'] = ANY_COMBINATION
-digram_rules['z']['z'] = NOT_BEGIN
-digram_rules['z']['ch'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['ph'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['rh'] = ILLEGAL_PAIR
-digram_rules['z']['sh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['th'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['wh'] = ILLEGAL_PAIR
-digram_rules['z']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['z']['ck'] = ILLEGAL_PAIR
-
-digram_rules['ch'] = dict()
-digram_rules['ch']['a'] = ANY_COMBINATION
-digram_rules['ch']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['d'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['e'] = ANY_COMBINATION
-digram_rules['ch']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['g'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['i'] = ANY_COMBINATION
-digram_rules['ch']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['k'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['l'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['m'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['n'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['o'] = ANY_COMBINATION
-digram_rules['ch']['p'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['r'] = NOT_END
-digram_rules['ch']['s'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['t'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['u'] = ANY_COMBINATION
-digram_rules['ch']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['w'] = NOT_BEGIN | NOT_END
-digram_rules['ch']['x'] = ILLEGAL_PAIR
-digram_rules['ch']['y'] = ANY_COMBINATION
-digram_rules['ch']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['ch'] = ILLEGAL_PAIR
-digram_rules['ch']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['ph'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['rh'] = ILLEGAL_PAIR
-digram_rules['ch']['sh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['th'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['wh'] = ILLEGAL_PAIR
-digram_rules['ch']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ch']['ck'] = ILLEGAL_PAIR
-
-digram_rules['gh'] = dict()
-digram_rules['gh']['a'] = ANY_COMBINATION
-digram_rules['gh']['b'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['c'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['d'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['e'] = ANY_COMBINATION
-digram_rules['gh']['f'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['g'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['h'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['i'] = BEGIN | NOT_END
-digram_rules['gh']['j'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['k'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['l'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['m'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['n'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['o'] = BEGIN | NOT_END
-digram_rules['gh']['p'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['gh']['r'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['s'] = NOT_BEGIN | PREFIX
-digram_rules['gh']['t'] = NOT_BEGIN | PREFIX
-digram_rules['gh']['u'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['v'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['w'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['x'] = ILLEGAL_PAIR
-digram_rules['gh']['y'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['z'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['ch'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['gh'] = ILLEGAL_PAIR
-digram_rules['gh']['ph'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['rh'] = ILLEGAL_PAIR
-digram_rules['gh']['sh'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['th'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['wh'] = ILLEGAL_PAIR
-digram_rules['gh']['qu'] = NOT_BEGIN | BREAK | PREFIX | NOT_END
-digram_rules['gh']['ck'] = ILLEGAL_PAIR
-
-digram_rules['ph'] = dict()
-digram_rules['ph']['a'] = ANY_COMBINATION
-digram_rules['ph']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ph']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ph']['d'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ph']['e'] = ANY_COMBINATION
-digram_rules['ph']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ph']['g'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ph']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ph']['i'] = ANY_COMBINATION
-digram_rules['ph']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ph']['k'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ph']['l'] = BEGIN | SUFFIX | NOT_END
-digram_rules['ph']['m'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ph']['n'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ph']['o'] = ANY_COMBINATION
-digram_rules['ph']['p'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ph']['r'] = NOT_END
-digram_rules['ph']['s'] = NOT_BEGIN
-digram_rules['ph']['t'] = NOT_BEGIN
-digram_rules['ph']['u'] = ANY_COMBINATION
-digram_rules['ph']['v'] = NOT_BEGIN | NOT_END
-digram_rules['ph']['w'] = NOT_BEGIN | NOT_END
-digram_rules['ph']['x'] = ILLEGAL_PAIR
-digram_rules['ph']['y'] = NOT_BEGIN
-digram_rules['ph']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ph']['ch'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ph']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ph']['ph'] = ILLEGAL_PAIR
-digram_rules['ph']['rh'] = ILLEGAL_PAIR
-digram_rules['ph']['sh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ph']['th'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ph']['wh'] = ILLEGAL_PAIR
-digram_rules['ph']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ph']['ck'] = ILLEGAL_PAIR
-
-digram_rules['rh'] = dict()
-digram_rules['rh']['a'] = BEGIN | NOT_END
-digram_rules['rh']['b'] = ILLEGAL_PAIR
-digram_rules['rh']['c'] = ILLEGAL_PAIR
-digram_rules['rh']['d'] = ILLEGAL_PAIR
-digram_rules['rh']['e'] = BEGIN | NOT_END
-digram_rules['rh']['f'] = ILLEGAL_PAIR
-digram_rules['rh']['g'] = ILLEGAL_PAIR
-digram_rules['rh']['h'] = ILLEGAL_PAIR
-digram_rules['rh']['i'] = BEGIN | NOT_END
-digram_rules['rh']['j'] = ILLEGAL_PAIR
-digram_rules['rh']['k'] = ILLEGAL_PAIR
-digram_rules['rh']['l'] = ILLEGAL_PAIR
-digram_rules['rh']['m'] = ILLEGAL_PAIR
-digram_rules['rh']['n'] = ILLEGAL_PAIR
-digram_rules['rh']['o'] = BEGIN | NOT_END
-digram_rules['rh']['p'] = ILLEGAL_PAIR
-digram_rules['rh']['r'] = ILLEGAL_PAIR
-digram_rules['rh']['s'] = ILLEGAL_PAIR
-digram_rules['rh']['t'] = ILLEGAL_PAIR
-digram_rules['rh']['u'] = BEGIN | NOT_END
-digram_rules['rh']['v'] = ILLEGAL_PAIR
-digram_rules['rh']['w'] = ILLEGAL_PAIR
-digram_rules['rh']['x'] = ILLEGAL_PAIR
-digram_rules['rh']['y'] = BEGIN | NOT_END
-digram_rules['rh']['z'] = ILLEGAL_PAIR
-digram_rules['rh']['ch'] = ILLEGAL_PAIR
-digram_rules['rh']['gh'] = ILLEGAL_PAIR
-digram_rules['rh']['ph'] = ILLEGAL_PAIR
-digram_rules['rh']['rh'] = ILLEGAL_PAIR
-digram_rules['rh']['sh'] = ILLEGAL_PAIR
-digram_rules['rh']['th'] = ILLEGAL_PAIR
-digram_rules['rh']['wh'] = ILLEGAL_PAIR
-digram_rules['rh']['qu'] = ILLEGAL_PAIR
-digram_rules['rh']['ck'] = ILLEGAL_PAIR
-
-digram_rules['sh'] = dict()
-digram_rules['sh']['a'] = ANY_COMBINATION
-digram_rules['sh']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['sh']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['sh']['d'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['sh']['e'] = ANY_COMBINATION
-digram_rules['sh']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['sh']['g'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['sh']['h'] = ILLEGAL_PAIR
-digram_rules['sh']['i'] = ANY_COMBINATION
-digram_rules['sh']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['sh']['k'] = NOT_BEGIN
-digram_rules['sh']['l'] = BEGIN | SUFFIX | NOT_END
-digram_rules['sh']['m'] = BEGIN | SUFFIX | NOT_END
-digram_rules['sh']['n'] = BEGIN | SUFFIX | NOT_END
-digram_rules['sh']['o'] = ANY_COMBINATION
-digram_rules['sh']['p'] = NOT_BEGIN
-digram_rules['sh']['r'] = BEGIN | SUFFIX | NOT_END
-digram_rules['sh']['s'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['sh']['t'] = SUFFIX
-digram_rules['sh']['u'] = ANY_COMBINATION
-digram_rules['sh']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['sh']['w'] = SUFFIX | NOT_END
-digram_rules['sh']['x'] = ILLEGAL_PAIR
-digram_rules['sh']['y'] = ANY_COMBINATION
-digram_rules['sh']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['sh']['ch'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['sh']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['sh']['ph'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['sh']['rh'] = ILLEGAL_PAIR
-digram_rules['sh']['sh'] = ILLEGAL_PAIR
-digram_rules['sh']['th'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['sh']['wh'] = ILLEGAL_PAIR
-digram_rules['sh']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['sh']['ck'] = ILLEGAL_PAIR
-
-digram_rules['th'] = dict()
-digram_rules['th']['a'] = ANY_COMBINATION
-digram_rules['th']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['d'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['e'] = ANY_COMBINATION
-digram_rules['th']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['g'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['i'] = ANY_COMBINATION
-digram_rules['th']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['k'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['l'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['m'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['n'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['o'] = ANY_COMBINATION
-digram_rules['th']['p'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['r'] = NOT_END
-digram_rules['th']['s'] = NOT_BEGIN | END
-digram_rules['th']['t'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['u'] = ANY_COMBINATION
-digram_rules['th']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['w'] = SUFFIX | NOT_END
-digram_rules['th']['x'] = ILLEGAL_PAIR
-digram_rules['th']['y'] = ANY_COMBINATION
-digram_rules['th']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['ch'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['ph'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['rh'] = ILLEGAL_PAIR
-digram_rules['th']['sh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['th'] = ILLEGAL_PAIR
-digram_rules['th']['wh'] = ILLEGAL_PAIR
-digram_rules['th']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['th']['ck'] = ILLEGAL_PAIR
-
-digram_rules['wh'] = dict()
-digram_rules['wh']['a'] = BEGIN | NOT_END
-digram_rules['wh']['b'] = ILLEGAL_PAIR
-digram_rules['wh']['c'] = ILLEGAL_PAIR
-digram_rules['wh']['d'] = ILLEGAL_PAIR
-digram_rules['wh']['e'] = BEGIN | NOT_END
-digram_rules['wh']['f'] = ILLEGAL_PAIR
-digram_rules['wh']['g'] = ILLEGAL_PAIR
-digram_rules['wh']['h'] = ILLEGAL_PAIR
-digram_rules['wh']['i'] = BEGIN | NOT_END
-digram_rules['wh']['j'] = ILLEGAL_PAIR
-digram_rules['wh']['k'] = ILLEGAL_PAIR
-digram_rules['wh']['l'] = ILLEGAL_PAIR
-digram_rules['wh']['m'] = ILLEGAL_PAIR
-digram_rules['wh']['n'] = ILLEGAL_PAIR
-digram_rules['wh']['o'] = BEGIN | NOT_END
-digram_rules['wh']['p'] = ILLEGAL_PAIR
-digram_rules['wh']['r'] = ILLEGAL_PAIR
-digram_rules['wh']['s'] = ILLEGAL_PAIR
-digram_rules['wh']['t'] = ILLEGAL_PAIR
-digram_rules['wh']['u'] = ILLEGAL_PAIR
-digram_rules['wh']['v'] = ILLEGAL_PAIR
-digram_rules['wh']['w'] = ILLEGAL_PAIR
-digram_rules['wh']['x'] = ILLEGAL_PAIR
-digram_rules['wh']['y'] = BEGIN | NOT_END
-digram_rules['wh']['z'] = ILLEGAL_PAIR
-digram_rules['wh']['ch'] = ILLEGAL_PAIR
-digram_rules['wh']['gh'] = ILLEGAL_PAIR
-digram_rules['wh']['ph'] = ILLEGAL_PAIR
-digram_rules['wh']['rh'] = ILLEGAL_PAIR
-digram_rules['wh']['sh'] = ILLEGAL_PAIR
-digram_rules['wh']['th'] = ILLEGAL_PAIR
-digram_rules['wh']['wh'] = ILLEGAL_PAIR
-digram_rules['wh']['qu'] = ILLEGAL_PAIR
-digram_rules['wh']['ck'] = ILLEGAL_PAIR
-
-digram_rules['qu'] = dict()
-digram_rules['qu']['a'] = ANY_COMBINATION
-digram_rules['qu']['b'] = ILLEGAL_PAIR
-digram_rules['qu']['c'] = ILLEGAL_PAIR
-digram_rules['qu']['d'] = ILLEGAL_PAIR
-digram_rules['qu']['e'] = ANY_COMBINATION
-digram_rules['qu']['f'] = ILLEGAL_PAIR
-digram_rules['qu']['g'] = ILLEGAL_PAIR
-digram_rules['qu']['h'] = ILLEGAL_PAIR
-digram_rules['qu']['i'] = ANY_COMBINATION
-digram_rules['qu']['j'] = ILLEGAL_PAIR
-digram_rules['qu']['k'] = ILLEGAL_PAIR
-digram_rules['qu']['l'] = ILLEGAL_PAIR
-digram_rules['qu']['m'] = ILLEGAL_PAIR
-digram_rules['qu']['n'] = ILLEGAL_PAIR
-digram_rules['qu']['o'] = ANY_COMBINATION
-digram_rules['qu']['p'] = ILLEGAL_PAIR
-digram_rules['qu']['r'] = ILLEGAL_PAIR
-digram_rules['qu']['s'] = ILLEGAL_PAIR
-digram_rules['qu']['t'] = ILLEGAL_PAIR
-digram_rules['qu']['u'] = ILLEGAL_PAIR
-digram_rules['qu']['v'] = ILLEGAL_PAIR
-digram_rules['qu']['w'] = ILLEGAL_PAIR
-digram_rules['qu']['x'] = ILLEGAL_PAIR
-digram_rules['qu']['y'] = ILLEGAL_PAIR
-digram_rules['qu']['z'] = ILLEGAL_PAIR
-digram_rules['qu']['ch'] = ILLEGAL_PAIR
-digram_rules['qu']['gh'] = ILLEGAL_PAIR
-digram_rules['qu']['ph'] = ILLEGAL_PAIR
-digram_rules['qu']['rh'] = ILLEGAL_PAIR
-digram_rules['qu']['sh'] = ILLEGAL_PAIR
-digram_rules['qu']['th'] = ILLEGAL_PAIR
-digram_rules['qu']['wh'] = ILLEGAL_PAIR
-digram_rules['qu']['qu'] = ILLEGAL_PAIR
-digram_rules['qu']['ck'] = ILLEGAL_PAIR
-
-digram_rules['ck'] = dict()
-digram_rules['ck']['a'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['b'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['c'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['d'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['e'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['f'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['g'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['h'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['i'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['j'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['k'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['l'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['m'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['n'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['o'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['p'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['r'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['s'] = NOT_BEGIN
-digram_rules['ck']['t'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['u'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['v'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['w'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['x'] = ILLEGAL_PAIR
-digram_rules['ck']['y'] = NOT_BEGIN
-digram_rules['ck']['z'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['ch'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['gh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['ph'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['rh'] = ILLEGAL_PAIR
-digram_rules['ck']['sh'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['th'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['wh'] = ILLEGAL_PAIR
-digram_rules['ck']['qu'] = NOT_BEGIN | BREAK | NOT_END
-digram_rules['ck']['ck'] = ILLEGAL_PAIR
-
-###############################################################################
-# END DIGRAM RULES
-###############################################################################
-
-
-def marked(flag, first_unit, second_unit):
-    return digram_rules[first_unit][second_unit] & flag
-
-
-
-# Generates a random word, as well as its hyphenated form.  The
-# length of the returned word will be between minlen and maxlen.
-
-def generate_password_shazel(minlen = MIN_LENGTH_PASSWORD,
-                      maxlen = MAX_LENGTH_PASSWORD):
-
-    if (minlen > maxlen):
-        raise PasswordGenerationException("minlen minlen is greater than maxlen maxlen.")
-
-    #
-    # Check for zero length words.  This is technically not an error,
-    # so we take the short cut and return empty words.
-    #
-    if (maxlen == 0):
-        raise PasswordGenerationException("maxlen must be greater than 0.")
-
-
-    word = ''
-    for i in range(MAX_UNACCEPTABLE):
-        results = _random_word(random.randint(minlen, maxlen))
-        word = results[0]
-        hyphenated_word = results[1]
-        if (word != ''):
-            break
-
-
-    if (word == "" and (minlen > 0)):
-        raise PasswordGenerationException("failed to generate an acceptable random password.")
-
-
-
-    return (word, hyphenated_word)
-
-
-
-# Selects a random element from an array.
-
-def random_element(ar):
-
-    try:
-        keys = ar.keys()
-    except:
-        keys = range(len(ar))
-    return ar[ keys[random.randint(0, len(keys) - 1)] ]
-
-
-
-
-# This is the routine that returns a random word.  It collects random
-# syllables until a predetermined word length is found.  If a retry
-# threshold is reached, another word is tried.
-
-def _random_word(pwlen):
-
-    word = ''
-    word_syllables = []
-
-    max_retries = (4 * pwlen) + len(grams)
-
-    tries = 0 # count of retries.
-
-
-    # word_units used to be an array of indices into the 'rules' C-array.
-    # now it's an array of actual units (grams).
-    word_units = []
-
-
-    saved_pair = []
-    #
-    # Find syllables until the entire word is constructed.
-    #
-    while(len(word) < pwlen):
-        #
-        # Get the syllable and find its length.
-        #
-
-        new_syllable, syllable_units, saved_pair = get_syllable(pwlen - len(word), saved_pair)
-
-        #
-        # Append the syllable units to the word units.
-        #
-        word_units = word_units + list(syllable_units)
-
-        #
-        # If the word has been improperly formed, throw out
-        # the syllable.  The checks performed here are those
-        # that must be formed on a word basis.  The other
-        # tests are performed entirely within the syllable.
-        # Otherwise, append the syllable to the word.
-        #
-        if not (
-            _improper_word(word_units)
-             or
-            (
-                 word == ''
-                 and
-                 _have_initial_y(syllable_units)
-            )
-             or
-             (
-                 len(word + new_syllable) == pwlen
-                 and
-                 _have_final_split(syllable_units)
-            )
-           ):
-            word = word + new_syllable
-            word_syllables.append(new_syllable)
-
-
-        #
-        # Keep track of the times we have tried to get syllables.
-        # If we have exceeded the threshold, start from scratch.
-        #
-        tries = tries + 1
-        if (tries > max_retries):
-            tries = 0
-            word = ''
-            word_syllables = []
-            word_units = []
-
-
-
-    return (word, '-'.join(word_syllables))
-
-
-
-
-# Selects a gram (aka "unit").  This is the standard random unit
-# generating routine for get_syllable().
-#
-# This routine attempts to return grams (units) with a distribution
-# approaching that of the distribution of the units in English.
-#
-# The distribution of the units may be altered in this procedure
-# without affecting the digram table or any other programs using the
-# random_word function, as long as the set of grams (units) is kept
-# consistent throughout this library.
-
-def _random_unit(type):
-
-    if (type & VOWEL):
-        # Sometimes, we are asked to explicitly get a vowel (i.e., if
-        # a digram pair expects one following it).  This is a
-        # shortcut to do that and avoid looping with rejected
-        # consonants.
-        return random_element(vowel_numbers)
-    else:
-        # Get any letter according to the English distribution.
-        return random_element(numbers)
-
-
-
-
-
-
-# Check that the word does not contain illegal combinations
-# that may span syllables.  Specifically, these are:
-#
-#  1. An illegal pair of units between syllables.
-#  2. Three consecutive vowel units.
-#  3. Three consecutive consonant units.
-#
-# The checks are made against units (1 or 2 letters), not against
-# the individual letters, so three consecutive units can have
-# the length of 6 at most.
-
-def _improper_word(units):
-
-    failure = 0
-
-    for unit_count in range(len(units)):
-        #
-        # Check for ILLEGAL_PAIR.
-        # This should have been caught for units within a syllable,
-        # but in some cases it would have gone unnoticed for units between syllables
-        # (e.g., when saved units in get_syllable() were not used).
-        #
-        if (unit_count > 0
-            and digram_rules[units[unit_count-1]][units[unit_count]]
-            & ILLEGAL_PAIR):
-            return 1 # Failure!
-
-
-        if (unit_count >= 2):
-
-
-            #
-            # Check for consecutive vowels or consonants.  Because the
-            # initial y of a syllable is treated as a consonant rather
-            # than as a vowel, we exclude y from the first vowel in the
-            # vowel test.  The only problem comes when y ends a syllable
-            # and two other vowels start the next, like fly-oint.  Since
-            # such words are still pronounceable, we accept this.
-            #
-
-            #
-            # Vowel check.
-            #
-            if ((
-                (gram_rules[units[unit_count - 2]] & VOWEL)
-                and
-                not (gram_rules[units[unit_count - 2]] & ALTERNATE_VOWEL)
-                and
-                (gram_rules[units[unit_count - 1]] & VOWEL)
-                and
-                (gram_rules[units[unit_count    ]] & VOWEL)
-                )
-            or
-            #
-            # Consonant check.
-            #
-                (
-                not (gram_rules[units[unit_count - 2]] & VOWEL)
-                and
-                not (gram_rules[units[unit_count - 1]] & VOWEL)
-                and
-                not (gram_rules[units[unit_count    ]] & VOWEL)
-                )):
-                return 1 # Failure!
-
-
-
-    return 0 # success
-
-
-
-# Treating y as a vowel is sometimes a problem.  Some words get
-# formed that look irregular.  One special group is when y starts a
-# word and is the only vowel in the first syllable.  The word ycl is
-# one example.  We discard words like these.
-
-def _have_initial_y(units):
-
-    vowel_count = 0
-    normal_vowel_count = 0
-
-    for unit_count in range(len(units)):
-        #
-        # Count vowels.
-        #
-        units = list(units)
-        if (gram_rules[units[unit_count]] & VOWEL):
-            vowel_count = vowel_count + 1
-
-            #
-            # Count the vowels that are not:
-            #  1. 'y'
-            #  2. at the start of the word.
-            #
-            if (not (gram_rules[units[unit_count]] & ALTERNATE_VOWEL) or (unit_count > 0)):
-                normal_vowel_count = normal_vowel_count + 1
-
-
-
-
-    return (vowel_count <= 1) and (normal_vowel_count == 0)
-
-
-
-# Besides the problem with the letter y, there is one with a silent e
-# at the end of words, like face or nice.  We allow this silent e,
-# but we do not allow it as the only vowel at the end of the word or
-# syllables like ble will be generated.
-
-def _have_final_split(units):
-
-    vowel_count = 0
-
-    #
-    # Count all the vowels in the word.
-    #
-    for unit_count in range(len(units)):
-        units = list(units)
-        if (gram_rules[units[unit_count]] & VOWEL):
-            vowel_count = vowel_count + 1
-
-
-
-    #
-    # Return TRUE iff the only vowel was e, found at the end if the word.
-    #
-    return ((vowel_count == 1)
-             and (gram_rules[units[len(units) - 1]] & NO_FINAL_SPLIT))
-
-
-
-
-def digram_is_invalid(first_unit, second_unit, current_unit_num,
-                      length_left, units_in_syllable, vowel_count):
-
-    #
-    # Reject ILLEGAL_PAIRS of units.
-    #
-    if (marked(ILLEGAL_PAIR,
-                first_unit,
-                second_unit)):
-        return 1
-
-
-    #
-    # Reject units that will be split between
-    # syllables when the syllable has no vowels
-    # in it.
-    #
-    if (marked(BREAK,
-                first_unit,
-                second_unit) and
-        (vowel_count == 0)):
-        return 1
-
-
-    #
-    # Reject a unit that will end a syllable when
-    # no previous unit was a vowel and neither is
-    # this one.
-    #
-    if (marked(END,
-                first_unit,
-                second_unit) and
-        (vowel_count == 0) and
-        not (gram_rules[second_unit] & VOWEL)):
-        return 1
-
-
-    if (current_unit_num == 1):
-        #
-        # Reject the unit if we are at the starting
-        # digram of a syllable and it does not fit.
-        #
-        if (marked(NOT_BEGIN,
-                    first_unit,
-                    second_unit)):
-            return 1
-
-    else:
-        # We are not at the start of a syllable.
-
-        #
-        # Do not allow syllables where the first letter is y
-        # and the next pair can begin a syllable.  This may
-        # lead to splits where y is left alone in a syllable.
-        # Also, the combination does not sound to good even
-        # if not split.
-        #
-        if ((current_unit_num == 2) and
-            marked(BEGIN,
-                    first_unit,
-                    second_unit) and
-            (gram_rules[units_in_syllable[0]] &
-              ALTERNATE_VOWEL)):
-            return 1
-
-
-        #
-        # If this is the last unit of a word, we
-        # should reject any digram that cannot end a
-        # syllable.
-        #
-        if (marked(NOT_END,
-                    first_unit,
-                    second_unit) and
-            (length_left == 0)):
-            return 1
-
-
-        #
-        # Reject the unit if the digram it forms wants
-        # to break the syllable, but the resulting
-        # digram that would end the syllable is not
-        # allowed to end a syllable.
-        #
-        if (marked(BREAK,
-                    first_unit,
-                    second_unit) and
-            (digram_rules[units_in_syllable[current_unit_num-2]]
-              [first_unit] & NOT_END)):
-            return 1
-
-
-
-        #
-        # Reject the unit if the digram it forms
-        # expects a vowel preceding it and there
-        # is none.
-        #
-        if (marked(PREFIX,
-                    first_unit,
-                    second_unit) and
-            not (gram_rules[ units_in_syllable[current_unit_num-2] ] &
-               VOWEL)):
-            return 1
-
-
-
-    return 0
-
-
-
-# Generate next unit to password, making sure that it follows these rules:
-#
-# 1. Each syllable must contain exactly 1 or 2 consecutive vowels,
-# where y is considered a vowel.
-#
-# 2. Syllable end is determined as follows:
-#
-#    a. Vowel is generated and previous unit is a consonant and
-#       syllable already has a vowel.  In this case, new syllable is
-#       started and already contains a vowel.
-#    b. A pair determined to be a "break" pair is encountered.
-#       In this case new syllable is started with second unit of this pair.
-#    c. End of password is encountered.
-#    d. "begin" pair is encountered legally.  New syllable is started
-#    with this pair.
-#    e. "end" pair is legally encountered.  New syllable has nothing yet.
-#
-# 3. Try generating another unit if:
-#
-#    a. third consecutive vowel and not y.
-#    b. "break" pair generated but no vowel yet in current or
-#       previous 2 units are "not_end".
-#    c. "begin" pair generated but no vowel in syllable preceding begin pair,
-#       or both previous 2 pairs are designated "not_end".
-#    d. "end" pair generated but no vowel in current syllable or in
-#       "end" pair.
-#    e. "not_begin" pair generated but new syllable must begin
-#       (because previous syllable ended as defined in 2 above).
-#    f. vowel is generated and 2a is satisfied, but no syllable break
-#       is possible in previous 3 pairs.
-#    g. Second and third units of syllable must begin, and first unit
-#       is "alternate_vowel".
-
-def get_syllable(pwlen, saved_pair):
-
-    #
-    # This is needed if the saved_pair is tried and the syllable then
-    # discarded because of the retry limit. Since the saved_pair is OK and
-    # fits in nicely with the preceding syllable, we will always use it.
-    #
-    hold_saved_pair = saved_pair
-
-    max_retries = (4 * pwlen) + len(grams)
-
-    max_loops = 100
-    num_loops = 0
-
-    #
-    # Loop until valid syllable is found.
-    #
-    while True:  # do: ftso python while: not PEP 315.
-        #
-        # Try for a new syllable.  Initialize all pertinent
-        # syllable variables.
-        #
-
-        syllable = ""               # string, returned
-        units_in_syllable = dict()  # array of units, returned
-
-        # grams:
-        unit = ''
-        current_unit = 0
-        last_unit = ''
-
-        # numbers:
-        vowel_count = 0
-        tries = 0
-        length_left = pwlen
-
-        # flags:
-        rule_broken = 0
-        want_vowel = 0
-        want_another_unit = 1
-
-        saved_pair = hold_saved_pair
-
-        #
-        # This loop finds all the units for the syllable.
-        #
-        while True:  # do: ftso python while: not PEP 315.
-            want_vowel = 0
-
-            #
-            # This loop continues until a valid unit is found for the
-            # current position within the syllable.
-            #
-            while True:  # do: ftso python while: not PEP 315.
-                rule_broken = 0
-                #
-                # If there are saved units from the previous
-                # syllable, use them up first.
-                #
-
-                #
-                # If there were two saved units, the first is
-                # guaranteed (by checks performed in the previous
-                # syllable) to be valid.  We ignore the checks and
-                # place it in this syllable manually.
-                #
-                if (len(saved_pair) == 2):
-                    syllable = saved_pair.pop()
-                    units_in_syllable[0] = syllable
-                    if (gram_rules[syllable] & VOWEL):
-                        vowel_count = vowel_count + 1
-
-                    current_unit = current_unit + 1
-                    length_left -= len(syllable)
-
-
-                if (len(saved_pair) > 0):
-                    #
-                    # The unit becomes the last unit checked in the
-                    # previous syllable.
-                    #
-                    unit = saved_pair.pop()
-
-                    #
-                    # The saved units have been used.  Do not try to
-                    # reuse them in this syllable (unless this
-                    # particular syllable is rejected at which point
-                    # we start to rebuild it with these same saved
-                    # units).
-                    #
-                else:
-                    #
-                    # If we don't have to consider the saved units,
-                    # we generate a random one.
-                    #
-                    if (want_vowel):
-                        unit = _random_unit(VOWEL)
-                    else:
-                        unit = _random_unit(NO_SPECIAL_RULE)
-
-
-
-                length_left -= len(unit)
-
-                rule_broken = 0
-                #
-                # Prevent having a word longer than expected.
-                #
-                if (length_left < 0):
-                    rule_broken = 1
-
-
-                #
-                # First unit of syllable.  This is special because
-                # the digram tests require 2 units and we don't have
-                # that yet.  Nevertheless, we can perform some
-                # checks.
-                #
-                if (current_unit == 0):
-                    #
-                    # If this shouldn't begin a syllable, don't use it.
-                    #
-                    if (gram_rules[unit] & NOT_BEGIN_SYLLABLE):
-                        rule_broken = 1
-                    elif (length_left == 0):
-                        #
-                        # If this is the last unit of a word, we have
-                        # a one unit syllable.  Since each syllable
-                        # must have a vowel, we make sure the unit is
-                        # a vowel.  Otherwise, we discard it.
-                        #
-                        if (gram_rules[unit] & VOWEL):
-                            want_another_unit = 0
-                        else:
-                            rule_broken = 1
-
-
-                else:
-
-                    #
-                    # We are not at the start of a syllable.
-                    # Save the previous unit for later tests.
-                    #
-                    last_unit = units_in_syllable[current_unit-1]
-
-                    #
-                    # There are some digram tests that are
-                    # universally true.  We test them out.
-                    #
-
-                    if (digram_is_invalid(last_unit,
-                                               unit,
-                                               current_unit,
-                                               length_left,
-                                               units_in_syllable,
-                                               vowel_count)):
-                        rule_broken = 1
-
-
-                    #
-                    # The following checks occur when the current
-                    # unit is a vowel and we are not looking at a
-                    # word ending with an e.
-                    #
-                    if (not rule_broken and
-                        (gram_rules[unit] & VOWEL) and
-                        ((length_left > 0)
-                          or not (gram_rules[last_unit] & NO_FINAL_SPLIT))):
-                        #
-                        # Don't allow 3 consecutive vowels in a
-                        # syllable.  Although some words formed
-                        # like this are OK, like "beau", most are
-                        # not.
-                        #
-                        if ((vowel_count > 1) and
-                            (gram_rules[last_unit] & VOWEL)):
-                            rule_broken = 1
-
-                        #
-                        # Check for the case of
-                        # vowels-consonants-vowel, which is only
-                        # legal if the last vowel is an e and we
-                        # are the end of the word (which is not
-                        # happening here due to a previous
-                        # check).
-                        #
-                        elif ((vowel_count != 0) and not (gram_rules[last_unit] & VOWEL)):
-                            #
-                            # Try to save the vowel for the next
-                            # syllable, but if the syllable left here
-                            # is not proper (i.e., the resulting last
-                            # digram cannot legally end it), just
-                            # discard it and try for another.
-                            #
-                            if (digram_rules[ units_in_syllable[ current_unit - 2] ][last_unit] & NOT_END):
-                                rule_broken = 1
-                            else:
-                                saved_pair = [unit]
-                                want_another_unit = 0
-
-
-
-
-
-                    #
-                    # The unit picked and the digram formed are legal.
-                    # We now determine if we can end the syllable.  It may,
-                    # in some cases, mean the last unit(s) may be deferred to
-                    # the next syllable.  We also check here to see if the
-                    # digram formed expects a vowel to follow.
-                    #
-                    if (not rule_broken and want_another_unit):
-                        if ((vowel_count != 0) and
-                           (gram_rules[unit] & NO_FINAL_SPLIT) and
-                           (length_left == 0) and
-                           not (gram_rules[last_unit] & VOWEL)):
-
-                            #
-                            # This word ends in a silent e.
-                            #
-
-                            want_another_unit = 0
-                        elif (marked(END,
-                                     last_unit,
-                                     unit)
-                              or (length_left == 0)):
-
-                            #
-                            # This syllable ends either because the
-                            # digram is a END pair or we would
-                            # otherwise exceed the length of the
-                            # word.
-                            #
-
-                            want_another_unit = 0
-                        elif (vowel_count != 0 and length_left > 0):
-                            #
-                            # Since we have a vowel in the syllable
-                            # already, if the digram calls for the end of the
-                            # syllable, we can legally split it off. We also
-                            # make sure that we are not at the end of the
-                            # dangerous because that syllable may not have
-                            # vowels, or it may not be a legal syllable end,
-                            # and the retrying mechanism will loop infinitely
-                            # with the same digram.
-                            #
-
-                            #
-                            # If we must begin a syllable, we do so if
-                            # the only vowel in THIS syllable is not part
-                            # of the digram we are pushing to the next
-                            # syllable.
-                            #
-                            if (marked(BEGIN,
-                                        last_unit,
-                                        unit) and
-                                (current_unit > 1) and
-                                not ((vowel_count == 1) and
-                                   (gram_rules[last_unit] & VOWEL))):
-                                saved_pair = [unit, last_unit]
-                                want_another_unit = 0
-                            elif (
-                                marked(BREAK,
-                                       last_unit,
-                                       unit)):
-                                saved_pair = [unit]
-                                want_another_unit = 0
-
-                        elif (
-                            marked(SUFFIX,
-                                   last_unit,
-                                   unit)):
-                            want_vowel = 1
-
-
-
-
-                tries = tries + 1
-
-                #
-                # If this unit was illegal, redetermine the amount of
-                # letters left to go in the word.
-                #
-                if (rule_broken):
-                    length_left += len(unit)
-
-                if not (rule_broken and tries <= max_retries):
-                    break
-
-
-            #
-            # The unit fit OK.
-            #
-            if (tries <= max_retries):
-                #
-                # If the unit were a vowel, count it in.  However, if
-                # the unit were a y and appear at the start of the
-                # syllable, treat it like a constant (so that words
-                # like "year" can appear and not conflict with the 3
-                # consecutive vowel rule).
-                #
-                if (
-                    (gram_rules[unit] & VOWEL)
-                and
-                    ((current_unit > 0) or not (gram_rules[unit] & ALTERNATE_VOWEL))
-               ):
-                    vowel_count = vowel_count + 1
-
-
-                #
-                # If a unit or units were to be saved, we must adjust
-                # the syllable formed.  Otherwise, we append the
-                # current unit to the syllable.
-                #
-                if (len(saved_pair) == 2):
-                    syllable = syllable[0:
-                                        len(syllable) -
-                                        len(last_unit)]
-                    length_left += len(last_unit)
-                    current_unit -= 2
-
-                elif (len(saved_pair) == 1):
-                    current_unit = current_unit - 1
-
-                else:
-                    units_in_syllable[ current_unit ] = unit
-                    syllable = syllable + unit
-
-            else:
-                #
-                # Whoops!  Too many tries.  We set rule_broken so we
-                # can loop in the outer loop and try another
-                # syllable.
-                #
-
-                rule_broken = 1
-
-
-            current_unit = current_unit + 1
-            if not (tries <= max_retries and want_another_unit):
-                break
-
-        num_loops = num_loops + 1
-
-        if not ((rule_broken or _illegal_placement(units_in_syllable))):
-            break
-
-    return (syllable, units_in_syllable.values(), saved_pair)
-
-
-
-
-# goes through an individual syllable and checks for illegal
-# combinations of letters that go beyond looking at digrams.
-#
-# We look at things like 3 consecutive vowels or consonants, or
-# syllables with consonants between vowels (unless one of them is the
-# final silent e).
-
-def _illegal_placement(units):
-
-    vowel_count = 0
-    failure = 0
-
-    for unit_count in range(len(units)):
-        if (failure):
-            break
-
-
-        if (unit_count >= 1):
-            #
-            # Don't allow vowels to be split with consonants in a
-            # single syllable.  If we find such a combination (except
-            # for the silent e) we have to discard the syllable.
-            #
-            if (
-                (
-                    not (gram_rules[units[unit_count-1]] & VOWEL)
-                 and
-                     (gram_rules[units[unit_count  ]] & VOWEL)
-                 and
-                    not ((gram_rules[units[unit_count  ]] & NO_FINAL_SPLIT) and (unit_count == len(units)))
-                 and
-                     vowel_count
-                )
-             or
-
-                 #
-                 # Perform these checks when we have at least 3 units.
-                 #
-                 (
-                     (unit_count >= 2)
-                 and
-                     (
-                         #
-                         # Disallow 3 consecutive consonants.
-                         #
-                         (
-                             not (gram_rules[units[unit_count-2]] & VOWEL)
-                         and
-                             not (gram_rules[units[unit_count-1]] & VOWEL)
-                         and
-                             not (gram_rules[units[unit_count]] & VOWEL)
-                        )
-                     or
-
-                         #
-                         # Disallow 3 consecutive vowels, where the
-                         # first is not a y.
-                         #
-                         (
-                             (gram_rules[units[unit_count-2]] & VOWEL)
-                         and
-                             not ((gram_rules[units[0]] & ALTERNATE_VOWEL)
-                                  and (unit_count == 2))
-                         and
-                             (gram_rules[units[unit_count-1]] & VOWEL)
-                         and
-                             (gram_rules[units[unit_count]] & VOWEL)
-                        )
-                    )
-                )
-            ):
-                    failure = 1
-
-
-
-        #
-        # Count the vowels in the syllable.  As mentioned somewhere
-        # above, exclude the initial y of a syllable.  Instead, treat
-        # it as a consonant.
-        #
-        if (
-            (gram_rules[units[unit_count]] & VOWEL)
-        and
-            not (
-                (gram_rules[units[0]] & ALTERNATE_VOWEL)
-            and
-                (unit_count == 0)
-            and
-                (len(units) > 1)
-           )
-       ):
-            vowel_count = vowel_count + 1
-
-
-
-    return failure