Project.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import shutil\n",
    "from IPython.display import display, Image as im\n",
    "import unittest\n",
    "\n",
    "import numpy as np\n",
    "from numpy import array\n",
    "from PIL import Image, ImageDraw\n",
    "np.seterr(divide='ignore', invalid='ignore')\n",
    "\n",
    "string_mode = True\n",
    "ncc_mode = True\n",
    "width = 10\n",
    "top = 3\n",
    "threshold = 3\n",
    "delete_threshold = 100\n",
    "bin_ratio = 600\n",
    "\n",
    "binary_path = os.getcwd() + '/binary/'\n",
    "found_path = os.getcwd() + '/found/'\n",
    "cutted_path = os.getcwd() + '/cutted/'\n",
    "lines_path = found_path + 'lines/'\n",
    "\n",
    "def_input_address = 'test.png'\n",
    "def_examples_path = os.getcwd() + '/examples/'\n",
    "def_empty_threshold = 65\n",
    "def_lines_threshold = 20\n",
    "\n",
    "bin_examples = []\n",
    "names = []\n",
    "nccors = []\n",
    "spaces = []\n",
    "\n",
    "RESULT = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def ui(def_input_address, def_examples_path, def_empty_threshold, \n",
    "       def_lines_threshold): #inputs check\n",
    "    \"\"\"\n",
    "    User interface receives the defaults. The user can define values \n",
    "    or they will be returned by default.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    input_address = input('Enter the image address (default is ' + \n",
    "                          def_input_address + ') :')\n",
    "    if input_address == '': \n",
    "        input_address = def_input_address\n",
    "\n",
    "    examples_path = input('Enter the path to folder with samples ' +\n",
    "                          '(default is ' + def_examples_path + '):')\n",
    "    if examples_path == '': \n",
    "        examples_path = def_examples_path\n",
    "    \n",
    "    empty_threshold = input('Enter the distance between letters ' +\n",
    "                            '(default is ' + str(def_empty_threshold) + \n",
    "                            ') [px]:')\n",
    "    if empty_threshold == '': \n",
    "        empty_threshold = def_empty_threshold\n",
    "        \n",
    "    empty_lines_threshold = input('Enter the distance between lines ' +\n",
    "                                  '(default is ' + \n",
    "                                  str(def_lines_threshold) + ') [px]:')\n",
    "    if empty_lines_threshold == '': \n",
    "        empty_lines_threshold = def_lines_threshold\n",
    "    \n",
    "    erase_flag = input('Clear examples after the previous ' + \n",
    "                       'preprocessing? [y/N]:')\n",
    "    return (erase_flag, input_address, examples_path, \n",
    "            empty_threshold, empty_lines_threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def create_folders(examples_path, binary_path, found_path, \n",
    "                   cutted_path, lines_path):\n",
    "    \"\"\"\n",
    "    The function creates folders that will be filled by generated images.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    folders = [examples_path, binary_path, found_path, cutted_path]\n",
    "    names = ['examples','binary','found','cutted']\n",
    "    for i in range(len(folders)):\n",
    "        if not os.path.exists(folders[i]):\n",
    "            os.mkdir(names[i])\n",
    "            f = os.getcwd() + '/' + names[i] + '/'\n",
    "    \n",
    "    if not os.path.exists(lines_path):\n",
    "            os.mkdir(found_path + 'lines/')\n",
    "            f = found_path + 'lines/'\n",
    "                \n",
    "    for d, dirs, files in os.walk(examples_path):\n",
    "            for f in dirs:\n",
    "                if not os.path.exists(binary_path + f):\n",
    "                    os.mkdir(binary_path + f)\n",
    "                    os.mkdir(cutted_path + f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def delete_folders(binary_path, found_path, cutted_path):\n",
    "    \"\"\"\n",
    "    The function deletes the folders that were filled by generated images.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    folders = [binary_path, found_path, cutted_path]\n",
    "    for f in folders:\n",
    "        if os.path.exists(f):   \n",
    "            shutil.rmtree(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def binarization(input_img_addr):\n",
    "    \"\"\"\n",
    "    The function takes an image and saves a copy in which all pixels \n",
    "    are only black or white in /binary.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    #convert to 'RGBA' for .gif opening fix\n",
    "    input_image  = Image.open(input_img_addr).convert('RGBA')\n",
    "    draw = ImageDraw.Draw(input_image)\n",
    "     \n",
    "    for i in range(input_image.size[0]):\n",
    "        for j in range(input_image.size[1]):\n",
    "            r, g, b, a = input_image.getpixel((i, j))\n",
    "            if a == 0:\n",
    "                r, g, b = 0, 0, 0\n",
    "            if (r + g + b > bin_ratio): \n",
    "                r, g, b = 255, 255, 255\n",
    "            else:\n",
    "                r, g, b = 0, 0, 0 \n",
    "            draw.point((i, j), (r, g, b))\n",
    "    del draw\n",
    "    \n",
    "    input_img_addr = input_img_addr[:-4] + '.png'\n",
    "    input_image.save(input_img_addr.replace('/examples/', \n",
    "                                            '/binary/'), \"PNG\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def separation(input_img_addr, threshold, \n",
    "               empty_threshold, empty_lines_threshold):\n",
    "    \"\"\"\n",
    "    The function takes the image, cuts it into rows by a horizontal lines \n",
    "    if the line and previous [empty_lines_threshold] lines contained \n",
    "    less than [threshold] black pixels in each. \n",
    "    The resulting images are saved in /found/lines. \n",
    "    Function cuts the images from /found/lines on the characters by a vertical \n",
    "    lines if the previous line and [empty_threshold] lines contained less \n",
    "    than [threshold] black pixels in each.\n",
    "    The resulting images are saved in /found.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    global spaces\n",
    "    \n",
    "    input_image = Image.open(input_img_addr).convert('L')\n",
    "    \n",
    "    x0 = 0\n",
    "    y0 = 0\n",
    "    x1 = 0\n",
    "    y1 = 0\n",
    "\n",
    "    symbolsx = []\n",
    "    symbolsy = []\n",
    "\n",
    "    black = 0\n",
    "    symbol = False\n",
    "    empty = 0\n",
    "    \n",
    "    if string_mode:\n",
    "        for y in range(input_image.size[1]):\n",
    "            for x in range(input_image.size[0]):\n",
    "                pix = input_image.getpixel((x, y))\n",
    "                if pix < 255:\n",
    "                    black += 1\n",
    "            if symbol == True and black < threshold:\n",
    "                empty += 1\n",
    "            if symbol == False and black > threshold:\n",
    "                y0 = y\n",
    "                symbol = True\n",
    "            if (symbol == True and black <= threshold and \n",
    "                empty >= int(empty_lines_threshold)):\n",
    "                y1 = y\n",
    "                symbol = False\n",
    "                symbolsy.append((y0, y1))\n",
    "                empty = 0\n",
    "            black = 0\n",
    "    \n",
    "        if symbolsx == []:\n",
    "            symbolsx = [(0, input_image.size[0])] \n",
    "        if symbolsy == []:\n",
    "            symbolsy = [(0, input_image.size[1])] \n",
    "\n",
    "        count = 0\n",
    "\n",
    "        for y in symbolsy:\n",
    "            for x in symbolsx:\n",
    "                if count < 1000:\n",
    "                    temp = '{:03d}'.format(count)\n",
    "                    addr = found_path + '/lines/' + str(temp) + '.png'\n",
    "                    input_image.crop((x[0], y[0], \n",
    "                                      x[1], y[1])).save(addr, \"PNG\")\n",
    "                count += 1\n",
    "                \n",
    "    \n",
    "    lines = os.listdir(found_path + '/lines')\n",
    "    scount = 0\n",
    "    try:\n",
    "        for l in sorted(lines):\n",
    "            input_image = Image.open(found_path + \n",
    "                                     'lines/' + l).convert('L')\n",
    "            \n",
    "            x0 = 0\n",
    "            y0 = 0\n",
    "            x1 = 0\n",
    "            y1 = 0\n",
    "\n",
    "            symbolsx = []\n",
    "            symbolsy = []\n",
    "\n",
    "            black = 0\n",
    "            symbol = False\n",
    "            empty = 0\n",
    "\n",
    "            for x in range(input_image.size[0]):\n",
    "                for y in range(input_image.size[1]):\n",
    "                    pix = input_image.getpixel((x, y))\n",
    "                    if pix < 255:\n",
    "                        black += 1\n",
    "                if symbol == True and black < threshold:\n",
    "                    empty += 1\n",
    "                if symbol == False and black > threshold: \n",
    "                    x0 = x\n",
    "                    symbol = True\n",
    "                if (symbol == True and black <= threshold and \n",
    "                    empty >= int(empty_threshold)):\n",
    "                    x1 = x\n",
    "                    symbol = False\n",
    "                    scount+=1\n",
    "                    symbolsx.append((x0, x1))\n",
    "                    empty = 0\n",
    "                black = 0\n",
    "\n",
    "\n",
    "            if symbolsx == []:\n",
    "                symbolsx = [(0, input_image.size[0])] \n",
    "            if symbolsy == []:\n",
    "                symbolsy = [(0, input_image.size[1])] \n",
    "\n",
    "            for y in symbolsy:\n",
    "                for x in symbolsx:\n",
    "                    if count < 1000:\n",
    "                        temp = '{:03d}'.format(count)\n",
    "                        addr = 'found/' + str(temp) + '.png'\n",
    "                        input_image.crop((x[0], y[0], \n",
    "                                          x[1], y[1])).save(addr, \"PNG\")\n",
    "                    count += 1\n",
    "            spaces.append(scount)\n",
    "    except IOError:\n",
    "            pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def delete_trash(threshold):\n",
    "    \"\"\"\n",
    "    The function deletes the images from /found if the number \n",
    "    of black pixels in it less than [delete_threshold].\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    images = os.listdir(found_path)\n",
    "    for i in range(len(images)):\n",
    "        try:\n",
    "            black = 0\n",
    "            input_image = Image.open(found_path + images[i])\n",
    "            \n",
    "            for x in range(input_image.size[0]):\n",
    "                for y in range(input_image.size[1]):\n",
    "                    pix = input_image.getpixel((x, y))\n",
    "                    if pix != 255:\n",
    "                        black += 1\n",
    "            if black < threshold:\n",
    "                os.remove(found_path + images[i])\n",
    "        except IOError:\n",
    "            pass        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def ncc(input_img_addr, example_addr): \n",
    "    \"\"\"\n",
    "    Function treat pixels of two images as vectors, normalizes them, \n",
    "    then takes their dot product.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    global width\n",
    "    input_image = Image.open(input_img_addr)\n",
    "    wpercent = (width / float(input_image.size[0]))\n",
    "    height = int((float(input_image.size[1]) * float(wpercent)))\n",
    "    input_image = input_image.resize((width,height),Image.ANTIALIAS)\n",
    "    example = Image.open(example_addr).resize((input_image.size[0],\n",
    "                                               input_image.size[1]), \n",
    "                                              Image.ANTIALIAS)\n",
    "    \n",
    "    images = [input_image, example]\n",
    "    vectors = []\n",
    "    norms = []\n",
    "    for image in images:\n",
    "        vector = []\n",
    "        for pixel in image.getdata():\n",
    "            vector.append(np.mean(pixel))\n",
    "        vectors.append(vector)\n",
    "        norms.append(np.linalg.norm(vector, 2))\n",
    "    a, b = vectors\n",
    "    a_norm, b_norm = norms\n",
    "    res = np.dot(a / a_norm, b / b_norm)\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def compare_1to1(input_img_addr, example_addr):\n",
    "    \"\"\"\n",
    "    Comparison of 1 to 1. Helper function for filling in the results list.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    input_img_addr = found_path + input_img_addr\n",
    "    naive_cut(input_img_addr)\n",
    "\n",
    "    if ncc_mode:\n",
    "        nccors.append(ncc(input_img_addr, example_addr))\n",
    "    \n",
    "    names.append(example_addr.replace(cutted_path, '')[:-4]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def compare_1toN(input_img_addr):\n",
    "    \"\"\"\n",
    "    The function calls the 1-to-1 for the found character and all examples.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    global names, nccors, bin_examples\n",
    "    names, nccors = [], []\n",
    "    \n",
    "    for i in range(len(bin_examples)):\n",
    "        try:\n",
    "            compare_1to1(input_img_addr, bin_examples[i])\n",
    "        except IOError:\n",
    "            pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def result_1toN():\n",
    "    \"\"\"\n",
    "    Function fills lists comparison results for each symbol.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    results = []\n",
    "    \n",
    "    if ncc_mode and nccors != []:\n",
    "        results.append(names[nccors.index(max(nccors))])\n",
    "    \n",
    "    if results == []:\n",
    "        results = ['']\n",
    "        \n",
    "    temp = max(set(results), key=results.count)\n",
    "    display(im(filename=binary_path + temp + '.png'))\n",
    "    for d, dirs, files in os.walk(examples_path):\n",
    "        for f in dirs:\n",
    "            temp = temp.replace(f, '')\n",
    "            temp = temp.replace('/', '') \n",
    "    return temp "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def print_top(top, tmp_arr, flag):\n",
    "    \"\"\"\n",
    "    The function prints the top [top] of the local results.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    for i in range(top):\n",
    "        if flag == 'max':\n",
    "            tmp = max(tmp_arr)\n",
    "        if flag == 'min':\n",
    "            tmp = min(tmp_arr)  \n",
    "            \n",
    "        print(str(i + 1) + \". :\" + str(names[tmp_arr.index(max(tmp_arr))]) +\n",
    "              \" scores: \" + str(max(tmp_arr)))\n",
    "        tmp_arr.remove(max(tmp_arr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def print_1toN(top):\n",
    "    \"\"\"\n",
    "    The function prints a general result of the character recognition.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    print('Results:')\n",
    "    if ncc_mode and nccors != []:\n",
    "        print('NCC mode:')\n",
    "        print_top(top, nccors, 'max')\n",
    "    print('Result:' + str(RESULT))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def naive_cut(img_address):\n",
    "    \"\"\"\n",
    "    The function cuts the image on all sides by removing rows and columns in which \n",
    "    no black pixels.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    img = Image.open(img_address).convert('L')\n",
    "    arr = array(img)\n",
    "    norm_arr = []\n",
    "    find = False\n",
    "\n",
    "    for c in range(4):\n",
    "        black = 0\n",
    "        find = False\n",
    "        #img = Image.fromarray(arr)\n",
    "        for x in range(len(arr[:, 1])):\n",
    "            if find:\n",
    "                break\n",
    "            for y in range(len(arr[1, :])):\n",
    "                if arr[x, y] == 0:\n",
    "                    black += 1\n",
    "            if black >= 1:\n",
    "                arr = np.delete(arr, np.s_[0:x], axis=0)\n",
    "                find = True\n",
    "                break\n",
    "        arr = np.rot90(arr)\n",
    "        c += 1 \n",
    "        \n",
    "    \n",
    "    img = Image.fromarray(arr)\n",
    "    img.save(img_address.replace('binary', 'cutted'),\"PNG\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def main():\n",
    "    \"\"\"\n",
    "    The program takes a recognizable image and databases address.\n",
    "    All images become a binary, then a recognizable image is cut, character by character.\n",
    "    Images are cut and reduced, and then compared with each other and displayed the most \n",
    "    similar result.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    global RESULT, input_address, empty_threshold, spaces\n",
    "    global empty_lines_threshold, examples_path, top, bin_examples\n",
    "    \n",
    "    (erase_flag, input_address, examples_path, empty_threshold, \n",
    "     empty_lines_threshold) = ui(def_input_address, def_examples_path, \n",
    "                                 def_empty_threshold, def_lines_threshold)\n",
    "    RESULT = ''\n",
    "    \n",
    "    try:\n",
    "        binarization(input_address)\n",
    "    except IOError:\n",
    "        print('Error. Input image is not found.')\n",
    "        return 0\n",
    "    \n",
    "    input_address = input_address[:-4] + '.png'\n",
    "    display(im(filename=input_address))  \n",
    "    \n",
    "    if (erase_flag == 'y' or erase_flag == 'Y' or \n",
    "        not os.path.exists(binary_path)):\n",
    "        delete_folders(binary_path, found_path, cutted_path)\n",
    "        create_folders(examples_path, binary_path, \n",
    "                       found_path, cutted_path, lines_path)\n",
    "        examples = []\n",
    "        \n",
    "        for d, dirs, files in os.walk(examples_path):\n",
    "            for f in files:\n",
    "                path = os.path.join(d, f)\n",
    "                examples.append(path)   \n",
    "                \n",
    "        for i in range(len(examples)):\n",
    "            try:\n",
    "                binarization(examples[i])\n",
    "                naive_cut(examples[i].replace('/examples/', '/binary/'))\n",
    "            except IOError:\n",
    "                pass\n",
    "    \n",
    "        for d, dirs, files in os.walk(cutted_path):\n",
    "            for f in files:\n",
    "                path = os.path.join(d, f)\n",
    "                bin_examples.append(path)\n",
    "    else:                \n",
    "        if os.path.exists(found_path):\n",
    "            shutil.rmtree(found_path)\n",
    "        create_folders(examples_path, binary_path, found_path, \n",
    "                       cutted_path, lines_path)\n",
    "        \n",
    "        for d, dirs, files in os.walk(cutted_path):\n",
    "            for f in files:\n",
    "                path = os.path.join(d, f)\n",
    "                bin_examples.append(path)\n",
    "            \n",
    "    separation(input_address, threshold, \n",
    "               empty_threshold, empty_lines_threshold)\n",
    "    delete_trash(delete_threshold)\n",
    "        \n",
    "    symbols = os.listdir(found_path)\n",
    "    count = 0\n",
    "    for i in sorted(symbols):\n",
    "        try:\n",
    "            count += 1\n",
    "            print('Processing:')\n",
    "            try:\n",
    "                display(im(filename=found_path + i))\n",
    "            except:\n",
    "                pass\n",
    "            compare_1toN(i)\n",
    "            RESULT += result_1toN().replace('0','')\n",
    "            print_1toN(top)\n",
    "            print('Processed: ' + str(count) + \n",
    "                  '/' + str(len(symbols) - 1))\n",
    "            if count in spaces: RESULT += ' '\n",
    "        except IOError:\n",
    "            pass\n",
    "    print('Message: ' + RESULT)\n",
    "    RESULT = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the image address (default is test.png) :\n",
      "Enter the path to folder with samples (default is /home/cel/UJ/Python/gctranslator/examples/):\n",
      "Enter the distance between letters (default is 65) [px]:\n",
      "Enter the distance between lines (default is 20) [px]:\n",
      "Clear examples after the previous preprocessing? [y/N]:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAx0AAAIDCAYAAABhMnPMAAAcVUlEQVR4nO3dbbOjqBYG0Hjr/P+/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\nlR4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAALUAAACQCAAAAABrWXXwAAACa0lEQVR4nO3czW7DMAwDYKXo+79y\ndtjWYfmzZIsUE5inYYfkA6u4Dpp2We2GeVUDujLVvNxT/Tazxez7mvz8kZ7kUyzrsvkPwJ1+iv2E\nbE8xnvwjvvIPuc3+DMPnvOfViFcjXswDde5pIBP4Rhz0L6CrZs71PqgFCqqGrarAuQa+E8y5/h/k\nmy5MDd0poNTY7Q1IDd6TYdTojSREDd/9AtZr/I59rtc/IVSdr2ag09UUdLaag05Wk9C5ahY6VU1D\nZ6p56EQ1EZ2nZqLT1FR0lpqLTlKT0TlqNjpFTUcn3BXwzYy7AsTnU8PqVtWQD9VG1Q40wD2oLml6\nVF2EHlNXLB9mNrbyVTU9om4WDXxeBrdeIx/y6VbXjYf1q0vRnXNdOdNmqLlGP7jWpa4dD+tTl6N7\n1PXoDrUAOq5WQIfVEujgel29Tv8md71mPWAcUmuMh8XUMuiIWgcdUAuh/WoltFtddmN7GOd6LdW0\nt2sxtE+thnaptWbazDXXck17uhZEt9WK6KZaEt1Sa6Kvr0aVm4Bdhu4Kyr5leKD+WETHwy671kVf\nqIXR52pl9KlaGn2m1kaffKNKHH3ctTr6UK23n96m43OZ8qZ73tEF0HG1AjqslkBH1RrooFoEHVOr\noENqGXRErYMOqIXQfrUS+uHfqJKq2rl70jI7u1ZDP3iu5ap2zLWe2dG1IrqplkTf9Gq8nmvNphtd\nq6Iv1bLox821btMXXSujT9XS6EfNtXbTJ12row/V8uibzvVrXyy+asDvTuaj84+4rPf8ZdLxY/Bz\n06uxGtCVqeZlqnmZal6mmpep5mWqeZlqXqaaly9YV1w+jW2nggAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKUAAACWCAYAAAC/xUjZAAADhUlEQVR4nO3cwXLaUBBE0SaV//9l\nsohJsA1GtqQ33TP3rLygCizdamSZ4nK9Xq8CjPyqfgHAR0QJO0QJO0QJO0QJO0QJO0QJO0QJO0QJ\nO0QJO0QJO0QJO0QJO79XPtnlcvn387MPJ215DPZzPheXFR9du//lfoI4j5NwLiLevvceSPyVchxP\njzLlQHR31HlYcT4jlhKzEOUAae9WMVGmHVgXicdt6S0hrJMY403MUmIOomwoeSUlomwnPUiJa8o2\nOsR4w1LCDlE20GklJaKM1y1IiSijdQxSIspYXYOUiDJS5yAloozTPUiJ+5QxJsR4w1LCDlEGmLSS\nElHamxakRJTWJgYpEaWtqUFKRGlpcpASUdqZHqRElFYI8i+iNEGQ/xGlAYJ8jyiLEeRnRFmIIB8j\nyiIE+RxRFiDIrxHlYgT5GlEuRJDb8CHfBYjxe1jKAdK+M54oT1a9kmlBSkR5Kqcgk+IkypM4BZmG\nKE9AkPsQ5cGqg+yAW0IHqg4yfSFviPIA1TFKfYKUePtuoVOQElHuVr2S3YKUiHIXgjwH15Q/UB2j\n1DdIiaWM1DlIiSi/rXoluwcpEeW3EOQaRLkRQa5DlBsQ5FpE+QJBrkeUXyDIGtynfKA6RmlukBJL\naWlykBJRflK9ktODlIjyHYL0QJRvCNIHUYog3YyPkiD9jI6yOkg8NvY+ZXWQLORzI5eSIL2Ni5Ig\n/Y2KsjpIbDPmmrI6SBZyuxFLSZBZ2kdJkHlaR0mQmdpGSZC52v2hUx2jRJB7tV3KKgS5X0yUW052\n9UoS5DFionyFIPtoESVB9hIfJUH2Ex0lQfYUGyVB9hUT5X2EBNlbTJQ3BNlfVJTVQWKNdv9mPAsL\nuU7UUlYhyLWI8gWCXI8ov0CQNYjyCYKsQ5QPEGQtovyAIOsR5R2C9ECUbwjSB1GKIN2Mj5Ig/YyP\nEn5GR8lKehr5gQxi9DZuKQnS37go4W9UlKxkhhHXlMSYpf1SEmSe1lESZKbWUSJTy2tKFjJbu6Uk\nyHytoiTIHlpFiR5aXFOykL3ELyVB9hMdJUH2FB0leoq8pmQhe4tbSoLsLypKgpwhKkrMcHqUR60b\nK+lhxXmIWEqCPEbKcbxcF77S++8sf/a0Wx6D/ZzPxdIogS0i3r4xC1HCDlHCDlHCDlHCDlHCDlHC\nDlHCDlHCDlHCDlHCDlHCDlHCDlHCDlHCzh+dMxZPQrIBXQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results:\n",
      "NCC mode:\n",
      "1. :1/h scores: 1.0\n",
      "2. :1/w scores: 0.909726030622\n",
      "3. :1/g scores: 0.904388427825\n",
      "Result:h\n",
      "Processed: 1/12\n",
      "Processing:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAF0AAACQCAAAAABPbDh1AAABJ0lEQVR4nO3a0Q6DIAyF4bbZ+78y\nu1IBhWA9W7bk74VbHH6UYTA0erEPRmxf/BO6l9bWDiXMzPxIXDuE6EUpHydPycdZE/Kvi3N+nlo3\ny8x4LGXq1fGWfvuKx3qfpA/O53RZLOml+3ymD5TEPbPUquTw64mSLWXxnfW9Cl2HcbaEown1A6PX\nW74oOwtree1A9tXW5bRdruXC+IFVDB0dHR0dHR0dHR0d/af1veo23/N5bkO45e77YYDXBde7+vxK\nX2k00VtGFv98z7S6elsfNTvCS7bvowoxr0d4alzUONDR0dHR0dHR0dHR0dHR0beoq276kkH7fuTI\n9+mv44gaH6Zwm230Nfwv3tPrIj/b38h9raz2pOo2b5b7f6i6oaOjo6Ojo5uZvQHUnzAXPXrCuwAA\nAABJRU5ErkJggg==\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEcAAACQCAYAAABai3aIAAACQklEQVR4nO3dwW6DMBAAUVz1/3+Z\nniohlEwCuxt7o5ljpUJ4cRyQcBj7vu+bPexn9gtYOXEgcSBxIHEgcSBxIHEgcaB0nDFG9ian9Zu1\noSPKM6BuVyrhkTPGeHu0dBtVIZw7B9sJ6DZO5CC7AN3CyTi4DkBpE/Kdxhhpk/Qj7Oi2L4+cFd/x\nZ68p+lo9CYSm40Tf3Vf/H9n+dJyVa4/zatKNTMrTcSovKT7+bbVijxAy0Kee52RWMQIvj5xuV9aR\npn6sVoe+hZNxUKvDbFtg5HQ4uGihj9UdoH3f28CG55wrB9oF5b+Ur/LjQZ+vZbqBHEs/z+mMce4r\nzpCrEgcSBxIHEgcSBxIHEgcSBxIHEgcSBxIHEgcSBxIHEgcSBxIHEgcSBxIHEgcSBxIHEgcSBxIH\nEgcSBxIHEgcSBxIHEgcSB0q/YXLW3aTH/WbtM3XkPFoy+IkFs+d9XPmVBCoNZ9aqYdpvi9XBKy63\nficnZEgc6CM4XW/5T8N5BlANQ9uP7ntU/HBr5g94XN3vtuW9ISU435ITMiQOJA4kDiQOJA4kDiQO\nJA4kDiQOJA4kDiQOJA4kDiQOJA4kDiQOJA4kDiQOJA4kDiQOJA4kDiQOJA4kDiQOJA4kDiQOJA4k\nDiQOJA4kDiQOJA4kDlS6ALb7soqS55Wf/1aNVPV89JSP1cw1nJX7bj3nVD79ddua41TXGqd6LmuN\nU10KTuUi1EhLLoCdUcX5lY/HhZxzIHEgcSBxIHEgcSBxIHEgcSBxIHEgcaA/m2iMJTXZ/AoAAAAA\nSUVORK5CYII=\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results:\n",
      "NCC mode:\n",
      "1. :2/a scores: 1.0\n",
      "2. :2/b scores: 0.976608116641\n",
      "3. :2/b scores: 0.968681499718\n",
      "Result:ha\n",
      "Processed: 2/12\n",
      "Processing:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHgAAACQCAAAAADmGPDhAAABmElEQVR4nO2bwRLCIAxEodP//2U8\nOK20Eoh0A6ndHBy1Do9dkpRWjSnMiWUSl2CCCSaYYIIJfjJ43Z/F1kexm6QmToqr07jfGndbdRV8\nW6sPjtVUnKy9nOJLNkJ1MPQVxxLSPmQ9X5L4ohOcjaLOVIB8fXJdrZ8S+CMZPHoLrLEunxIi0c5W\nD5Pc00AglbWcxxoluUMxppVs4JZkuBG7YrUOUO8sWF0Sh195BzuQ2ipn76DOUg4U6wJ2WvagWF5k\ni272o2LcBigHS5JN2regWGABd3yS1bH4FBirdCDid7Q6cChIRc7EQx0be1sDNwI6Lx9W+wGn3F1s\nBlTKKb0fjPa7ZfCA9C5aPaKsjuC3uwduPBzDxcnqcS2kVU5ml1LqOsbffJkUBEsBT3f3igkmmGAU\nGH+69K74L+9zEewD/Lxyeh6YDYRggnFgu2/ahDC7ReDe6vFgK6/9Kt4CndZtsJHX/q2eB7b4yc2M\nUIBtssuzYhvJrhWbSPatOIQAl60DG3gd+Q8vggkmmGCCCSaYYIIJJphggr/iBXhFPQ+5SHMsAAAA\nAElFTkSuQmCC\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEwAAACVCAYAAADyphzMAAAClElEQVR4nO3cwU7DMBAAUQfx/78c\nDqhSQVR4Etu7684ckWjT17WTQtTjPM+zWXcf0QdQLcFggsEEgwkGEwwmGEwwmGAwwWCCwQSDCQYT\nDCYYTDCYYDDBYILBBIMJBhMMJhhMMJhgMMFggsE+Rz3QcRyjHupyK24T6QLLgNHT1eMk0P8uySpY\nq3IPa2woBGuDl6T32/1s2FnyudXId/ZZeqxdS5I8aMRErnzO7j3sPM+uA4s6q15Bu/I7eNPPjEa6\nOpXbnCVXvUmXwHqnrMKk0S5PWKbLDfrG3Dn26UtytynbZg/r7e7KuAXW++Q7TdlbTdiIffc2WPSU\nrZ7eIROW6Yz5qlHHuHRJjp6GiL3xrfawEQ0DW72XkccZuWU4YbDtwUafkLYHG91QsFX7WOQnh60n\nbMb14XCw2VMW/bk0dMJmvvhZnz7ClyRBi56u1ib9X5L2DJH9c2kKsOdGTNFM9PAlWa0pYNmX1Z22\nm7DZb9Z2YLMTDJYWrPfml9+/M7tUlxV/veDHzzJctLYWCFb1TBqyJKtitTYR7NXyuoLVsxxXvQlT\nl2TlSXpV2rPkoyyb/aP0YD2lvCnYvhMMJhisPNjqM3F5sNUJBhMMJhhMMJhgMMFggsFKg0X8+ag0\nWESlwbxPv0CCwQSDCQYrDeZlRYEEgwkGKw3mhWuBBIMJBhMMJhhMMFh5sJLfjDKzbHcxpgfLlmCw\nEmCZlmUJsExtAbbyTFkGLMuyLAOWJcFg24Cl/mrld64UWIaNvxRYhsqBRU9ZObDoSoJFTllJsMi2\nAVs1dWXBopZlqi/6oHm7U4EEgwkGEwwmGEwwmGAwwWCCwQSDCQYTDCYYTDCYYDDBYILBBIMJBhMM\nJhhMMJhgMMFggsG+ANo9uPNuzEX9AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results:\n",
      "NCC mode:\n",
      "1. :3/p scores: 0.998821039119\n",
      "2. :14/t scores: 0.895534505299\n",
      "3. :8/x scores: 0.887534550751\n",
      "Result:hap\n",
      "Processed: 3/12\n",
      "Processing:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHkAAACQCAAAAAAJ2pvfAAAA1klEQVR4nO3Y2xKCIBAAUGn8/1+m\nh7KSSUpdyfTsi4KOZ0Aus6TuHvl2SV0l8usbufbmF3EZF6vwh6fr5LUNWS6HtmqW3DBm9Xbov/jd\nCFv+seBZ1TDI5KPKqdgdn7P0MdPLqqCV7Iy9vR+5to7Hbt52DDL5OHI/3EzuHGVl1Hpyxt7+k7xq\nyyy2YfTjYh6a9bZ5oRldIU8cWmyR0O9mbJPJwZEanoCN44y9TSaTyWQymUwmk8lkMplMJpPJZDKZ\nTCaTyWQymUwmk8lkMplMJpPJZPLx5CutMxUi4ye4LwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAE0AAAA6CAYAAAD1LtTJAAABF0lEQVR4nO3aUZKCMBAAUWJ5/yvH\nA6gMdpgBp/r97i5gb9BEMuacc9NPHldfwD8yGmA0wGiA0QCjAUYDjAY8o18YY+z+fG9uHP1thk/X\ns/IaPkkbaVcEqzpvWrTOq7N2I62CHwRAu9uz4rztbs+K84ZTjsgd37uyr8n3NMBogNEAowFGA4wG\nGA0I52krX/0cnZ0fmVetHuvMlYIjDTAaYDQgNVr1urTqfCPaAHPHBfnZbvOMoDOjAUYDjAYYDTAa\nYDRg+cFKxYJ+9ZhnzzUdaYDRgHYPiyu0G2l/vdWqs+VPz2/mnOF/PWNUVGyASYu2bXlbS6/eMOjt\nCRgNMBpgNMBogNGA8GmU3jnSAKMBRgOMBhgNMBrwAm08QoSGepD2AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results:\n",
      "NCC mode:\n",
      "1. :4/p scores: 1.0\n",
      "2. :4/h scores: 0.762450931114\n",
      "3. :18/f scores: 0.749991236423\n",
      "Result:happ\n",
      "Processed: 4/12\n",
      "Processing:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHwAAACQCAAAAADv81CbAAABuElEQVR4nO3Z2w7CIAwG4Jbs/V+5\nXqjQQtmIKzXGnwtFs/BxLNtgoe+l8kUbOHDgTuIv4kwczq/iXD/ycTZfuTgPmTyc3WwOztMf+/EX\nJ/Gb7/JSEyLRdUnFmeL1BVz6bJh+kC3PG1h5Rpj9Y+7G0Nbg2KY/29OVNraR6/88ueKT5I752Pzw\niT7HFc99RSKroXARHUe4frI1A+dd13LFN7PTbSYQJ2rN50172QlOqvnsrrK4fm+4LtMtX0wmojem\ncauuZ2eJR631o9NqmTWmSgu9u9a5ml3v/dtUybhRo146Wv16E40KG2yND+U5N22jeb8WxS/FxJWx\nl4P6vUxaoHT9j8lE4Nfp1QX9HnO7FmVWRBfa3ercx2dJm5teWZXzvlu7z/k0HdeXELXgFtsFi/ie\njv+R1yIb0sl8MzuLmXkStKmujvmWx+T/HfMyHTcxX3vwyyvmtbtdL5bJ9Mk4gShX98mbcQ/KOXkp\nLpV06lM8LOvEqT6xtGmXd9hlHpe8G9U0PDv9cWwHDhw4cODAgQMHDhw4cODAgQMHDhw4cODAgQMH\nDhw4cODAgQMHDhw4cODAgQP/QfwBIfRfLYnHlFMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFMAAABTCAYAAADjsjsAAAACaUlEQVR4nO2aS47EIAwFYTT3vzKz\nSqsVhWDjZ4yZV8sWoUnF5uOkttZaIRB+ogdwEpQJhDKBUCYQygRCmUAoEwhlAqFMIJQJhDKBUCYQ\nygRCmUAoEwhlAjlKZq019P+PkXmJrLWGST1C5pO8CKHpZb5JWy00tUyJrJVC08rUSFolNKXMGTkr\nhKaT+SaltVYiPwNIJ7PHt8SeUO/oPEbmXVSE0HQyNWm8WuivtQPJwNDzWGutu1E/fs70OOJJo25l\ndFbLV3CWAaEiqDeGe//SdhbC5kxUtEat3E+EL0ASqVcbj0xASofLvDbO2g1076buvz+1s86fKNwj\nUyNVKsoidLaNhGVpLo1WaTpHV9WfCJkzpVK/24/aSNt5pjpUpnagHjcm6VM6dWgx7TORSPaByD2l\nx77TfJz8ZvR03wYqOSL22kj78gaS5ppFY1SP7F036leLR0KaZM5upN+uG92kVILXvPjGtEzIhA18\nj4MSZelnSibyCc9swFEpik51tUyX0pVCqLafmTazhBc6ZnmLXmtRZPZalUzPp2o5l1s4op75hFbU\nJueND2KZUYUFdHR6PgDoCSiC0WlnZfSml1nKPukuSvMda4c7stUClJ0Uaf40L44KvtIKFjLrRDKj\nSlpSdvnEkGkOhDKBiGWu2H6MKvG7kyoyVz3Q2f9Rv1DzWogyRN4IdWRGvZ7NwFSaI2/+FJGlGOZM\nhISTRJZiXIAsMk4TWQrgOKk9lp0o8QJ2Nu99onKyvDtuhY7/JPEi1aZ9dygTCGUCoUwglAmEMoFQ\nJhDKBEKZQCgTCGUCoUwglAmEMoFQJhDKBPIHyvIe57rnz9QAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results:\n",
      "NCC mode:\n",
      "1. :5/y scores: 0.99812815982\n",
      "2. :17/m scores: 0.864077275504\n",
      "3. :25/u scores: 0.859047795438\n",
      "Result:happy\n",
      "Processed: 5/12\n",
      "Processing:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJUAAABtCAAAAACNCHznAAACh0lEQVR4nO1a0XLEIAhUp///y+lD\nehejEBdc7uyM+9KbjJV1IQqGfKQFUb5NQMRmhWOzwvGDDMpHyq/fH3ln89BKFp/Gkht6UCalPSZB\n1wqxG6WYygoVI4SY5sFYD40gaWVjFCGWoJVRphwga8/KboRPq/NgZ0LyUDuI7cWGVb9s8B3l8rp7\nECcVu7nftbqzMh1GVJY1K4dTgnhVHvRESpAf1dMZtKdLPYO3B92+iHCipJVt7sgTp1qx1UyAE3ut\n7Gvn0zpZVSesxyF0WoUyFZsWqfIih3zLyjt95Om8CkqqQ+EgLJkRWDStrvUQaN1YLXPDxosrpliF\nd0xQ86vv1qMyag8uE1Y1Kx6pafmFW7VzTpBjxocaULp1/T3ACvVc/QeRXbczmNTPtz88tKw8pPg3\nIA2rrPwWYRpswqiif4Ch/LeCm8lEVl7fB5dVXOW1Au6sZuMiKK4s0wYe5g81jsnqOZgWV63tGQVo\nW6ke7WN6Xl3H6DOZI2XUymHLenBIXy0NRuSh0yyZ+1XufnhRFsrWL5RLb16StJQHebixmhOLmPjx\ntGJmoyWtVJ2+QNNq4mq8x0TeroEg/UON4wQjHkozkZdWROW1Wry/vnnNBSs11NMVVzHf+bx4Rzsp\nB+XEwvUOum9bM52UvIu6s4fgit5AKyIMtb6+cWddSub+BxjqbS0gQUQ30Qn9ZttskrgVP3WkPJmC\nWo/cGPYUCfagQVMAbj+a8ImLpsoGpMQI7NOdkovSUw5GlwUfglbmjhT+OrQ9HI+uD/WL2myFOPyf\ndUe/ByjPQ1+K4c6gWI99U6GMJbqVtje4wvbU4R/cXy2DzQrHZoVjs8KxWeHYrHBsVjg2KxybFY5f\ny5d+wujyC6AAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGkAAACECAYAAACTWAVmAAADkElEQVR4nO2dya7rIBBE4en+/y/7\nrZAsywlTD1WkzjpKGg7dYEzsel3XVQQ0/7IDEH0kiQBJIkCSCJAkAiSJAEkiQJIIkCQCJIkASSJA\nkgiQJAIkiQBJIkCSCJAkAiSJAEki4C87AEtqraUd2ai1dj/Pcryjsh9EGZGxAlK3UJc7L0He3z0L\nfLnL7Ky3387IMGhJSKO5cY8pShhsuUMUlAVMJjFKua8mPYHIJEZBjVqre/zpkpgF3fFsR2q5s2iY\ndbnZicmr/KVczFqNOu/Qd+K0jC283LEIivqNEWBWdz2yOuz+uzMDzLL0hZU7lNJhwWxbduMPKXcn\nCSolPqb0Jfg3EAU1ZmLbnYddy110Wcggoo0wmcQoqJSYuN0kzYwwVkEN79KXnknsghqeoswlzWw4\nniKo4SXKVNIpm6U7eIhKL3cnYl0h0iSdVuqeUG+winnMJM0sFk7PohlG+k2Z5MjoYOyJCpWkDFpD\nmeSMRTaZSNL10XfS7ydJkD9h5U7z0TohkiRojE9VCeIgyqfgkOU+Y/aMdSuTLOajb98RcYR3hbeY\nenHuSExdgiMK6NEbVB6kSTpN0P0z1m1LkTTbCAShmTHTHjOOJPtotLaFgqE+0iU+I0nBUB7pEn3C\nJSHvIkRAMyexicqOl+K0UHYnrfAp5vA5abfzGDt/h9XrLfiFA4rIzMxPv1Xx9nw6FDFPes/S84o7\nXVIDVcwbXrF++l74cncKozvob2xLYsoAVkwyqScK9Q4rGip3xIRK+tVs2m23MskZi4FpJkkLCD+U\nSY5YPSZBZxwA6FUhitNCJzMyTZhKinwoEjrQR7q0gLDH7Sldv/RsoTse7Xabk1T67HBdOJyUISN4\nVQ/31Z3V3+SRmd1Anh28UBezv7BbTnOkqweTqIhYYW6fP4l6o8osq1Lg/+m3GiBSRmWWYvhHBCCJ\nWmW3IoS/UCT7D1mjIL2RhvqtLw2LJiDG1DjiwP7OfMGw7E9/GTB6B83i0Z2Q10mseI33dEmI10Jo\npEsqhV+U93NlYXYcno1kmauoXyiyC0N2RcUIk0lvXNcFl1F6Qf0L3zrFWyBKNsOWuxE8OxFFUCkE\nmdRj9RWjve9Cgl7SHdRO3oW63P0KkkSAJBEgSQRIEgGSRIAkESBJBEgSAZJEgCQRIEkESBIBkkSA\nJBEgSQRIEgGSRIAkESBJBEgSAZJEgCQRIEkESBIBkkSAJBHwH+/aeAyNCBK2AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results:\n",
      "NCC mode:\n",
      "1. :10/n scores: 1.0\n",
      "2. :12/d scores: 0.977313402314\n",
      "3. :12/b scores: 0.976792215381\n",
      "Result:happy n\n",
      "Processed: 6/12\n",
      "Processing:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIMAAABtCAAAAACnuI1IAAABe0lEQVR4nO2ayxLCIBAEwfL/fxkP\n4wPDsiwJWpPU9ElFU81sSCCYS4qRq9fR3wS5rT3cLhgccpPrM/RiffjGbN1bIoYc7r2GHO7XNqNp\nGHLITW+NQWj11Gg68/nA4NDWIn0F3KnGwkpw5GCOzfLpoDdE27j2wZBDe61+NVSvS+D9ARhyYHDo\n1iK151x1e1w6o2HIoXvfTJshWvd21aB8wpCDdz6kNJocrJncMuTA4DCqRXLKsWqZcZIc3LncCk6T\nw2iNcxCGHBgcgrW4/No/nEM6vLzuwpCDHIAcgByAHIAcgByAHIAcAIOD5rRA6yygdTdgcJh7FlR+\nMkTPkIO/y3ed55N+Dp0uX/B5NYPDzB6K3XSNPZTwvt5s+wR8ObyfeoV6+X2+ZP/LDgw5MDiYtajw\ns539vg1DDt7+5rhXZbDvF4Mhh+01asel5/BdlCEHBofgf/YGB5n/SQ1nDv+HIQc5ADkAOQA5ADkA\nOQA5ADkAOQA5ADkAOQAGhwfFPE+xCdd6KQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFAAAABxCAYAAABC4SQ+AAACL0lEQVR4nO2d227DIBAFoer//zJ9\nQnLU1DEMl6Waea1s3PFZgsEkuZRSknTztfsCTkeBEAVCFAhRIESBEAVCFAhRIESBEAVCjhSYc045\n592XkVI6VGAkvndfwCfukvbub6snl0wgRIGQISV8V2a9JdX7IVGPm9Huu3OaQMj0D5HrHY28etCb\neBMIySklvK7Uevfu2hs9QB7Zln3gBBQIGVLCLydsKIuZpTy7dCsmEDJ8GFPv1pO7vHqIM6o6rphA\nSJ79bgztb3Yf/wkTCFEgZHoJvzQGO/GWmZLZpVsxgZClU/o9Q5zWZMwYqtxhAiFL+8BfjW9amhz5\nL5tAiAIhW9eFr6W0opxn9FYmEBLmzYSWIU7PeWdhAiFhElgZlcRVozMTCFEgJFwJV3pL2dfbDiNs\nAitPB9u7HulNIESBEAVCFAhRIESBEAVCFAhRIESBEAVCFAhRIESBEAVCFAhRIESBkPBT+k8XlehG\n615MICRsAndt+W/FBELCJXDU21mrkmgCIQqEhCnhnv0dEbbUmkDIUftERm3jd59IILYkcGZa3Ct3\nGAqEHLXhelZbpD0TCAn/rR3R2zeBkK4EPnnZe3fy3tHbB/91XCnFBFIUCBk+G7PrmbSlvdZZnDtM\nIGTLfODub/MdubnbBELQQDriUKWX3r7bBEIUCBnyLBxxG2ov/hjBYrYuKv0HTCBEgRAFQhQIUSBE\ngRAFQhQIUSBEgRAFQhQIUSBEgRAFQhQI+QF62OnJNopU/gAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results:\n",
      "NCC mode:\n",
      "1. :11/e scores: 0.996766406672\n",
      "2. :3/h scores: 0.915247422477\n",
      "3. :25/r scores: 0.90520015797\n",
      "Result:happy ne\n",
      "Processed: 7/12\n",
      "Processing:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAALgAAABtCAAAAAA3q/SHAAACRklEQVR4nO2a3ZbCIAyExbPv/8rZ\nC1dtS0ISfobVM3Oj1VA+Y6CBUOT2mbrvBugVwdEiOFoER4vgaBEcLYKjRXC0CI4WwdEiOFoER4vg\naBEcLYKjRXC0CI4WwdH6CdiUx0uoWpSxHVJxuijHCxcnZz0kJ1RK46o2TlkPyvG40rnRQMNc6XMT\nvDw7romUJrpRMaxnqAl+7fSJV7Uxvii69RRZMa4663l9DWbrB+FDpbihLNUneotl0aJ6vDEfiBgm\notPJK9YnywqV8JTtQgEHZ2l3dooWc7xeWkzHVzzucJ++DXHfZEG09CRZf+F8YPH8uSBcvFzFaPV4\nEVhKVasvrT1PLVsOGX1sPn4FL7FRJMb7hoJ3jqrX46K8g6pvcN6iE+E6fU+MZ2+wdp3T6PfwV6dm\ntzdwYhE9Ma6K7HHZ8E/YFePD7rrvitFRbZtVRh32NdMhTKOj887z4zkN+2s4V9mVrAx7nElWUp0L\niUODsOH/WEhsVwWejtlNOUPnrHKk3TM8J4TKHpfX4JFBdF5yRBpAtuCinUiYfMGfUoP7O5SlWod5\nDTC7tR65NjC9BvMHsBYqbfLzhkqAfAl3u3ilfX7dCHLJ13DbxSu9OyUnbO5TrKt0Gg8gYxtEz2Xt\nDHdhhdY4PXHabfFqyy/j5CbRkNzKcqyar1fyX2X1BcofQmgUYkOWkxQ5aPOWTaLUYbeeV5HGVW2M\nzBP9tDY14nDDM5aPZx4iix44VTfcEAKL4GgRHC2Co0VwtAiOFsHRIjhaBEeL4Gj9ApEMf8PhAk9V\nAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIEAAACICAYAAADAr4iYAAADWUlEQVR4nO2d267jIAwAJ6v9/1/O\nPkWquqS5YTBh5vXoNGAmNs3FXdZ1XZGp+dN7ANIfJRAlECUQlEBQAkEJBCUQlEBQAkEJBCUQlEBQ\nAkEJBCUQlEBQAkEJBCUQlEBQAkEJBCUQlEBQAkEJBCUQlEBQAkEJBCUQlEBQAkEJBCUQlEBQAkEJ\nBCUQlEBQAkEJBCUQlEBQAkEJBCUQlECAv70HcMSyLLt/y/ijLaONF2DJ9vM3v4K4R4YpjDpuSFYO\n7gTyyf/VYFmWIcf9SfpycJbvgEaeZTUXb1mW7hmhSzk4s2C1Al1zelFjKn1uy2VJIQE8m/TR4tSY\nYuQx9j671dI03xNEWH/0/0/rdrRk05SDz0D2rNdnj31Gmoh59CgNTTJBy13wuq4/g1ZjLEfHqP3Z\n0fFrXg56pz44DmqGr26v2hhuAe2x+HdKQ4tN5lWiS2loJugpwJ3jZhTg+7gRWSrVFcMIftXvKwHt\nXcZCN9PZ7h1EcXRjZ8QbP7V4fSbYuPuN4e0CwEQSyD7VJXhydS6aq2d15ixQM87TZYKzC5tZgNpU\nv5X8huCNMIeaY5wuE8j/hOwJRucNc7jC43JQCljvK4U1yPDET4mIZw92LxbNdjbMQmm53RNMRunk\nLkpgFpgLM8GEfJ/kSiBKMCPfm8OiBBm/GkkcZoLJKJ3guxeL3pwNej1OnhUzQYGZBAAlECZ7qOQs\nI4zfh0qkKiESvKGmjpANajHVk0VvWlifLGrEm6T5RZgE2TaId98tyDaHIV9DyxTEEpsA2UWIHEOY\nBNEvUZ7l19lzpa72nsPGcG8l9xbh6jHPtL1pTYsOL+HloJcId18zzyRCqxY/KRpX1f78p30GMojQ\nSgDo1Lhqo/aha94dPLvQ0X0SWyxP0/4Ekf36om4Pt7rt3LOhZdO2tkfNIEr07mx6Zsw9skZNUnY0\nrVlzM7a13djG1rIvc4lU7WqiglyTiE1h7yV4TZfzVoGs2Wiy9+JvpLqB9KRu9yKyu2krUpWDT0bc\nbI04ZkgswTctL57UYKTxDiOBxJFqTyB9UAJRAlECQQkEJRCUQFACQQkEJRCUQFACQQkEJRCUQFAC\nQQkEJRCUQFACQQkEJRCUQFACQQkEJRCUQFACQQkEJRCUQFACAf4BlQSJ+uVyG24AAAAASUVORK5C\nYII=\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results:\n",
      "NCC mode:\n",
      "1. :13/w scores: 1.0\n",
      "2. :18/o scores: 0.990927147303\n",
      "3. :5/m scores: 0.978537858584\n",
      "Result:happy new\n",
      "Processed: 8/12\n",
      "Processing:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKwAAACDCAAAAAA1oK/nAAACAklEQVR4nO2a0W6DMAxF7Yn//+Xs\nqSGFVKTgQ3B1z0PFpokd3ZrEGNwQCnLWP+SsEKlkF4v/zjz4fJVUyUqWQrIUkqWQLIVkKSRLIVmK\nVLILfH43i+vub0k26taBTNbbo4h06TIoZnHJcmXgq2J5//E0aLKlOYhIF5INXQQq4Gqwdb2eLSFb\nitnONaISfH9aCr/8j1Jtt5KlQJau7sIVsNASyXrz2fyyXL6QwTKIH9NCsqUE7bBvoL1B7QyDtDnZ\nsipG7TxkssWDS4FuEf11EAG9KfR6mtPQtzWhXZK225bIHpRO1utHAPSmUA+evs7WCnh+svuu6/Ip\nb5kbFNPcIJL4m2ZkbtB8NlyfdmluQCFZCmbp6l0JD50bdLuXiPaAG3Lsory+6Ghu8EJzA5A0c4O1\nM0wyNzCzPHOD0CYp1XYrWQrJUkiWQrIUkqWQLIVkKVLJDt4j1R76278PZTBZ/zC4uJdUZbAMfWFt\noDeNnnukSvbnZH0dVxLjtnEGk41+bfccA7LvY+CZtsey25H1RNufu8Aegx+t8b3nghGP489wlOyH\n8pxTtanKQLIUAxfYttG68an/hsNku1qT2sRUZZBK9rBmN28SMa8VDTKQbPvS21TXkWTNmh1r4h3Y\n9833VAaTfQapVgPJUkiWQrIUkqWQLIVkKSRLIVkKyVJIliKV7D/Hj1YsvFhxMQAAAABJRU5ErkJg\ngg==\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHsAAABwCAYAAAA+AA+8AAACrUlEQVR4nO3d226kMBBFURzl/3/Z\neUJCjgFfy2XOXo+jZCbRnjI0mO4QY4wHJPzm/jCEYP1zSFg9Vz9L/3WYIraQ7DJ+tXrp2Z2nQyKT\nLYTYQogthNhCiC2E2EKILYTYQogthNhCiC2E2EKILYTYQogthNhCXjcvwFZus8OoDSRM9gZG7XZh\nshcrDXn9utZJJ7YzuZCjJptlfJEQQnHE9D9AzfdeMdkOlCzL169pnXRiG5p5pl2CZXyh3tC1E07s\nyWKM2ag9oVuXdJZxI6OX6xgjk417xBZCbCEcsw3MeMnV8lqbyZ7sLkrPJdDze+/O9O8QeyHrZ7eJ\nbeicxBGXPltwzHag5PbliP8UxF7kjFoSMf0a7mdvKr0SNnNZJ7YDJcfwEZdbOUFzZvRNkysm26FZ\n97iZbCFMtkOjzr5TTLYzuRM09o1/SO1rbV5nb6pkyWayNzfqrlcNYjvwFi33kEALYhti37gw6/dy\nJ/Zkd0FHhK595otl3MCMPePHwRMheEBsIcQWwjHbyOibG+wbd2r0zY3W6+TEnuwpau8179rVgdiG\n2DcO9o1/HfvGwb7xLyu9fcm+cRHsG/+ombc9mWwhxBZCbCHEFkJsIcQWQmwhxBZCbCHEFkJsIcQW\nQmwhxBZCbCHEFvK6ecH6PbGflNzY9/TzerPVZL89j0zoZ1vFRp/sMm799g8laqfW4++wGpMthNhC\n3MdOT8qeludVD8ztwn3sK6sPFf8q17FbHzoneJ7b2L3vwkvw/9zGxnjEFhKiw6sPrW+xbPX37crd\nZM88vqofu93FxjzEFkJsIa5P0E6tP+Ksz8falcvJnhFFPfRxOI2NOYgtxOUx+9TyaTmrP2HHM9eT\nXfvpdYR+5nqyUyVXwDb6dcy5nuwUIfts9w6HBG+31WSjD7GF/AGSxAUcNImgFAAAAABJRU5ErkJg\ngg==\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results:\n",
      "NCC mode:\n",
      "1. :6/y scores: 1.0\n",
      "2. :6/o scores: 0.998743021507\n",
      "3. :6/o scores: 0.998666143081\n",
      "Result:happy new y\n",
      "Processed: 9/12\n",
      "Processing:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAALgAAACDCAAAAAAb5Y51AAABIklEQVR4nO3XQUpDURQE0f/c/57N\nIOJEyaAfVNNQZxAMBClCX2PO97Ppqx2QMpxmOM1wmuE0w2mG04bDz3me5zw/D78/vB8+PPv4yr8v\n+OfZlfvfELr9HlCbyu07Vgu/fsdnv7rVRn5p+M/hqN1wjxO2O5V2QMqN03an0g5I7YZ7nLDdqbQD\nUrvhHidsdyrtgJQbp+1OpR2Q2g33OGG7U2kHpHbDPU7Y7lTaAandjbcDUh4nbTd89jjdOMxwmsdJ\n251KOyBlOM1w2m64H0Cw3am0A1K74R4nbHcq7YCU4TTDabvhfgDBdqfSDkgZTjOcZjjNcJrhNP87\npO1OpR2Q2g33OGG7U2kHpM7sxtsBKcNphtMMpxlOM5xmOM1wmuG02fAXBPoVGZIubpYAAAAASUVO\nRK5CYII=\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJAAAAB7CAYAAACbxQn5AAABm0lEQVR4nO3awYrCQBQFUVv8/1+O\n2wQV7FQ0BM5ZDiPjosi7OI5lWZYb7HQ/+w1wbQIiERCJgEgERCIgEgGRCIhEQCQCIhEQiYBIBEQi\nIBIBkewKaIxxG2O8/Ozd783+zqef/fN1Z7zPo97Dka/7xpj9QtneP8Q1zH6/0AljY/YBISA2fv4E\n8hVq1qYDsoFYc8JIBEQiIBIjmsSIJnHCSAREYgOR2EAkThiJgEgERGJEkxjRJE4YiYBIBERiRJMY\n0SROGImASGwgEhuIxAkjERCJgEiMaBIjmsQJIxEQiYBIjGgSI5rECSMREIkNROIJRGJEk3gCkQiI\nxIgmsYFInDASAZEIiMSIJjGiSZwwEgGRCIhEQCQCIhEQiYBIfJBI4oNEEieMREAkAiIxokmMaBIn\njERAJAIiERCJgEgERCIgEh8kkvggkcQJIxEQiYBIBEQiIBIBkQiIREAkAiIREImASARE4r/xJP4b\nT+KEkQiIREAkRjSJEU3ihJEIiOQx+wIbiDVPIBIBkQiIREAkAiIREImASAREIiCSJ8obQjRVwepK\nAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results:\n",
      "NCC mode:\n",
      "1. :7/e scores: 1.0\n",
      "2. :15/m scores: 0.749275306936\n",
      "3. :4/e scores: 0.655539688711\n",
      "Result:happy new ye\n",
      "Processed: 10/12\n",
      "Processing:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJgAAACDCAAAAABUuI2lAAACY0lEQVR4nO2a0XqDIAxGwc/3f+Xs\nokMBCea3CUK/nIt11lWOIYZoFynMyfa2AIeLobgYiouhuBiKi6G4GIqLobgYiouhuBjKLvqrWGwN\nubESRSx2N22QiA0RqZGIvXJPLJpK6m7aILsqid0wAy8Xgya2Uy7iS9n1oR+xmC7I8YZ3U5nUhptF\ndsS8etG5TcdOW1dZ8p+Sp5dx3X20iI9YCmSLeKYyan1CIzZs3Zy/H3vYchUf07xOU8Q6LRcRiWqK\n7jzzU/kv85FizGoTRbO7HOvPTr1XcS6ZckEhBGqu4tki0NynxbEk3WVxtZwn6XrhUuOYSvCo6YIw\nWzCbOTbDF1/TFthT7GGYqPGbBnuI3EUfW6OljM986lay+TmYLVYt4EHMfl6J9Y7S6/tSu2VHofyl\nc+RYqhUndBF+yn4MlR2fP3gpUb6j2xGdyR/L5Gpz3ZXeUQvVP1m5iNVrCd9g2PSORR175bEOQy42\nk5dm5dcusO0hmOh1BqdANo1i2UDLTr9uui0axdQaZtt35/9puq+NnErckljrXG/OPy0UF4926wuy\niRxa3KTbt2x3g/CDP90pY6PsOMJnYRTslsiDPde4pkubEa23WoHVlv1ezCh8C9yMTIZcbPDN5g9E\njMUmlL8cMRtWEpvhWc9aEeswMJiA2NgpFn6XFEIYbPYjOTaQhcTmKGOrRGySaIWwTMQmohSb6NGd\nVsTUs3ORqXyGybWsFDF9N6S7YLEI2SI5RvMUf/7/x15mkamcCBdDcTEUF0NxMRQXQ3ExFBdDcTEU\nF0NxMRQXQ3ExFBdDcTEUF0NxMZQ/ixx789CRFhgAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGgAAACECAYAAAB8mm5YAAADOklEQVR4nO2b2Y7jIBAA8Wr//5e9\nT5E83vHB0VCQKmk0UiRMoNzQpp1t3/c9CZY/o7+A3KMgOAqCoyA4CoKjIDgKgqMgOAqCoyA4CoKj\nIDgKgqMgOAqCoyA4CoKjIDgKgqMgOAqCoyA4f0d/gdZs21bUjvr22VIRVCqntm0kywiiTnAtywii\nLlG1LCMopTpJVMFLCUqpbKKpclJaUFAuZDkpTZJmHxMA+oS2ZroI2rbtMWNbSeJ0gj48iVpF0kb/\nAVfu8815OCUSz21GTtG0EXTFW6Fv5eRcM4LlBNVAPI2YIovL5e1EE4Wc+doImkFOSl8saBZCl7jV\najNHSsZWMq6wCOpZm9n3/cdfNKVjK2mHX+LuJvxKSKSk2r0rtz1e0BWjlsHafnPbI9Ps8yD2fQ85\nMM05dYjo7w2hRz29NtLS/u/6erohao+g3hK6xM2QjV3xlHT0GhtqD5pZaBQoQfI/4YJWjoq3Y6uZ\ng+os7rNZRqafv23IEf2VZIrnDPNNP3f9nttVRdDxwlHVzavrRqfEb0rrT5TKOX7edIkrlZRTPIvi\nbqIi3oF4ewM0f1CtKRf3ElI6oaXXqRlXeJLwdl0nREvr67RYJruk2W8GEkGvk+3Im6vrc9AsVUwS\n3QQppwxPEjow9EG1JceBREZcz9ONT1+f/7iCXWkpmnpEVFtaRxXsngpvOe1H72FXpfVWNa+r64QJ\nah0BIyPq6RSkxc1zVTUOWeKoy1MJI/erlAIEKadtn1WCfttj7iD/nid3LB+i98bqPShnYlut11GM\nvkl+wwfVQFoIV1Al0VGnIDgKgrO8IOLGn8PygmZHQQ2IjFIFwVEQHAXBQQiaPdOKBCFIrvk6QbNF\n61cImk3KEdRbPZHMKukrImhmFARHQXCGC5p1b+jFcEFyT3dBRkweRhAcBcHpLoj8XhwRIyiIVnut\nguAoqBFR2amCAmgp62tOs3sQEUVGEJyhJwmeKjwzZIlTzHtc4uAoCI6C4CgIjoLgKAiOguAoCI6C\n4CgIjoLgKAiOguAoCI6C4CgIjoLgKAiOguAoCI6C4CgIjoLgKAiOguAoCI6C4CgIjoLgKAiOguAo\nCI6C4CgIzj/OuXSwrPeTwgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results:\n",
      "NCC mode:\n",
      "1. :8/a scores: 1.0\n",
      "2. :18/o scores: 0.920421115467\n",
      "3. :10/i scores: 0.918832443809\n",
      "Result:happy new yea\n",
      "Processed: 11/12\n",
      "Processing:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHUAAACDCAAAAACWpAtkAAABcElEQVR4nO2ZyxKDIBAEhfL/f5lc\nkggCC+ggSVXv0VjTzog8Ni5sC8qvgEKFChUqVKhQ11KdW0B1Qu5gwiLsXlOs7OKcZHf39XpOr5am\nxK2RsG7w5NLBJER5usK1q+VNaJSz1LkfVxTwfUvm7Vb7kvf2LRNGlT+phkdOW3sCDdu2hZmfzLtS\no8WrWd2PI54lDrXZOUeuQu2HtBQPVJ0Rp7o9LOWYol3tmlNQKwE0EZireo4Q5d5eSZRrzUzNdv38\nzhQqVKhQoUKFChUqVKh/TK10frKjq/YYlJ+ujE6IDH1O2Gx3y1pCqde2rMZuTO2zIu7BdOaniPmK\nhra39lxVvAbzhttmC6KZpn7K6FN0HffcoLa7ThJsMpqMBq12Hu4ew1JsuSs9G3tQm/1vIfbSLHGb\nb/WH59UVr/86D3+oA88veBf7sJBiALgRISfbwQTRH/RD5R/+Zr7UBQUVKlSoUKFChQoVKlSoUKFC\nhQp1fr0AqepB8H83GwgAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFcAAABnCAYAAAB1st7BAAACOklEQVR4nO2d0W6DMAwAm2n//8vs\nYaqEom6j4IvtcfdWVU3C4RhCG3ds27Y9BOEjewD/GeWCKBdEuSDKBVEuiHJBlAuiXBDlgigXRLkg\nygVRLohyQZQLolwQ5YLcUu4Y4zHGwPu5ndy9VFry7eS+ghL8ibT6B2cPhvyieowR3v7SyL06Delp\nHN12y7Sw4mIUwZK0QMjYtxk5nSPTAx65K6LsaLpYHfGo3C7TdyZq3JjcDLG/RXDGeFJuxWiqzBgk\ncs8c3LZt6H1sBuGR+67YWejzdZXou0Jo5F4VO7/XPZLTFhFHxXWWnCL3jKxVgiNPZqvlb7cIXi73\nqiAyTbR+KhY5+GgRxAlrlRZmooRQM6H9Cm0Wc+R2cFXubi93ptJFr3VaqI5yQZQLolwQ5YIoF0S5\nIMoFUS6IckGUC6JcEOWCKBdEuSDKBVEuiHJBlAuiXBDlgigXRLkgygVRLohyQZQL0uK3YhGbTzJ+\nQ1ZOLrWL51W7tPAyaWFVaZS5T5L0yM3eb/bsn4jiNLnZUmcIySlpoZrYPZFja1WGZRXlSwJIgQva\nEY7mwchZEVGOpaTcswe1/1yF9FNKLrEJMFNyiZxLbzk92/bVE5Mqd+V2/4xnCyUidxWrBZcvZtG5\n35SSANlbSFf1f6u08C5XT0LbegsdMHJ/ICIQlAuyTG6nlBA1Vnz520nq49HoYXllsa/KHEaPdxB/\nB04UV+8IErmK/ca7BRDlgigXRLkgygVRLohyQZQLolwQ5YJ8AcJE0bp2pjEfAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results:\n",
      "NCC mode:\n",
      "1. :9/r scores: 1.0\n",
      "2. :9/r scores: 0.970765480417\n",
      "3. :9/l scores: 0.913771950136\n",
      "Result:happy new year\n",
      "Processed: 12/12\n",
      "Processing:\n",
      "Message: happy new year \n"
     ]
    }
   ],
   "source": [
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}