{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# m vs time for fixed stringlength (m in powers of 2 for table till 1024)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sympy\n",
    "import random\n",
    "import time\n",
    "from scipy.special import lambertw\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "def egcd(a, b):\n",
    "    x,y, u,v = 0,1, 1,0\n",
    "    while a != 0:\n",
    "        q, r = b//a, b%a\n",
    "        m, n = x-u*q, y-v*q\n",
    "        b,a, x,y, u,v = a,r, u,v, m,n\n",
    "    return b, x, y\n",
    "\n",
    "def mod_inverse(a, m):\n",
    "    g, x, _ = egcd(a, m)\n",
    "    if g != 1:\n",
    "        return None  \n",
    "    else:\n",
    "        return x % m\n",
    "\n",
    "def padding(plain_text,block_size):\n",
    "    plain_text += '0'*(block_size-len(plain_text))\n",
    "    return plain_text\n",
    "\n",
    "def chunkstring(string, length):\n",
    "    return list(string[0+i:length+i] for i in range(0, len(string), length))\n",
    "\n",
    "def Rotate(lists, num): # Right is default\n",
    "    output_list = []       \n",
    "    for item in range(len(lists) - num, len(lists)): \n",
    "        output_list.append(lists[item])       \n",
    "    for item in range(0, len(lists) - num):  \n",
    "        output_list.append(lists[item]) \n",
    "    return output_list \n",
    "\n",
    "def evolve_primes_list(sample,shift_factor):\n",
    "    right = sample[len(sample)//2+1:]\n",
    "    left = sample[:len(sample)//2]\n",
    "    rotated_right = Rotate(right,num=shift_factor%len(right))\n",
    "    rotated_left = Rotate(left,num=len(left)-(shift_factor%len(left)))\n",
    "    rotated_left.append(sample[len(sample)//2])\n",
    "    final = rotated_left + rotated_right\n",
    "    return final\n",
    "\n",
    "def calculate_blocksize(n):\n",
    "    num = int(np.sqrt(n))\n",
    "    if num**2<n**2:\n",
    "        return int(np.sqrt(num**2))\n",
    "    else:\n",
    "        return(-1)\n",
    "\n",
    "def get_prime_list_permutations(prime_list,num_blocks):\n",
    "    primes_list_permutations = []\n",
    "    for shift_factor in range(num_blocks):\n",
    "        temp = evolve_primes_list(prime_list,shift_factor%len(prime_list))\n",
    "        if shift_factor > num_blocks//2:\n",
    "            temp = temp[:num_blocks//2+shift_factor]\n",
    "        # print(temp)\n",
    "        primes_list_permutations.append(temp)\n",
    "    return primes_list_permutations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "m_vals = [1,2,4,8,16,32,64,128,256,512,1024]\n",
    "time_taken = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Blocksize =  31\n",
      "m = 1 -------------- Operation Runtime : 0.0018422603607177734 seconds\n",
      "m = 2 -------------- Operation Runtime : 0.001878976821899414 seconds\n",
      "m = 4 -------------- Operation Runtime : 0.002119779586791992 seconds\n",
      "m = 8 -------------- Operation Runtime : 0.002096414566040039 seconds\n",
      "m = 16 -------------- Operation Runtime : 0.0022907257080078125 seconds\n",
      "m = 32 -------------- Operation Runtime : 0.002521991729736328 seconds\n",
      "m = 64 -------------- Operation Runtime : 0.0029687881469726562 seconds\n",
      "m = 128 -------------- Operation Runtime : 0.003992319107055664 seconds\n",
      "m = 256 -------------- Operation Runtime : 0.006209373474121094 seconds\n",
      "m = 512 -------------- Operation Runtime : 0.012920141220092773 seconds\n",
      "m = 1024 -------------- Operation Runtime : 0.03332209587097168 seconds\n"
     ]
    }
   ],
   "source": [
    "plaintext = 'abcdefghij'*100\n",
    "blocksize = calculate_blocksize(len(plaintext))\n",
    "if blocksize%2 == 0:\n",
    "    blocksize -= 1\n",
    "\n",
    "print('Blocksize = ',blocksize)\n",
    "\n",
    "for m in m_vals:\n",
    "    plain_text_chunks = []\n",
    "    if len(plaintext) < blocksize:\n",
    "        plain_text_chunks.append(padding(plaintext,blocksize))\n",
    "    else:\n",
    "        chunks = chunkstring(plaintext,blocksize)\n",
    "        for i in range(len(chunks)):\n",
    "            plain_text_chunks.append(padding(chunks[i],blocksize))\n",
    "\n",
    "    ascii_chunks = []\n",
    "    for chunk in plain_text_chunks:\n",
    "        t = []\n",
    "        for i in chunk:\n",
    "            t.append(ord(i))\n",
    "        ascii_chunks.append(t)\n",
    "    num_blocks = len(ascii_chunks)\n",
    "\n",
    "    # Fixing the value of q based on blocksize using prime number theory\n",
    "    n = np.exp(-lambertw(-1/blocksize,k=-1))\n",
    "    n = int(n.real)\n",
    "    q = sympy.ntheory.generate.nextprime(n,ith=1)\n",
    "\n",
    "    prime_list = []\n",
    "    count = 0\n",
    "    temp = []\n",
    "    while True:\n",
    "        if count == blocksize:\n",
    "            break\n",
    "        p = sympy.prime(random.randint(1,blocksize))\n",
    "        if p not in prime_list and mod_inverse(p,q**m)!=None:\n",
    "            prime_list.append(p)\n",
    "            count += 1\n",
    "\n",
    "    prime_list_permutations = get_prime_list_permutations(prime_list,num_blocks)\n",
    "\n",
    "    t1 = time.time()\n",
    "\n",
    "    encrypted_cipher = []\n",
    "    for chunk in range(len(ascii_chunks)):\n",
    "        cipher = []\n",
    "        for c in range(len(ascii_chunks[chunk])):\n",
    "            cipher.append((ascii_chunks[chunk][c]*prime_list_permutations[chunk][c])%(q**m))\n",
    "        encrypted_cipher.append(cipher)\n",
    "\n",
    "    decrypted_ascii_chunks = []\n",
    "    for chunk in range(len(encrypted_cipher)):\n",
    "        temp_ascii = []\n",
    "        for k in range(len(encrypted_cipher[chunk])):\n",
    "            temp_ascii.append((encrypted_cipher[chunk][k]*mod_inverse(prime_list_permutations[chunk][k],q**m))%q**m)\n",
    "        decrypted_ascii_chunks.append(temp_ascii)\n",
    "\n",
    "    decrypted_text_list = []\n",
    "    for chunk in decrypted_ascii_chunks:\n",
    "        for i in chunk:\n",
    "            if chr(i)!='0':\n",
    "                decrypted_text_list.append(chr(i))\n",
    "    tt = time.time()-t1\n",
    "    time_taken.append(tt)\n",
    "    print('m = '+ str(m) + ' -------------- Operation Runtime : {} seconds'.format(tt))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Runtime (seconds)')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEGCAYAAABy53LJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXwV5dn/8c9FEsK+74EYBGTfA4pLHzfcK0pRcUVFcePRtvr0p11sa2vV1i5qrYqiAlVRUZC64YK7iIRF1gBhERKBEPYt+/X74wxtGgM5B3Jysnzfr9d55cx9Zk6ucZAvM/fMfZu7IyIiEq46sS5ARESqFwWHiIhERMEhIiIRUXCIiEhEFBwiIhKR+FgXUBlatWrlKSkpsS5DRKRamT9/fo67ty7dXiuCIyUlhbS0tFiXISJSrZjZt2W161KViIhERMEhIiIRUXCIiEhEFBwiIhIRBYeIiEREwSEiIhFRcIiISEQUHCIiNdDarXv547vpRGPqDAWHiEgN80VGDhc9/gUvz9vId7tyK/z7FRwiIjXIi3M3MObZr2nXtB4zbjuJpGb1K/x31IohR0REarqiYuf+t1bw7BfrOLV7ax67fCCN6yVE5XcpOEREqrk9uQXcMXURs9Ozue6kFH5xXk/i46J3QUnBISJSjW3cvp8bJqWRsXUvv7+oD1edcEzUf6eCQ0Skmpr/7XbGTZ5PQVExk64bysndWlXK71VwiIhUQzMWZvGzaYvp0KweE68dQpfWjSrtdys4RESqkeJi568frOKx2Rkc37kFT141mOYN61ZqDQoOEZFq4kB+EXe+uoi3l2zmstRO/O6iPtSNr/ynKhQcIiLVwJbdudw4OY0lWbv4xXk9ueGUzphZTGpRcIiIVHFLs3Zxw6Q0ducWMOHqVIb3ahvTehQcIiJV2LtLN/OTlxfRvEEC024+kV4dmsS6JAWHiEhV5O48+claHno3nf6dmvH0NYNp07herMsCFBwiIlVOXmERP399Ka8tyOSH/Tvwp1H9qJcQF+uy/k3BISJShWzfl8/NU+bz9frt/PjMbtxxRreYdYIfioJDRKSKWL1lD9dPmkf27jwevXwgF/bvEOuSyqTgEBGpAj5ZtZXxLywgMSGOqeNOYGBy81iXdEgKDhGRGJv05Xp++69lHNe2MROvHRKVOTQqUlQfOTSzc8xspZllmNndZXyeaGYvB5/PNbOUoH2omS0KXt+Y2cXhfqeISHVRWFTMvW8s5dczl3F6jzZMu+XEKh8aEMUzDjOLAx4HhgOZwDwzm+nuy0usNhbY4e5dzWw08BBwGbAUSHX3QjNrD3xjZv8CPIzvFBGp8nYdKGD8iwv4bHUO435wLP/vnB7E1alaneCHEs0zjqFAhruvdfd8YCowotQ6I4BJwftpwBlmZu6+390Lg/Z6hAIj3O8UEanSvt22j5H/+II5a7bx0I/68vPzelab0IDoBkcSsLHEcmbQVuY6QVDsAloCmNnxZrYMWALcHHwezncSbD/OzNLMLG3r1q0VsDsiIkdv7tptXPT4F2zbl8+Uscdz2ZDkWJcUscofVjFM7j7X3XsDQ4B7zCyiRybdfYK7p7p7auvWraNTpIhIBF5N28hVE+fSvGFdZtx6EsO6tIx1SUckmndVZQGdSix3DNrKWifTzOKBpsC2kiu4+woz2wv0CfM7RUSqlOJi54+zVvLkJ2s4uWsrHr9iEE0bJMS6rCMWzTOOeUA3M+tsZnWB0cDMUuvMBMYE70cBs93dg23iAczsGKAHsD7M7xQRqTL25RVy8z/n8+Qna7jy+GSeu25ItQ4NiOIZR3BH1HhgFhAHPOvuy8zsPiDN3WcCE4EpZpYBbCcUBAAnA3ebWQFQDNzq7jkAZX1ntPZBRORobNp1gLHPp5G+eTe//mEvrj0xpcoNH3IkzN3LX6uaS01N9bS0tFiXISK1yDcbd3LD5DQO5Bfx2BUDOa17m1iXFDEzm+/uqaXb9eS4iEgFe3Pxd9z5yje0bpzIP8ceT/d2jWNdUoVScIiIVBB357HZGfzl/VWkHtOcJ68eTKtGibEuq8IpOEREKkBuQRH/77XFvLHoO0YOTOKBH/UlMb7qzKFRkRQcIiJHaeuePG6aksaCDTv5v7O7c+upXWpEJ/ihKDhERI5C+ubdjH0+jW378njiykGc27d9rEuKOgWHiMgRmp2+hf99cSGN6sXz6k0n0rdj01iXVCkUHCIiEXJ3Jn6+jj+8vYJeHZrwzDVDaNc0olGRqjUFh4hIBAqCOTRe+noj5/Rux18u60+DurXrr9LatbciIkdh5/58bn1hAV+u2cZtp3XhzuHdqVONhkOvKAoOEZEwrN26l7GT0sjacYC/XNqfkYM6xrqkmFFwiIiU48uMHG55YQFxdYwXbjyeISktYl1STCk4REQO48W5G7j3jaV0btWQiWOGkNyyQaxLijkFh4hIGYqKnT+8vYKJn6/jf45rzWNXDKRJveo9HHpFUXCIiJSyN6+Q219ayOz0bK49MYVfnt+T+LgqO2FqpVNwiIiUkLljPzdMSmN19l5+d1Efrj7hmFiXVOUoOEREAvO/3cFNU9LIKyzm+euGcEq31rEuqUpScIiIADMWZvGz1xbTvmk9po4bQtc2jWJdUpWl4BCRWq242PnbB6t4dHYGQzu34KmrBtO8Yd1Yl1WlKThEpNY6kF/EXa9+w1tLNnFpakd+f1Ff6sarE7w8Cg4RqZWyd+dy4+Q0Fmft4ufn9eDGU46t0XNoVCQFh4jUOkuzdnHj5DR2HShgwtWpDO/VNtYlVSsKDhGpVWYt28yPpy6ieYMEXr15GL071I45NCpSVC/mmdk5ZrbSzDLM7O4yPk80s5eDz+eaWUrQPtzM5pvZkuDn6SW2+Tj4zkXBq00090FEagZ354mP13DzP+dzXLvGzBh/kkLjCEXtjMPM4oDHgeFAJjDPzGa6+/ISq40Fdrh7VzMbDTwEXAbkAD909+/MrA8wC0gqsd2V7p4WrdpFpGbJLyzm59OXMG1+Jhf0a8/Dl/SnXkJcrMuqtqJ5qWookOHuawHMbCowAigZHCOA3wTvpwF/NzNz94Ul1lkG1DezRHfPi2K9IlIDbd+Xz81T5vP1+u3ccUY3fnxmN3WCH6VoBkcSsLHEciZw/KHWcfdCM9sFtCR0xnHQj4AFpULjOTMrAl4Dfu/uXtHFi0j1l5G9h+ufT2Pz7lweGT2AEQOSyt9IylWlO8fNrDehy1dnlWi+0t2zzKwxoeC4GphcxrbjgHEAycnJlVCtiFQln67aym0vLiAxPo6p405gUHLzWJdUY0SzczwL6FRiuWPQVuY6ZhYPNAW2BcsdgenANe6+5uAG7p4V/NwDvEjoktj3uPsEd09199TWrTXejEhtMnnOeq57fh5JzerzxviTFBoVLKwzDjNLBU4BOgAHgKXA++6+4zCbzQO6mVlnQgExGrii1DozgTHAHGAUMNvd3cyaAW8Bd7v7FyXqiAeauXuOmSUAFwAfhLMPIlLzFRYV87s3lzNpzrec0aMNj1w+kEaJVfrCSrV02DMOM7vOzBYA9wD1gZVANnAy8IGZTTKzMq8DuXshMJ7QHVErgFfcfZmZ3WdmFwarTQRamlkG8FPg4C2744GuwL2lbrtNBGaZ2WJgEaFAevpId15Eao7duQVcPymNSXO+5cZTOjPhmlSFRpTY4fqVzew24Fl3P3CIzwcALd39wyjVVyFSU1M9LU1374rUVBu27ef6SfNYn7OP31/Uh9FD1a9ZEcxsvrunlm4/bBy7++PlfL7oaAsTETkaX6/bzk1T0ih2mDx2KCd2aRXrkmq8sDrHzeyPZtbEzBLM7EMz22pmV0W7OBGRw3k1bSNXPvMVzRvUZcZtJyk0Kkm4d1Wd5e67CXVGryfU//B/0SpKRORwioudh95N5/+mLWZo5xZMv/UkOrdqGOuyao1we44Ornc+8Kq779KTlyISC/vzC/nJy4uYtWwLVxyfzG8v7E1CnObQqEzhBsebZpZO6FbcW8ysNZAbvbJERL5v064D3DApjRWbdnPvBb247qQUDR8SA2EFh7vfbWZ/BHa5e5GZ7Sc0zpSISKX4ZuNObpycxv78IiaOGcJpPTQwdqwcNjjMbGQZbSUXX6/ogkRESntr8SZ++soiWjVK5LVbjqd7u8axLqlWK++M44fBzzbAicDsYPk04EsUHCISRe7O32dn8Of3VzH4mOY8dfVgWjVKjHVZtV55z3FcB2Bm7wG93H1TsNweeD7q1YlIrZVbUMTdry1mxqLvuHhgEg+M7Ks5NKqIcDvHOx0MjcAWQI9mikhU5OzNY9zkNBZs2MldZx3Hbad1VSd4FRJucHxoZrOAl4Lly9DggiISBembdzP2+TS27cvjH1cO4ry+7WNdkpQS7l1V44OO8lOCpgnuPj16ZYlIbTQ7fQv/++JCGibG88pNw+jXsVmsS5IyhD10pLu/jjrDRSQK3J1nv1jP/W8tp2f7JjwzJpX2TevHuiw5hHDn4xhJaCa+NoAFL3f3JlGsTURqgYKiYu59Yxkvfb2Bs3u35a+XDaBBXQ2HXpWFe3T+CPzQ3VdEsxgRqV127S/glhfm8+Wabdx6ahfuOqs7deqoE7yqCzc4tig0RKQircvZx9jn57Fxx34evqQ/owZ3jHVJEqZwgyPNzF4GZgB5BxuDfg8RkYh8uSaHW/65gLg6xos3nsCQlBaxLkkiEG5wNAH2A2eVaHPUWS4iEZr69QZ+OWMpnVs1ZOKYISS3bBDrkiRC4d6Oe120CxGRmq2o2Hng7RU88/k6fnBca/5+xUCa1EuIdVlyBMKdAbCjmU03s+zg9ZqZ6YKkiIRlb14h4yan8czn67j2xBSeHZOq0KjGwp395DlgJtAheP0raBMROazMHfsZ9cSXfLxqK78b0ZvfXNibeE28VK2F28fR2t1LBsXzZvbjaBQkIjXHgg07GDc5jbzCYp6/bgindGsd65KkAoQb+9vM7CoziwteVwHbolmYiFRvbyzKYvSEr2iYGM/0W09UaNQg4QbH9cClwGZgEzAKKLfD3MzOMbOVZpZhZneX8Xmimb0cfD7XzFKC9uFmNt/MlgQ/Ty+xzeCgPcPMHjUNmSlSpRQXO395fxV3TF3EgE7NmHHrSXRto4mXapJw76r6Frgwki82szjgcWA4kAnMM7OZ7r68xGpjgR3u3tXMRhMa1uQyIIfQk+rfmVkfYBaQFGzzBHAjMBd4GzgHeCeS2kQkOnILirjz1W94a/EmLhnckfsv7kvdePVn1DTh3lU1ycyalVhubmbPlrPZUCDD3de6ez4wle/PUz4CmBS8nwacYWbm7gvd/bugfRlQPzg7aQ80cfev3N2BycBF4eyDiERX9u5cLntqDm8v2cQ95/bgj6P6KTRqqHA7x/u5+86DC+6+w8wGlrNNErCxxHImcPyh1nH3QjPbBbQkdMZx0I+ABe6eZ2ZJwfeU/M4kymBm44BxAMnJmnNKJJqWfbeLGyalsXN/AU9dNZizereLdUkSReH+c6COmTU/uGBmLYhgSPYjZWa9CV2+uinSbd19grununtq69bqlBOJlveWbeaSJ+cAMO2WYQqNWiDcv/z/DMwxs1eD5UuA+8vZJgvoVGK5Y9BW1jqZZhYPNCW4Wyt4wHA6cI27rymxfskHD8v6ThGpBO7OU5+u5aF30+mX1JSnr0mlTZN6sS5LKkFYZxzuPhkYSWiu8S3ASHefUs5m84BuZtbZzOoCowk9RFjSTGBM8H4UMNvdPehPeQu4292/KFHHJmC3mZ0Q3E11DfBGOPsgIhUnv7CYn01bzIPvpHNe3/a8fNMwhUYtEknPVQtgn7v/HdhqZp0Pt7K7FwLjCd0RtQJ4xd2Xmdl9ZnbwDq2JQEszywB+Chy8ZXc80BW418wWBa82wWe3As8AGcAadEeVSKXavi+fqybO5dX5mdx+RjceGz2QeglxsS5LKpGFbk4qZyWzXwOpQHd3P87MOgCvuvtJ0S6wIqSmpnpaWlqsyxCp9jKy93D982ls3p3Ln0b1Y8SAMu9NkRrCzOa7e2rp9nD7OC4GBgILAILnK/REj0gt8tnqrdz6wgIS4+vw0o0nMPiY5uVvJDVSuMGRH/Q9OICZNYxiTSJSxUyZs57f/Gs53do04pkxqXRsrjk0arNwg+MVM3sKaGZmNxIaguTp6JUlIlVBYVExv39rBc9/uZ7Te7Th0csH0igx6nfiSxUX7pAjD5vZcGA30B24193fj2plIhJTu3MLGP/iQj5dtZUbTu7MPef1JK6OhoaTMIMjuDQ1293fN7PuQHczS3D3guiWJyKxsGHbfsZOmse6nH08MLIvlw/V6AvyH+Gec34KnBI8Pf4ukEZoMMIro1WYiMTGvPXbuWnKfIqKncljh3Jil1axLkmqmHCf4zB330/oIcAn3P0SoHf0yhKRWHhtfiZXPj2XZvUTmHHbSQoNKVO4ZxxmZsMInWGMDdr0xI9IDVFc7PzpvZU88fEaTuzSkieuHEzTBpoTXMoWbnDcAdwDTA+e/j4W+Ch6ZYlIZdmfX8hPXl7ErGVbuHxoMveN6E2C5gSXwwj3rqpPCfVzHFxeC9weraJEpHJs3pXL2EnzWLFpN7+6oBfXn5SCJtWU8hw2OMzsaeBRd19SxmcNCXWQ57n7C1GqT0SiZHHmTm6YlMb+/CKeGZPK6T3axrokqSbKO+N4HPiVmfUFlgJbgXpAN6AJ8Cyg0BCpZt5esomfvrKIlg0TmXbLUHq0axLrkqQaOWxwuPsi4FIza0RokMP2wAFghbuvrIT6RKQCuTuPf5TBw++tYlByMyZck0qrRomxLkuqmXD7OPYCH0e3FBGJptyCIu55fQnTF2Zx0YAOPPijfhoOXY6IBp0RqQVy9uZx05T5zP92B3cOP47xp3dVJ7gcMQWHSA23cvMexk6aR87ePB6/YhDn92sf65KkmosoOMysQfAEuYhUAx+lZ/O/Ly2kQd04XrlpGP06Not1SVIDhPWUj5mdaGbLgfRgub+Z/SOqlYnIEXN3nv18HWMnzSO5RQPeGH+SQkMqTLhnHH8FzgZmArj7N2b2g6hVJSJHrKComF/PXMaLczdwVq+2/G30ABrU1VVpqThh/2ly942lOtOKKr4cETkau/YXcOuL8/kiYxu3nNqF/zurO3U0h4ZUsHCDY6OZnQi4mSUQGrtqRfTKEpFIrcvZx9jn57Fxx37+NKofl6R2inVJUkOFGxw3A48ASUAW8B5wW7SKEpHIzFmzjZv/OZ86Bi/ccAJDO7eIdUlSg4XVOe7uOe5+pbu3dfc27n6Vu28rbzszO8fMVppZhpndXcbniWb2cvD5XDNLCdpbmtlHZrbXzP5eapuPg+9cFLzahLerIjXT1K83cPXEubRunMiM205SaEjUhTt1bGfgf4GUktu4+4WH2SaO0FhXw4FMYJ6ZzXT35SVWGwvscPeuZjYaeIjQwIm5wK+APsGrtCvdPS2c2kVqqqJi58F3VvD0Z+s4pVsrHr9yEE3qaQ4Nib5wL1XNACYC/wKKw9xmKJARDMGOmU0FRgAlg2ME8Jvg/TTg72Zm7r4P+NzMuob5u0Rqlb15hdzx0kI+TM9mzLBj+NUFvYjXHBpSScINjlx3fzTC704CNpZYzgSOP9Q67l5oZruAlkBOOd/9nJkVAa8Bv3d3L72CmY0DxgEkJydHWLpI1ZW5Yz83TEpjdfZe7hvRm2uGpcS6JKllwg2OR8zs14Q6xfMONrr7gqhUdXhXunuWmTUmFBxXA5NLr+TuE4AJAKmpqd8LFpHqaMGGHYybnEZeQTHPXTuEHxzXOtYlSS0UbnD0JfQX9On851KVB8uHkgWUvB+wY9BW1jqZZhYPNAUO2+nu7lnBzz1m9iKhS2LfCw6RmmbmN99x16vf0K5JPV66MZVubRvHuiSppcINjkuAY909P4Lvngd0CzrWs4DRwBWl1pkJjAHmAKOA2WVddjooCJdm7p4TPE9yAfBBBDWJVDvuzl8/WM2jH65maEoLnrx6MC0a1o11WVKLhRscS4FmQHa4Xxz0WYwHZgFxwLPuvszM7gPS3H0moQ73KWaWAWwnFC4AmNl6QrMM1jWzi4CzgG+BWUFoxBEKjafDrUmkusktKOKuV7/hzcWbGDW4I/df3IfEeM2hIbEVbnA0A9LNbB7/3cdxyNtxg8/fBt4u1XZvife5hM5myto25RBfOzi8kkWqt+zdudw4ZT6LM3dy97k9uOkHx2oODakSwg2OX0e1ChH5L8u+28UNk9LYub+AJ68azNm928W6JJF/C3fq2E+iXYiIhLy/fAt3TF1I0/oJvHrzMPokNY11SSL/5bDBYWafu/vJZraH0F1U//4IcHdvEtXqRGoRd2fCp2t58N10+iU15elrUmnTpF6syxL5nsMGh7ufHPzUfX8iUZRfWMwvZyzhlbRMzu/bnocv6U/9uuoEl6op3BkAp4TTJiKR27Evn6snzuWVtExuP70rj10+UKEhVVq4neO9Sy4Ez1Po7iaRo5SRvZexk+axaVcuf7tsABcNTIp1SSLlKq+P4x7g50B9M9t9sBnIJxjOQ0SOzEfp2dw+dSGJ8XV46cYTGHxM81iXJBKW8vo4HgAeMLMH3P2eSqpJpEZbvWUPD7yTzuz0bLq3bczEa1Pp2LxBrMsSCVu4t+PeY2ZJwDH893wcn0arMJGaJntPLn99fzUvz9tAw8R47j63B9eemEK9BPVnSPUS7kRODxIaDmQ5UBQ0O6DgECnH/vxCnv50HU99uob8wmKuGZbC7Wd003hTUm2F2zl+MdDd3fPKXVNEgNAMfa/Nz+Th91aSvSePc/u042fn9KBzq4axLk3kqIQbHGuBBEqMUyUih/bJqq088PYK0jfvYWByM/5x5SBSUzQXuNQM4QbHfmCRmX3Ifw9yeHtUqhKpplZs2s0f3l7BZ6tzSG7RgMevGMR5fdtpcEKpUcINjpnBS0TKsHlXLn9+byXTFmTSpF4Cv7qgF1edkKwh0KVGCveuqknRLkSkOtqbV8hTn6zh6c/WUlwMN5zcmfGndaNpg4RYlyYSNeHeVbWO/x7kEAB3P7bCKxKpBgqLipk6byN/+2AVOXvz+WH/Dvzs7O50aqHnMaTmC/dSVWqJ9/UITb6knj6pddyd2enZPPBOOhnZexma0oJnxvRkQKdmsS5NpNKEe6lqW6mmv5nZfODestYXqYmWZO7i/reX89Xa7RzbqiETrh7M8F5t1fEttU64l6oGlVisQ+gMJNyzFZFqLWvnAR6etZLpC7No0bAu943ozeVDk0mIC2twaZEaJ9y//P9c4n0hsJ5DzBUuUlPszi3gHx+t4dkv1mHArad24eZTu9Cknjq+pXYL91LVaSWXzSyO0BAkq6JRlEgs5RcW8+Lcb3nkw9XsPFDAxQOTuOus7nRoVj/WpYlUCeUNq94EuA1IAt4APgiW7wQWAy9Eu0CRyuLuzFq2hYfeTWddzj5O7NKSn5/XU3N+i5RS3hnHFGAHMAe4EfgFofk4Lnb3RVGuTaTSLNywg/vfWkHatzvo1qYRz107hFO7t1bHt0gZyguOY929L4CZPQNsApLdPTecLzezc4BHgDjgGXd/sNTnicBkQrMJbgMuc/f1ZtYSmAYMAZ539/ElthkMPA/UB94G7nD37z1jIhKODdv289CsdN5avIlWjRJ5YGRfLhnckXh1fIscUnnBUXDwjbsXmVlmBKERBzwODAcygXlmNtPdl5dYbSyww927mtlo4CHgMiAX+BXQJ3iV9AShs5+5hILjHOCdcGoSOWjn/nwem53B5Dnria9Th9vP6MZNPziWhom6WVCkPOX9X9K/1JSxB6eQNcDdvclhth0KZLj7WgAzmwqMIDSnx0EjgN8E76cBfzczc/d9wOdm1rXkF5pZe6CJu38VLE8GLkLBIWHKKyxiypxvefTD1ezJK+TSwZ346VnH0bZJvViXJlJtlDd17NGM0JYEbCyxnAkcf6h13L3QzHYBLYGcw3xnZqnvTCprRTMbB4wDSE5OjrR2qWHcnTcXb+KPs9LZuP0A/3Nca+45rwc92h3u3z4iUpYae17u7hOACQCpqanqA6nF5q3fzv1vrWDRxp30aNeYKWOHckq31rEuS6TaimZwZAGdSix3DNrKWifTzOKBpoQ6yQ/3nR3L+U4RANZu3ctD76Yza9kW2jZJ5E+j+jFyUEfi6uhOKZGjEc3gmAd0M7POhP5yHw1cUWqdmcAYQrf7jgJmH+4OKXffZGa7zewEQp3j1wCPRaN4qb627c3j0Q9X88LcDSTG1+HO4cdxwynHUr+u5sYQqQhRC46gz2I8MIvQ7bjPuvsyM7sPSHP3mcBEYIqZZQDbCYULAGa2HmgC1DWzi4CzgjuybuU/t+O+gzrGJZBbUMSzX6zjiY/WsL+giNFDOvHjM4+jdePEWJcmUqNYbXgEIjU11dPS0mJdhkRJcbEzY1EWD89ayXe7cjmzZxvuPrcHXds0jnVpItWamc1399TS7TW2c1xqhy/X5PCHt1ewNGs3fZOa8udLBzCsS8tYlyVSoyk4pFpavWUPD76Tzofp2SQ1q8/fLhvAhf07UEcd3yJRp+CQaiV7Ty5/+2A1U7/eQMO68dx9bg+uPTGFegnq+BapLAoOqRb25xfyzGfrePKTNeQXFnPNsBRuP6MbLRrWjXVpIrWOgkOqtKJi57X5mfz5/ZVs2Z3HuX3a8bNzetC5VcNYlyZSayk4pMr6dNVW/vD2CtI372FAp2Y8fsUgUlNaxLoskVpPwSFVzopNu/nD2yv4bHUOyS0a8PgVgzivbzvNjSFSRSg4pMrYvCuXP7+3kmkLMmlSL4Ffnt+Tq4cdQ2K8Or5FqhIFh8Tc3rxCJnyyhgmfraW4GG44uTPjT+tG0wYJsS5NRMqg4JCYKSwq5uW0jfz1/dXk7M3jh/078LOzu9OpRYNYlyYih6HgkErn7sxOz+aBd9LJyN7L0JQWPDMmlQGdmsW6NBEJg4JDKtXSrF3c/9YK5qzdRudWDXnq6sGc1autOr5FqhEFh1SKrJ0HeHjWSqYvzKJFw7r89sLeXHF8MglxdWJdmohESMEhUbU7t4B/fLSGZ0gnllUAAAz2SURBVL9YhwG3nNqFW07tQpN66vgWqa4UHBIVBUXFvPDVtzw6O4Pt+/IZOTCJO8/uTlKz+rEuTUSOkoJDKpS7M2vZFh56N511OfsYdmxLfnF+T/okNY11aSJSQRQcUiHcnfnf7uChd9OZt34H3do04tlrUzmtext1fIvUMAoOOSpZOw8wY2EWry/IZM3WfbRqlMgfLu7LpakdiVfHt0iNpOCQiO3JLeCdpZuZviCLr9Ztwx2GpDRn7MnHcuGADjRK1B8rkZpM/4dLWAqLivk8I4fpC7OYtWwzuQXFHNOyAT8+4zguHphEcks97S1SWyg45LCWf7eb1xdk8sY337F1Tx5N6yfwo0EdGTmoI4OSm6n/QqQWUnDI92zZncsbi7J4fUEW6Zv3kBBnnNa9DSMHJXFajzYarVaklotqcJjZOcAjQBzwjLs/WOrzRGAyMBjYBlzm7uuDz+4BxgJFwO3uPitoXw/sCdoL3T01mvtQW+zPL+S9ZVt4bUEmX2TkUOwwoFMzfjeiNxf060BzTdEqIoGoBYeZxQGPA8OBTGCemc109+UlVhsL7HD3rmY2GngIuMzMegGjgd5AB+ADMzvO3YuC7U5z95xo1V5bFBc7X63dxmsLsnh36Sb25ReR1Kw+t53WlYsGJtGldaNYlygiVVA0zziGAhnuvhbAzKYCI4CSwTEC+E3wfhrwdwtdNB8BTHX3PGCdmWUE3zcnivXWGqu37OH1hVnMWJjFpl25NE6M54J+Hbh4UBJDU1pQp476LUTk0KIZHEnAxhLLmcDxh1rH3QvNbBfQMmj/qtS2ScF7B94zMweecvcJZf1yMxsHjANITk4+uj2pAXL25vGvb77j9QVZLMnaRVwd4wfdWvHz83oyvFdb6iWo30JEwlMdO8dPdvcsM2sDvG9m6e7+aemVgkCZAJCamuqVXWRVkFtQxAcrtjB9QRYfr9pKUbHTJ6kJv7qgFxf270DrxomxLlFEqqFoBkcW0KnEcsegrax1Ms0sHmhKqJP8kNu6+8Gf2WY2ndAlrO8FR21VXOykfbuD1xdk8taSTezJLaRdk3rceMqxjByUxHFtG8e6RBGp5qIZHPOAbmbWmdBf+qOBK0qtMxMYQ6jvYhQw293dzGYCL5rZXwh1jncDvjazhkAdd98TvD8LuC+K+1BtrMvZx/QFmUxflMXG7QdoUDeOc/q0Y+TAjgzr0pI49VuISAWJWnAEfRbjgVmEbsd91t2Xmdl9QJq7zwQmAlOCzu/thMKFYL1XCHWkFwK3uXuRmbUFpgcPncUDL7r7u9Hah6pu5/58/rV4E68vyGThhp2YwcldW/GTM4/j7N7taKihP0QkCsy95l/+T01N9bS0tFiXUSFyC4r4eOVWpi/MZHZ6NgVFTve2jRk5KIkRA5Jo17RerEsUkRrCzOaX9ayc/klaDeQVFvHZqhzeWrKJ95dvYW9eIa0aJXLNsBRGDkqiV/smGvpDRCqNgqOKyi8s5os1Obz5zSbeW76ZPbmFNK2fwPl923N+v/ac2KWlhi0XkZhQcFQhBUXFzFmzjbcWb+LdZZvZdaCAxvXiObt3O87v156TurSibrzCQkRiS8ERY4VFxcxdt503F2/i3aWb2LG/gEaJ8Qzv1ZYL+rXn5G6tNKigiFQpCo4YKCp25q3fzpuLv+PdpZvJ2ZtPg7pxnNmzLef3a8//HNdaT3KLSJWl4KgkxcXO/A07eGvxJt5esonsPXnUT4jj9J5tuKBve07r0UZhISLVgoIjivbnF/JFxjZmp2czO30LW3bnkRhfh9O6t+GC/u05vUcbGtTVIRCR6kV/a1Wwjdv3B0GRzZy128gvLKZRYjyndGvFOX3acUbPtpqTW0SqNf0NdpQKi4qZ/+2Of4fF6uy9ABzbqiFXn3AMp/dow5CUFrobSkRqDAXHEdiTW8Cnq3L4YMUWZqdns+tAAQlxxtDOLRg9NJnTe7Shc6uGsS5TRCQqFBxhcnc+WpnNc1+s56u12ygocpo3SODMnm05o2cbTunWisb1EmJdpohI1Ck4yvHi3A1s3p3Lp6u2smjjTpKa1ef6kzpzZq+2DEpurlFnRaTWUXAcxoZt+/n59CUAdGhajwdH9uVHgzuSoKE+RKQWU3AcQkFRMXe/vpg6Bh/fdRodm9fXXNwiIig4Dikhrg492zfhh/07kNyyQazLERGpMhQch/GrC3rFugQRkSpHF+tFRCQiCg4REYmIgkNERCKi4BARkYgoOEREJCIKDhERiYiCQ0REIqLgEBGRiJi7x7qGqDOzrcC3R7h5KyCnAsupymrTvkLt2t/atK9Qu/Y3mvt6jLu3Lt1YK4LjaJhZmrunxrqOylCb9hVq1/7Wpn2F2rW/sdhXXaoSEZGIKDhERCQiCo7yTYh1AZWoNu0r1K79rU37CrVrfyt9X9XHISIiEdEZh4iIRETBISIiEVFwHIKZnWNmK80sw8zujnU9R8vMOpnZR2a23MyWmdkdQXsLM3vfzFYHP5sH7WZmjwb7v9jMBsV2D46MmcWZ2UIzezNY7mxmc4P9etnM6gbticFyRvB5SizrjpSZNTOzaWaWbmYrzGxYTT62ZvaT4M/xUjN7yczq1aRja2bPmlm2mS0t0Rbx8TSzMcH6q81sTEXVp+Aog5nFAY8D5wK9gMvNrLpPB1gI3OnuvYATgNuCfbob+NDduwEfBssQ2vduwWsc8ETll1wh7gBWlFh+CPiru3cFdgBjg/axwI6g/a/BetXJI8C77t4D6E9on2vksTWzJOB2INXd+wBxwGhq1rF9HjinVFtEx9PMWgC/Bo4HhgK/Phg2R83d9Sr1AoYBs0os3wPcE+u6Kngf3wCGAyuB9kFbe2Bl8P4p4PIS6/97veryAjoG/4OdDrwJGKEnbONLH2dgFjAseB8frGex3ocw97MpsK50vTX12AJJwEagRXCs3gTOrmnHFkgBlh7p8QQuB54q0f5f6x3NS2ccZTv4B/OgzKCtRghO1QcCc4G27r4p+Ggz0DZ4XxP+G/wN+BlQHCy3BHa6e2GwXHKf/r2/wee7gvWrg87AVuC54LLcM2bWkBp6bN09C3gY2ABsInSs5lMzj21JkR7PqB1nBUctY2aNgNeAH7v77pKfeeifJTXi/mwzuwDIdvf5sa6lEsQDg4An3H0gsI//XMYAatyxbQ6MIBSYHYCGfP+yTo0W6+Op4ChbFtCpxHLHoK1aM7MEQqHxgru/HjRvMbP2weftgeygvbr/NzgJuNDM1gNTCV2uegRoZmbxwTol9+nf+xt83hTYVpkFH4VMINPd5wbL0wgFSU09tmcC69x9q7sXAK8TOt418diWFOnxjNpxVnCUbR7QLbhLoy6hjreZMa7pqJiZAROBFe7+lxIfzQQO3m0xhlDfx8H2a4I7Nk4AdpU4Ta7y3P0ed+/o7imEjt9sd78S+AgYFaxWen8P/ncYFaxfLf6F7u6bgY1m1j1oOgNYTg09toQuUZ1gZg2CP9cH97fGHdtSIj2es4CzzKx5cJZ2VtB29GLdAVRVX8B5wCpgDfCLWNdTAftzMqFT28XAouB1HqFrvR8Cq4EPgBbB+kbozrI1wBJCd7DEfD+OcN9PBd4M3h8LfA1kAK8CiUF7vWA5I/j82FjXHeE+DgDSguM7A2hek48t8FsgHVgKTAESa9KxBV4i1H9TQOiMcuyRHE/g+mC/M4DrKqo+DTkiIiIR0aUqERGJiIJDREQiouAQEZGIKDhERCQiCg4REYmIgkOkCjCzUw+O4CtS1Sk4REQkIgoOkXKYWUowz8XzZrbKzF4wszPN7ItgnoOhZWzzlZn1LrH8sZmlmtlQM5sTDEb4ZYmnvUtu+xszu6vE8tKDc0iY2VVm9rWZLTKzpyw030hcUNtSM1tiZj+Jzn8JkRAFh0h4ugJ/BnoErysIPY1/F/DzMtZ/GbgU/j2uUHt3TyP0tPMpHhqM8F7gD+EWYGY9gcuAk9x9AFAEXEnoqfEkd+/j7n2B545oD0XCFF/+KiJCaFC9JQBmtozQhDpuZksIzZtQ2ivAe4Qm0rmU0MCDEBpgb5KZdSM0BExCBDWcAQwG5oWGaKI+oYHu/gUca2aPAW8Fv1ckahQcIuHJK/G+uMRyMWX8f+TuWWa2zcz6ETpLuDn46HfAR+5+cXD56eMyflch/301oF7w04BJ7n5P6Q3MrD+hyYxuJhRU14e1VyJHQJeqRKLnZUITSTV198VBW1P+M7T1tYfYbj2hYdEJ5o/uHLR/CIwyszbBZy3M7BgzawXUcffXgF8e3FYkWhQcItEzjdCQ7q+UaPsj8ICZLeTQZ/yvAS2CS2LjCY3SjLsvJxQM75nZYuB9QlOEJgEfm9ki4J+EpjoWiRqNjisiIhHRGYeIiEREwSEiIhFRcIiISEQUHCIiEhEFh4iIRETBISIiEVFwiIhIRP4/a1muUqKfi1kAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.figure()\n",
    "plt.plot(m_vals, time_taken)\n",
    "plt.xlabel('m values')\n",
    "plt.ylabel('Runtime (seconds)')"
   ]
  }
 ],
 "metadata": {
  "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}