Completed lab 4

diff --git a/full_script.py b/full_script.py
new file mode 100644 (file)
index 0000000..a45375a
--- /dev/null
+++ b/full_script.py
@@ -0,0 +1,589 @@
+# %% 
+import numpy as np
+import matplotlib.pyplot as plt
+import scipy as stats
+from scipy.fftpack import fft, rfft, irfft, fftfreq, rfftfreq
+import scipy.signal
+from scipy.stats import norm, expon
+import math
+
+def diff_letters(a,b):
+    return sum ( a[i] != b[i] for i in range(len(a)) )
+
+# %%
+# Create constellations
+
+M = 8
+first = (2 - 1 - M)
+last = (16 - 1 - M)
+PAM8 = np.linspace(first, last, 8)
+
+M = 4
+QPSK = [[math.cos(2* math.pi * m / M), math.sin(2 * math.pi * m / M)] for m in range(M)]
+
+M = 8
+PSK8 = [[math.cos(2 * math.pi * m / M), math.sin(2 * math.pi * m / M)] for m in range(M)]
+
+M = 4
+first = (-3)
+last = (3)
+PAM4 = np.linspace(first, last, 4)
+QAM16 = []
+for i in PAM4:
+    for j in PAM4:
+        QAM16.append([i, j])
+
+# %%
+# Assign gray codes: 
+
+g_PAM8 = {format(k, '03b'): i for k, i in zip([0, 1, 3, 2, 6, 7, 5, 4], PAM8)}
+
+g_QPSK = {format(k, '02b'): i for k, i in zip([0,1,3,2], QPSK)}
+
+g_PSK8 = {format(k, '03b'): i for k, i in zip([0, 1, 3, 2, 6, 7, 5, 4], PSK8)}
+
+g_QAM16 = {format(k, '04b'): i for k, i in zip([0, 1, 3, 2, 4, 5, 7, 6, 12, 13, 15, 14, 8, 9, 11, 10], QAM16)}
+
+# %%
+# Plot constellations
+
+# PAM-8
+plt.figure(figsize=(4, 1))
+plt.title("PAM-8 modulation, gray coding")
+plt.plot(PAM8, [0]*8, 'o')
+plt.yticks([])
+plt.xticks(PAM8)
+plt.grid(True)
+for (k, s) in g_PAM8.items():
+    plt.text(s, 0, k)
+
+# QPSK
+x = [x for x, y in QPSK]
+y = [y for x, y in QPSK]
+
+circle_x = np.linspace(0, 2*np.pi, 100)
+
+plt.figure(figsize=(4, 4))
+plt.title("QPSK modulation, gray coding")
+plt.plot(np.cos(circle_x), np.sin(circle_x), color="orange")
+plt.plot(x,y,'o', color="blue")
+plt.xticks(x)
+plt.yticks(y)
+plt.grid(True)
+for (k, s) in g_QPSK.items():
+    plt.text(*s, k)
+
+# PSK8
+x = [x for x, y in PSK8]
+y = [y for x, y in PSK8]
+
+plt.figure(figsize=(4, 4))
+plt.title("PSK-8 modulation, gray coding")
+plt.plot(np.cos(circle_x), np.sin(circle_x), color="orange")
+plt.plot(x,y,'o', color="blue")
+plt.xticks(x, rotation=45)
+plt.yticks(y)
+plt.grid(True)
+for (k, s) in g_PSK8.items():
+    plt.text(*s, k)
+
+# QAM16
+x = [x for x, y in QAM16]
+y = [y for x, y in QAM16]
+
+plt.figure(figsize=(4, 4))
+plt.title("QAM16")
+plt.plot(x,y,'o')
+plt.xticks(x)
+plt.yticks(y)
+plt.grid(True)
+for (k, s) in g_QAM16.items():
+    plt.text(*s, k)
+
+# %%
+# Transmission through AWGN channel
+
+num_symbols = 10**6
+SNR_list = np.linspace(-20, 20, 21)
+
+# %%
+# PAM8 transmission
+
+symbol_error_rate = []
+bit_error_rate = []
+
+symbols = np.random.randint(0, len(PAM8), size=(num_symbols))
+
+PAM8_symbols = np.zeros(num_symbols, dtype=int)
+for i, s in enumerate(symbols):
+    PAM8_symbols[i] = PAM8[s]
+
+for SNR_dB in SNR_list:
+
+    SNR_linear = 10**(SNR_dB / 10)
+
+    signal_power = np.mean(np.abs(PAM8_symbols)**2)
+    noise_power = signal_power / SNR_linear
+
+    noise = noise_power * np.random.normal(0, 1, len(PAM8_symbols))
+    rx_signal = PAM8_symbols + noise
+
+    distances = np.zeros(len(PAM8), dtype=float)
+    detected_symbols = np.zeros(num_symbols, dtype=int)
+    for i, r in enumerate(rx_signal):
+        for j, s in enumerate(PAM8):
+            distances[j] = np.linalg.norm(r - s)
+            
+        detected_symbols[i] = PAM8[np.argmin(distances)]
+        
+    errors = 0
+    bit_errors = 0
+    for i in range(num_symbols):
+        if PAM8_symbols[i] != detected_symbols[i]:
+            errors += 1
+            code = ""
+            expected_code = ""
+            for k, v in g_PAM8.items():
+                if v == PAM8_symbols[i]:
+                    expected_code = k
+                elif v == detected_symbols[i]:
+                    code = k
+                
+                if code != "" and expected_code != "":
+                    break
+                    
+            bit_errors += diff_letters(code, expected_code)
+        
+    SER = errors / num_symbols
+    
+    BER = bit_errors / num_symbols
+
+    # Make the plot for specific SNR_dB
+    if SNR_dB == 20:
+        plt.figure(figsize=(4, 1))
+        plt.title("Recieved symbols, PAM-8 modulation (SNR_dB = 20)")
+        plt.plot(rx_signal, np.zeros(num_symbols), 'o', color="red")
+        plt.plot(PAM8, [0]*len(PAM8), 'o', color="blue")
+        plt.yticks([])
+        plt.xticks(PAM8)
+        plt.grid(True)
+        for (k, s) in g_PAM8.items():
+            plt.text(s, 0, k)
+
+            
+    symbol_error_rate.append(SER)
+    bit_error_rate.append(BER)
+
+# Final curve plot
+plt.figure(figsize=(4, 4))
+plt.title("PAM-8 modulation error rate")
+plt.plot(SNR_list, symbol_error_rate, 'o-', color="blue")
+plt.plot(SNR_list, bit_error_rate, 'o-', color="red")
+plt.xlabel("SNR (dB)")
+plt.ylabel("Error rate")
+plt.legend(["Symbol error rate", "Bit error rate"])
+
+# %%
+# QPSK transmission
+
+symbol_error_rate = []
+bit_error_rate = []
+
+symbols = np.random.randint(0, len(QPSK), size=(num_symbols))
+
+QPSK_symbols = np.zeros((num_symbols, 2), dtype=float)
+for i, s in enumerate(symbols):
+    QPSK_symbols[i] = QPSK[s]
+
+for SNR_dB in SNR_list:
+
+    SNR_linear = 10**(SNR_dB / 10)
+
+    signal_power = np.mean(np.abs(QPSK_symbols)**2)
+    noise_power = signal_power / SNR_linear
+
+    noise = noise_power * np.random.normal(0, 1, size=(num_symbols, 2))
+    rx_signal = QPSK_symbols + noise
+
+    distances = np.zeros(len(QPSK), dtype=float)
+    detected_symbols = np.zeros((num_symbols, 2), dtype=float)
+    for i, r in enumerate(rx_signal):
+        for j, s in enumerate(QPSK):
+            distances[j] = np.linalg.norm(r - s)
+            
+        detected_symbols[i] = QPSK[np.argmin(distances)]
+    
+    errors = 0
+    bit_errors = 0
+    for i in range(num_symbols):
+        if QPSK_symbols[i][0] != detected_symbols[i][0] or QPSK_symbols[i][1] != detected_symbols[i][1]:
+            errors += 1
+            code = ""
+            expected_code = ""
+            for k, v in g_QPSK.items():
+                if v[0] == QPSK_symbols[i][0] and v[1] == QPSK_symbols[i][1]:
+                    expected_code = k
+                elif v[0] == detected_symbols[i][0] and v[1] == detected_symbols[i][1]:
+                    code = k
+                
+                if code != "" and expected_code != "":
+                    break
+                    
+            bit_errors += diff_letters(code, expected_code)
+        
+    SER = errors / num_symbols
+    
+    BER = bit_errors / num_symbols
+    
+    # Make the plot for specific SNR_dB
+    if SNR_dB == 10:
+        r_x = [x for x, y in rx_signal]
+        r_y = [y for x, y in rx_signal]
+
+        x = [x for x, y in QPSK]
+        y = [y for x, y in QPSK]
+
+        plt.figure(figsize=(4, 4))
+        plt.title("Recieved symbols, QPSK modulation (SNR_dB = 10)")
+        plt.plot(np.cos(circle_x), np.sin(circle_x), color="orange")
+        plt.plot(r_x, r_y, 'o', color="red")
+        plt.plot(x,y,'o', color="blue")
+        plt.xticks(x, rotation=45)
+        plt.yticks(y)
+        plt.grid(True)
+        for (k, s) in g_QPSK.items():
+            plt.text(*s, k)
+        
+    symbol_error_rate.append(SER)
+    bit_error_rate.append(BER)
+
+# Final curve plot
+plt.figure(figsize=(4, 4))
+plt.title("QPSK modulation error rate")
+plt.plot(SNR_list, symbol_error_rate, 'o-', color="blue")
+plt.plot(SNR_list, bit_error_rate, 'o-', color="red")
+plt.legend(["Symbol error rate", "Bit error rate"])
+plt.xlabel("SNR (dB)")
+plt.ylabel("Error rate")
+
+# %%
+# PSK8 transmission
+
+symbol_error_rate = []
+bit_error_rate = []
+
+symbols = np.random.randint(0, len(PSK8), size=(num_symbols))
+
+PSK8_symbols = np.zeros((num_symbols, 2), dtype=float)
+for i, s in enumerate(symbols):
+    PSK8_symbols[i] = PSK8[s]
+
+for SNR_dB in SNR_list:
+
+    SNR_linear = 10**(SNR_dB / 10)
+
+    signal_power = np.mean(np.abs(PSK8_symbols)**2)
+    noise_power = signal_power / SNR_linear
+
+    noise = noise_power * np.random.normal(0, 1, size=(num_symbols, 2))
+    rx_signal = PSK8_symbols + noise
+
+    distances = np.zeros(len(PSK8), dtype=float)
+    detected_symbols = np.zeros((num_symbols, 2), dtype=float)
+    for i, r in enumerate(rx_signal):
+        for j, s in enumerate(PSK8):
+            distances[j] = np.linalg.norm(r - s)
+            
+        detected_symbols[i] = PSK8[np.argmin(distances)]
+    
+    errors = 0
+    bit_errors = 0
+    for i in range(num_symbols):
+        if PSK8_symbols[i][0] != detected_symbols[i][0] or PSK8_symbols[i][1] != detected_symbols[i][1]:
+            errors += 1
+            code = ""
+            expected_code = ""
+            for k, v in g_PSK8.items():
+                if v[0] == PSK8_symbols[i][0] and v[1] == PSK8_symbols[i][1]:
+                    expected_code = k
+                elif v[0] == detected_symbols[i][0] and v[1] == detected_symbols[i][1]:
+                    code = k
+                
+                if code != "" and expected_code != "":
+                    break
+                    
+            bit_errors += diff_letters(code, expected_code)
+        
+    SER = errors / num_symbols
+    
+    BER = bit_errors / num_symbols
+    
+    # Make the plot for specific SNR_dB
+    if SNR_dB == 10:
+        r_x = [x for x, y in rx_signal]
+        r_y = [y for x, y in rx_signal]
+
+        x = [x for x, y in PSK8]
+        y = [y for x, y in PSK8]
+
+        plt.figure(figsize=(4, 4))
+        plt.title("Recieved symbols, PSK-8 modulation (SNR_dB = 10)")
+        plt.plot(np.cos(circle_x), np.sin(circle_x), color="orange")
+        plt.plot(r_x, r_y, 'o', color="red")
+        plt.plot(x,y,'o', color="blue")
+        plt.xticks(x, rotation=45)
+        plt.yticks(y)
+        plt.grid(True)
+        for (k, s) in g_PSK8.items():
+            plt.text(*s, k)
+        
+    symbol_error_rate.append(SER)
+    bit_error_rate.append(BER)
+
+# Final curve plot
+plt.figure(figsize=(4, 4))
+plt.title("PSK-8 modulation error rate")
+plt.plot(SNR_list, symbol_error_rate, 'o-', color="blue")
+plt.plot(SNR_list, bit_error_rate, 'o-', color="red")
+plt.legend(["Symbol error rate", "Bit error rate"])
+plt.xlabel("SNR (dB)")
+plt.ylabel("Error rate")
+
+# %%
+# QAM16 transmission
+symbol_error_rate = []
+bit_error_rate = []
+
+symbols = np.random.randint(0, len(QAM16), size=(num_symbols))
+
+QAM16_symbols = np.zeros((num_symbols, 2), dtype=float)
+for i, s in enumerate(symbols):
+    QAM16_symbols[i] = QAM16[s]
+
+for SNR_dB in SNR_list:
+
+    SNR_linear = 10**(SNR_dB / 10)
+
+    signal_power = np.mean(np.abs(QAM16_symbols)**2)
+    noise_power = signal_power / SNR_linear
+
+    noise = noise_power * np.random.normal(0, 1, size=(num_symbols, 2))
+    rx_signal = QAM16_symbols + noise
+
+    distances = np.zeros(len(QAM16), dtype=float)
+    detected_symbols = np.zeros((num_symbols, 2), dtype=float)
+    for i, r in enumerate(rx_signal):
+        for j, s in enumerate(QAM16):
+            distances[j] = np.linalg.norm(r - s)
+            
+        detected_symbols[i] = QAM16[np.argmin(distances)]
+    
+    errors = 0
+    bit_errors = 0
+    for i in range(num_symbols):
+        if QAM16_symbols[i][0] != detected_symbols[i][0] or QAM16_symbols[i][1] != detected_symbols[i][1]:
+            errors += 1
+            code = ""
+            expected_code = ""
+            for k, v in g_QAM16.items():
+                if v[0] == QAM16_symbols[i][0] and v[1] == QAM16_symbols[i][1]:
+                    expected_code = k
+                elif v[0] == detected_symbols[i][0] and v[1] == detected_symbols[i][1]:
+                    code = k
+                
+                if code != "" and expected_code != "":
+                    break
+                    
+            bit_errors += diff_letters(code, expected_code)
+        
+    SER = errors / num_symbols
+    
+    BER = bit_errors / num_symbols
+    
+    # print("errors: ", errors)
+    # print("QAM16 Symbol error rate (SER): ", SER)
+    
+    # Make the plot for specific SNR_dB
+    if SNR_dB == 20:
+        r_x = [x for x, y in rx_signal]
+        r_y = [y for x, y in rx_signal]
+
+        x = [x for x, y in QAM16]
+        y = [y for x, y in QAM16]
+
+        plt.figure(figsize=(4, 4))
+        plt.title("Recieved symbols, QAM-16 modulation (SNR_dB = 20)")
+        plt.plot(r_x, r_y, 'o', color="red")
+        plt.plot(x,y,'o', color="blue")
+        plt.xticks(x)
+        plt.yticks(y)
+        plt.grid(True)
+        for (k, s) in g_QAM16.items():
+            plt.text(*s, k)
+        
+    symbol_error_rate.append(SER)
+    bit_error_rate.append(BER)
+
+# Final curve plot
+plt.figure(figsize=(4, 4))
+plt.title("QAM-16 modulation error rate")
+plt.plot(SNR_list, symbol_error_rate, 'o-', color="blue")
+plt.plot(SNR_list, bit_error_rate, 'o-', color="red")
+plt.legend(["Symbol error rate", "Bit error rate"])
+plt.xlabel("SNR (dB)")
+plt.ylabel("Error rate")
+
+# %%
+# Hamming code
+
+def hamming_encode(data):
+    if len(data) % 4 != 0:
+        raise ValueError("input data multiple of 4")
+
+    G = [[1, 0, 0, 1, 0, 1, 1],
+         [0, 1, 0, 1, 0, 1, 0],
+         [0, 0, 1, 1, 0, 0, 1],
+         [0, 0, 0, 0, 1, 1, 1]]
+    
+    encoded_data = []
+    for k in range(0, len(data), 4):
+        block = data[k:k+4]
+        for i in range(7):
+            sum = 0
+            for j in range(4):
+                sum += block[j] * G[j][i]
+            encoded_data.append(sum  % 2)
+        
+    return encoded_data
+
+def hamming_decode(recieved_data):
+    if len(recieved_data) % 7 != 0:
+        raise ValueError("Recieved data length mult of 7")
+    
+    H = [[1, 0, 1, 0, 1, 0, 1],
+         [1, 1, 0, 0, 1, 1, 0],
+         [1, 1, 1, 1, 0, 0, 0]]
+    
+    decoded_data = []
+    for k in range(0, len(recieved_data), 7):
+        block = recieved_data[k:k+7]
+        syndrome= []
+        for i in range(3):
+            syndrome_sum = 0
+            for j in range(7):
+                syndrome_sum += block[j] * H[i][j]
+            syndrome.append(syndrome_sum % 2)
+        error_pos = sum([2 ** i for i, bit in enumerate(syndrome) if bit])
+        if error_pos > 0:
+            block[7-error_pos] ^= 1
+        decoded_data.extend([block[0], block[1], block[2], block[4]])
+    return decoded_data
+
+num_data_bits_by_4 = 10**6
+
+data = np.zeros(4 * num_data_bits_by_4)
+for i in range(4 * num_data_bits_by_4):
+    data[i] = np.random.randint(0, 2)
+
+encoded = np.array(hamming_encode(data))
+
+ber_encoded = []
+ber_plain = []
+
+QPSK_symbols_encoded = np.array([g_QPSK[str(int(block[0])) + str(int(block[1]))] for block in encoded.reshape(int(len(encoded) / 2), 2)])
+QPSK_symbols_plain = np.array([g_QPSK[str(int(block[0])) + str(int(block[1]))] for block in data.reshape(int(len(data) / 2), 2)])
+
+num_symbols_encoded = len(QPSK_symbols_encoded)
+num_symbols_plain = len(QPSK_symbols_plain)
+
+SNR_list = np.linspace(-20, 10, 16)
+
+# Encoded QPSK transmission
+for SNR_dB in SNR_list:
+
+    SNR_linear = 10**(SNR_dB / 10)
+
+    signal_power = np.mean(np.abs(QPSK_symbols_encoded)**2)
+    noise_power = signal_power / SNR_linear
+
+    noise = noise_power * np.random.normal(0, 1, size=(num_symbols_encoded, 2))
+    rx_signal = QPSK_symbols_encoded + noise
+
+    distances = np.zeros(len(QPSK), dtype=float)
+    detected_symbols = np.zeros((num_symbols_encoded, 2), dtype=float)
+    for i, r in enumerate(rx_signal):
+        for j, s in enumerate(QPSK):
+            distances[j] = np.linalg.norm(r - s)
+            
+        detected_symbols[i] = QPSK[np.argmin(distances)]
+    
+    recv = []
+    for i in range(num_symbols_encoded):
+        code = ""
+        for k, v in g_QPSK.items():
+            if v[0] == detected_symbols[i][0] and v[1] == detected_symbols[i][1]:
+                code = k
+                break
+        
+        for char in code:
+            recv.append(int(char))
+                
+    decoded = np.array(hamming_decode(recv))
+    
+    bit_errors = np.sum(data != decoded)
+    BER = bit_errors / num_symbols_encoded
+        
+    ber_encoded.append(BER)
+
+# Plain QPSK transmission
+for SNR_dB in SNR_list:
+
+    SNR_linear = 10**(SNR_dB / 10)
+
+    signal_power = np.mean(np.abs(QPSK_symbols_plain)**2)
+    noise_power = signal_power / SNR_linear
+
+    noise = noise_power * np.random.normal(0, 1, size=(num_symbols_plain, 2))
+    rx_signal = QPSK_symbols_plain + noise
+
+    distances = np.zeros(len(QPSK), dtype=float)
+    detected_symbols = np.zeros((num_symbols_plain, 2), dtype=float)
+    for i, r in enumerate(rx_signal):
+        for j, s in enumerate(QPSK):
+            distances[j] = np.linalg.norm(r - s)
+            
+        detected_symbols[i] = QPSK[np.argmin(distances)]
+    
+    recv = []
+    for i in range(num_symbols_plain):
+        code = ""
+        for k, v in g_QPSK.items():
+            if v[0] == detected_symbols[i][0] and v[1] == detected_symbols[i][1]:
+                code = k
+                break
+        
+        for char in code:
+            recv.append(int(char))
+                
+    bit_errors = np.sum(data != np.array(recv))
+    BER = bit_errors / num_symbols_plain
+        
+    ber_plain.append(BER)
+
+plt.figure(3)
+plt.semilogy(SNR_list, ber_encoded, 'o-', label="With hamming")
+plt.semilogy(SNR_list, ber_plain, 's-', label="Without encoding")
+plt.title("Bit error rate for QPSK communication with and without encoding")
+plt.xlabel("SNR (dB)")
+plt.ylabel("Bit error rate")
+plt.legend()
+plt.grid(True)
+plt.show()
+
+
+
+# Also check with Rayleigh-fading channel
+
+
+
+# %%

diff --git a/lab4.ipynb b/lab4.ipynb
index 78620870ef9a96e043286bd075a9525d159bcb4e..63186548bd67b7ec72049808750c65fa07cd6a8f 100644 (file)
--- a/lab4.ipynb
+++ b/lab4.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 613,
+   "execution_count": 63,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -12,39 +12,28 @@
     "from scipy.fftpack import fft, rfft, irfft, fftfreq, rfftfreq\n",
     "import scipy.signal\n",
     "from scipy.stats import norm, expon\n",
-    "import math"
+    "import math\n",
+    "\n",
+    "def diff_letters(a,b):\n",
+    "    return sum ( a[i] != b[i] for i in range(len(a)) )"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 614,
+   "execution_count": 64,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[-7. -5. -3. -1.  1.  3.  5.  7.]\n",
-      "[[0.7071067811865476, 0.7071067811865475], [-0.7071067811865475, 0.7071067811865476], [-0.7071067811865477, -0.7071067811865475], [0.7071067811865474, -0.7071067811865477]]\n",
-      "[[0.9238795325112867, 0.3826834323650898], [0.38268343236508984, 0.9238795325112867], [-0.3826834323650897, 0.9238795325112867], [-0.9238795325112867, 0.3826834323650899], [-0.9238795325112868, -0.38268343236508967], [-0.38268343236509034, -0.9238795325112865], [0.38268343236509, -0.9238795325112866], [0.9238795325112865, -0.3826834323650904]]\n",
-      "[[np.float64(-3.0), np.float64(-3.0)], [np.float64(-3.0), np.float64(-1.0)], [np.float64(-3.0), np.float64(1.0)], [np.float64(-3.0), np.float64(3.0)], [np.float64(-1.0), np.float64(-3.0)], [np.float64(-1.0), np.float64(-1.0)], [np.float64(-1.0), np.float64(1.0)], [np.float64(-1.0), np.float64(3.0)], [np.float64(1.0), np.float64(-3.0)], [np.float64(1.0), np.float64(-1.0)], [np.float64(1.0), np.float64(1.0)], [np.float64(1.0), np.float64(3.0)], [np.float64(3.0), np.float64(-3.0)], [np.float64(3.0), np.float64(-1.0)], [np.float64(3.0), np.float64(1.0)], [np.float64(3.0), np.float64(3.0)]]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "M = 8\n",
     "first = (2 - 1 - M)\n",
     "last = (16 - 1 - M)\n",
     "PAM8 = np.linspace(first, last, 8)\n",
-    "print(PAM8)\n",
     "\n",
     "M = 4\n",
-    "QPSK = [[math.cos((math.pi/M) + 2 * math.pi * m / M), math.sin((math.pi/M) + 2 * math.pi * m / M)] for m in range(M)]\n",
-    "print(QPSK)\n",
+    "QPSK = [[math.cos(2* math.pi * m / M), math.sin(2 * math.pi * m / M)] for m in range(M)]\n",
     "\n",
     "M = 8\n",
-    "PSK8 = [[math.cos((math.pi/M) + 2 * math.pi * m / M), math.sin((math.pi/M) + 2 * math.pi * m / M)] for m in range(M)]\n",
-    "print(PSK8)\n",
+    "PSK8 = [[math.cos(2 * math.pi * m / M), math.sin(2 * math.pi * m / M)] for m in range(M)]\n",
     "\n",
     "M = 4\n",
     "first = (-3)\n",
@@ -53,47 +42,36 @@
     "QAM16 = []\n",
     "for i in PAM4:\n",
     "    for j in PAM4:\n",
-    "        QAM16.append([i, j])\n",
-    "print(QAM16)\n"
+    "        QAM16.append([i, j])\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 615,
+   "execution_count": 65,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Assign gray codes: \n",
     "\n",
-    "g_PAM8 = {format(k, '03b'): i for k, i in enumerate(PAM8)}\n",
+    "g_PAM8 = {format(k, '03b'): i for k, i in zip([0, 1, 3, 2, 6, 7, 5, 4], PAM8)}\n",
     "\n",
-    "g_QPSK = {format(k, '03b'): i for k, i in enumerate(QPSK)}\n",
+    "g_QPSK = {format(k, '02b'): i for k, i in zip([0,1,3,2], QPSK)}\n",
     "\n",
-    "g_PSK8 = {format(k, '03b'): i for k, i in enumerate(PSK8)}\n",
+    "g_PSK8 = {format(k, '03b'): i for k, i in zip([0, 1, 3, 2, 6, 7, 5, 4], PSK8)}\n",
     "\n",
-    "g_QAM16 = {format(k, '03b'): i for k, i in enumerate(QAM16)}"
+    "g_QAM16 = {format(k, '04b'): i for k, i in zip([0, 1, 3, 2, 4, 5, 7, 6, 12, 13, 15, 14, 8, 9, 11, 10], QAM16)}"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 616,
+   "execution_count": 66,
    "metadata": {},
    "outputs": [
     {
      "data": {
+      "image/png": "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",
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7fc1d0552590>]"
-      ]
-     },
-     "execution_count": 616,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 400x400 with 1 Axes>"
+       "<Figure size 400x100 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -101,7 +79,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWsAAAF2CAYAAACoDrk9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/GU6VOAAAACXBIWXMAAA9hAAAPYQGoP6dpAABIzElEQVR4nO3dd3gU1f7H8fdseieNhJBA6F1QOkIoUkREEEUBEUEEuxS92K6iXht6RSyoqAiicFUUQcQfHQSRDqGKUhJ6AklIQnqb3x8nWQhJIAmbzJbv63n22cns7M53w/LJ7Jkz52i6rusIIYSwaiajCxBCCHFtEtZCCGEDJKyFEMIGSFgLIYQNkLAWQggbIGEthBA2QMJaCCFsgIS1EELYAAlrIYSwARLWokrNnTsXTdOIjY2t8HPXr1+PpmmsX7/eojVpmsYrr7xi0dcUllHa56VHjx706NHDsJqshYT1NRw4cICRI0dSu3Zt3NzcCAsLY+TIkRw8eLDEtkUftKKbu7s7jRs35oknniA+Pr7YtrGxsYwZM4YGDRrg7u5OaGgoUVFRTJ06tdh2PXr0oGXLliX2tWbNGjw9PbnppptISkqy7Ju2A7/99psEsrArzkYXYM0WLVrE8OHDCQgIYOzYsdSrV4/Y2Fhmz57Njz/+yPfff8+gQYNKPO+1116jXr16ZGVl8ccff/Dpp5/y22+/sX//fjw9PTly5Ajt27fHw8ODBx98kMjISM6ePcuuXbuYNm0ar7766lXrWrt2LQMHDqRJkyasXr2agICAqvoV2KzffvuNmTNnlhrYmZmZODvLR99WrFy50ugSrIJ8Ystw9OhR7r//furXr8+GDRsIDg42PzZhwgS6devGyJEj2bt3L/Xq1Sv23P79+9OuXTsAHnroIQIDA5k+fTpLlixh+PDhvP/++6SlpREdHU3dunWLPffcuXNXrev3339n4MCBNG7cWIK6ktzd3Y0uwWIyMjLw9PQ0uowq5erqanQJVkGaQcrw7rvvkpGRweeff14sqAGCgoKYNWsWaWlpvPvuu9d8rV69egEQExMDqD8E4eHhJYIaoGbNmmW+zsaNGxkwYAANGzZk9erVBAYGXnPfRc0oe/fupXv37nh6etKwYUN+/PFHQIV/x44d8fDwMB+pX2n37t30798fX19fvL29ueWWW9iyZUuJ7Q4cOECvXr3w8PAgPDyc119/nYKCghLbldVmHBkZyejRo6/6fjZu3MjQoUOpU6cObm5uREREMGnSJDIzM83bjB49mpkzZ5r3VXS72v7L8x6Lmrk2bdrE5MmTCQ4OxsvLizvvvJPz589fte6rOX78OHfccQdeXl7UrFmTSZMmsWLFihLt9UX/ljt37iQqKgpPT09eeOEFAJYsWcKAAQMICwvDzc2NBg0a8J///If8/Hzz86dOnYqLi0uptY4fP54aNWqQlZV11VoPHTrEPffcQ3BwsPkz8+KLLxbbxtKflyvbrIvOZfzwww+88cYbhIeH4+7uzi233MKRI0dKPH/mzJnUr18fDw8POnTowMaNG22yHVyOrMuwdOlSIiMj6datW6mPR0VFERkZydKlS/nkk0+u+lpHjx4FMIdr3bp1Wb16NWvXrjUH+bVs2rSJ2267jXr16rFmzRqCgoLK/V4uXLjA7bffzrBhwxg6dCiffvopw4YNY/78+UycOJFHHnmEESNG8O6773L33Xdz8uRJfHx8APUfqlu3bvj6+jJlyhRcXFyYNWsWPXr0MAc9QFxcHD179iQvL4/nnnsOLy8vPv/8czw8PMpdZ3ksXLiQjIwMHn30UQIDA9m2bRsfffQRp06dYuHChQA8/PDDnDlzhlWrVvHNN99c8zXL+x6LPPnkk/j7+zN16lRiY2OZMWMGTzzxBN9//32F3096ejq9evXi7NmzTJgwgdDQUBYsWMC6detK3T4xMZH+/fszbNgwRo4cSUhICKD+kHh7ezN58mS8vb1Zu3YtL7/8MqmpqeYDivvvv5/XXnuN77//nieeeML8mjk5Ofz444/cddddV/3WsXfvXrp164aLiwvjx48nMjKSo0ePsnTpUt54440K/S4t8Xl5++23MZlMPPPMM6SkpPDOO+9w3333sXXrVvM2n376KU888QTdunVj0qRJxMbGMnjwYPz9/QkPDy/3vqyCLkpITk7WAX3QoEFX3e6OO+7QAT01NVXXdV2fM2eODuirV6/Wz58/r588eVL/7rvv9MDAQN3Dw0M/deqUruu6vn//ft3Dw0MH9DZt2ugTJkzQFy9erKenp5fYR/fu3fWAgADdx8dHb9GihX7u3LkKvZfu3bvrgL5gwQLzukOHDumAbjKZ9C1btpjXr1ixQgf0OXPmmNcNHjxYd3V11Y8ePWped+bMGd3Hx0ePiooyr5s4caIO6Fu3bjWvO3funO7n56cDekxMjHk9oE+dOrVErXXr1tUfeOAB88/r1q3TAX3dunXmdRkZGSWe99Zbb+mapunHjx83r3v88cf1sj7eV+6/vO+x6N+3d+/eekFBgXn9pEmTdCcnJz05ObnU/V3Ne++9pwP64sWLzesyMzP1pk2blnjvRf+Wn332WYnXKe338vDDD+uenp56VlaWeV3nzp31jh07Fttu0aJFJfZVmqioKN3Hx6fY71nX9WK/i6r4vHTv3l3v3r27+eeiz0WzZs307Oxs8/oPPvhAB/R9+/bpuq7r2dnZemBgoN6+fXs9NzfXvN3cuXN1oNhr2gJpBinFxYsXAcxHl2Uperxo+yK9e/cmODiYiIgIhg0bhre3Nz///DO1a9cGoEWLFkRHRzNy5EhiY2P54IMPGDx4MCEhIXzxxRcl9pOens7FixcJCQnB19e3wu/H29ubYcOGmX9u0qQJNWrUoFmzZsWOGouWjx07BkB+fj4rV65k8ODB1K9f37xdrVq1GDFiBH/88QepqamAOqHXqVMnOnToYN4uODiY++67r8L1Xs3lR17p6ekkJCTQpUsXdF1n9+7dFX69irzHIuPHjy/WrNKtWzfy8/M5fvx4hfe/fPlyateuzR133GFe5+7uzrhx40rd3s3NjTFjxpRYf/nv5eLFiyQkJNCtWzcyMjI4dOiQ+bFRo0axdetW87c9gPnz5xMREUH37t3LrPP8+fNs2LCBBx98kDp16hR7rOh3Ud2flzFjxhRrzy76Flz0+d2xYweJiYmMGzeu2Anl++67D39//3Lvx1pIWJeirBC+0sWLF9E0rUSTxMyZM1m1ahXr1q3j4MGDHDt2jH79+hXbpnHjxnzzzTckJCSwd+9e3nzzTZydnRk/fnyJduOGDRsybdo01q5dy/Dhw4u1Q5ZHeHh4sXAB8PPzIyIiosQ6UM0moP6DZmRk0KRJkxKv2axZMwoKCjh58iSg2l0bNWpUYrvSnns9Tpw4wejRowkICMDb25vg4GBzyKSkpFT49SryHotcGVZF//GLfm8Vcfz4cRo0aFDi36dhw4albl+7du1ST7gdOHCAO++8Ez8/P3x9fQkODmbkyJFA8d/Lvffei5ubG/Pnzzc/9uuvv3LfffeVqOFyRQFYWjfSItX9ebnWv0PRH88rf5fOzs5ERkaWez/WQtqsS+Hn50dYWBh79+696nZ79+4lPDy8xH+eDh06mHuDXIuTkxOtWrWiVatWdO7cmZ49ezJ//nx69+5dbLspU6aQmJjIO++8w7hx45g9e/ZV/3NduY+KrNcNmuntWn+E8vPz6dOnD0lJSTz77LM0bdoULy8vTp8+zejRo0s9OVUVjPy9ldamm5ycTPfu3fH19eW1114z993ftWsXzz77bLHfi7+/P7fffjvz58/n5Zdf5scffyQ7O9sc7LbE2j6/VU3CugwDBw5k1qxZ/PHHH3Tt2rXE4xs3biQ2NpbJkydbbJ9FAX/27NlSH582bRpJSUl8+eWX+Pv7895771ls36UJDg7G09OTv//+u8Rjhw4dwmQymY/O69aty+HDh0tsV9pz/f39SU5OLrYuJyenzPddZN++ffzzzz98/fXXjBo1yrx+1apVJbYt7x+yirzHqlC3bl0OHjyIruvFai6tV0NZ1q9fT2JiIosWLSIqKsq8vqj30ZVGjRrFoEGD2L59O/Pnz+fGG2+kRYsWV91HUbPG/v37y9ymqj4vlVXU2+rIkSP07NnTvD4vL4/Y2FhuuOEGi+2rOkgzSBmeeeYZPD09efjhh0lMTCz2WFJSEo888gi+vr7FzqqX18aNG8nNzS2x/rfffgOu/lVw1qxZ3H333UyfPp3XX3+9wvuuCCcnJ/r27cuSJUuKXf4bHx/PggUL6Nq1q7kN/bbbbmPLli1s27bNvN358+fNX7cv16BBAzZs2FBs3eeff37NI+uiI6nLj5x0XeeDDz4osa2XlxdAiT8K1/Meq0K/fv04ffo0v/zyi3ldVlZWqecuylLa7yUnJ6fMXkr9+/cnKCiIadOm8fvvv5frqDo4OJioqCi++uorTpw4Ueyxov1W1eelstq1a0dgYCBffPEFeXl55vXz58+vVJOV0eTIugwNGzZk3rx5DB8+nFatWpW4gvHChQt89913JS6IKY9p06axc+dOhgwZYv7rvmvXLubNm0dAQAATJ04s87kmk4n58+eTkpLCSy+9REBAAI899lhl3+Y1vf7666xatYquXbvy2GOP4ezszKxZs8jOzuadd94xbzdlyhS++eYbbr31ViZMmGDuilW3bt0SzUkPPfQQjzzyCHfddRd9+vRhz549rFix4prdEZs2bUqDBg145plnOH36NL6+vvz000+l/sdr27YtAE899RT9+vXDycmp2EnWyrzHipg7dy5jxoxhzpw5V+07/vDDD/Pxxx8zfPhwJkyYQK1atZg/f765C115viF06dIFf39/HnjgAZ566ik0TeObb74psznAxcWFYcOG8fHHH+Pk5MTw4cPL9Z4+/PBDunbtyk033cT48ePN/x+WLVtGdHQ0UDWfl8pydXXllVde4cknn6RXr17cc889xMbGMnfu3FLPE1g9o7qh2Ip9+/bpI0aM0ENDQ3WTyaQDuru7u37gwIES2xZ17dq+fftVX3PTpk36448/rrds2VL38/PTXVxc9Dp16uijR48u1uVJ11W3pRYtWpR4jbS0NL1Tp066yWTS58+fX+a+ynp+3bp19QEDBpRYD+iPP/54sXW7du3S+/Xrp3t7e+uenp56z5499T///LPEc/fu3at3795dd3d312vXrq3/5z//0WfPnl2iK1Z+fr7+7LPP6kFBQbqnp6fer18//ciRI+Xqunfw4EG9d+/eure3tx4UFKSPGzdO37NnT4kuh3l5efqTTz6pBwcH65qmFevGRyldB8vzHsv69y2tzo8++kgH9OXLl5f4PV3p2LFj+oABA3QPDw89ODhYf/rpp/WffvpJB4p1rSzr31LX1WeqU6dOuoeHhx4WFqZPmTLF3BWztC5527Zt0wG9b9++16zvcvv379fvvPNOvUaNGrq7u7vepEkT/aWXXiq2jaU/L2V13Vu4cGGx14uJiSnxOdB1Xf/www/1unXr6m5ubnqHDh30TZs26W3bttVvvfXWCr13o0lYV9DXX3+ta5qm33///UaXIqzY0KFD9fbt21f6+e+//74OmPvmW1p0dLQO6PPmzauS17dm+fn5ekBAgP7QQw8ZXUqFSDNIBY0aNYqzZ8/y3HPPER4ezptvvml0ScLK6LrO+vXr+fbbb8u1fWZmZrFeHllZWcyaNYtGjRqZ++Zb2hdffIG3tzdDhgypkte3FllZWbi5uRVr8pg3bx5JSUk2d7m5put22s9FCBvRv39/6tSpQ5s2bUhJSeHbb7/lwIEDzJ8/nxEjRlh0X0uXLuXgwYO89NJLPPHEE0yfPt2ir29t1q9fz6RJkxg6dCiBgYHs2rWL2bNn06xZM3bu3GlTg0RJWAthsBkzZvDll18SGxtLfn4+zZs3Z8qUKdx7770W31dkZCTx8fH069ePb7755ppX6dq62NhYnnrqKbZt20ZSUhIBAQHcdtttvP3221cdNM0aSVgLIYQNkH7WQghhAySshRDCBlh1b5CCggLOnDmDj4+P7XVgF0KIUui6zsWLFwkLC8NkKv/xslWH9ZkzZ6p0XAYhhDDKyZMnKzQBglWHddGZ6pMnT1ZofIbc3FxWrlxJ3759cXFxqaryhB3JyMhg3bp19OzZ0+7nNBSWUdmcSU1NJSIiosI9caw6rIuaPnx9fSsc1p6envj6+kpYi3JxdnY2f2YkrEV5XG/OVLRpV04wCiGEDZCwFqIUM2fOJDIyEnd3dzp27FhsKM/PP/+cHj164Ovri6Zp1xyGVQhLkLAW4grff/89kydPZurUqezatYvWrVvTr18/zp07B6j27VtvvZUXXnjB4EqFI5GwFuIK06dPZ9y4cYwZM4bmzZvz2Wef4enpyVdffQXAxIkTee655+jUqZPBlQpHImEtxGVycnLYuXNnsTkwTSYTvXv3ZvPmzQZWJhydhLUQl0lMTCQ/P5+QkJBi60NCQoiLizOoKiGsvOueENUhPx82bDCxYUNt0tLkSllhnar0yHrDhg0MHDiQsLAwNE1j8eLFVbk7ISps0SKIjIT+/d2ZPr0dI0eGA04sXhxfbLv4+HhCQ0MNqVEIqOKwTk9Pp3Xr1sycObMqdyNEpSxaBHffDadOXb7WFWjLO++sYdEitaagoIA1a9bQuXNnA6oUQqnSZpD+/fvTv3//qtyFEJWSnw8TJkDpo7lPBh5g3Lh2NG7cgY8+mkF6ejpjxowBIC4ujri4OI4cOQLAvn378PHxoU6dOgQEBFTbexCOxararLOzs8nOzjb/nJqaCqjLOnNzc8v9OkXbVuQ5wo7kXoTMU2iZpyE7AfLS0fLS4LLb79siOHXqxTJe4F7gPElJL3NTm9Pc2MSfZe/1JijuU/IvBPPJp+v4z4c/mbeOiooC4Msvv2TUqFFV//6EVahszlQ2l6ptphhN0/j5558ZPHhwmdu88sorvPrqqyXWL1iwQMZrEGYuehq+BcfxKjiLh56Au56Ih56IR0ECHnoCLmRc8zX+9+cwRsz83zW3W/D4cIZ3+e6a2+XgRaYWRLqpFummWqRpYaSbQknXwsjSAkCG+BWFMjIyGDFiBCkpKRUa88iqjqyff/55Jk+ebP65aHSqvn37Vnggp1WrVtGnTx8ZyMmW5WfBxUNoKfsLbwfUfebpaz5Vd/EDj9robjXBxRucvdGdvcHZB5y9qJndrFwl1Gw7kPyWLSDvIlp2ImSfh5xEtOwEyE5Uy+i4ko6rno5f/nHIv6IWJw/wboDu3RC9xg3o/u3QA9qBW1BlfivCSlQ2Z4paDCrKqsLazc0NNze3EutdXFwqFbqVfZ4wgK5D2jE4twHOb4SELXDxH9DzS9/eqy74NgXPOuAZDp4Rhffqprmo4SfLOp7t0QrCX4bTp0tvt9Y0CA+HHqNG4OR0lboL8iHnggrx9Fi4eBguHrl0nx6Dlp8JhX9wOL34svcQCYHtIbADBLSHgJvAxb4nsLVHFc2ZymaSVYW1cCB6AaQcgHMbLwV05pmS27n6Q41W4NdK3ddoBTVagkv5v2mVxskJPvhA9QbRtOKBXdRiMWMGVw9qAJMTuAepm18z4IoT6gW5kH5chXfq35C0E5K2q+X0WHU7sbBoz+DXHEJugVp9oWZ39a1ACKo4rNPS0sxnzAFiYmKIjo4mICCAOnXqVOWuhTXKjIfTS+HMryqgcy4Uf9zkqo40g6MguCv4twGPWlXW3jtkCPz4o+oVcnn3vfBwFdRDhlhgJyYX8GmobmGXBXlOigruxG0qvBO3Q8ZJ9Qcs5QD886F6bnBXCO0LtfqBf2vQ5KJjR1WlYb1jxw569uxp/rmoPfqBBx5g7ty5VblrYS1SDsHpJXBqiWra4LJDWGcvCOoCwd2gZpRqDnD2qNbyhgyBQYNg1aosVq3aT58+LenTx/3aR9TXy9UPQnupW5HMODi/CeJWwdkV6qg7fp267Xke3IIhtA+E3Qbhd0iTiYOp0rDu0aMH1dTZRFiLgnxI3KLC+dQS1e58uYB2ED5IHS0G3KiOHg3m5ARRUQVkZ58mKqp51Qd1WTxCoc5d6qbrqs07biWcXQnxa1W7+PEF6ubkDmEDoO4wdV/Nf+RE9ZM2a2EZqYchZi7EzIOMy9oUTC4Q0ksFdO07wLO2YSXaFE0D30bq1vhx1fadsFkdcZ/8SbV5n/xJ3Zy91e+37jD1R9DJ1ejqRRWQsBaVl5umTo4d+wrO/3FpvYufOtoLHwRht173yUCB+qNXM0rdbngdkvfA8e/ULf04xM5XN1d/iBgC9cdCUCfp321HJKxFxei66rlxbI4K6rx0tV4zQWg/aDBGHUE7leyCKSxE09TJV/820PotSNyqQvvED5B5Fo7OVjf/G9VRed3h4CwXldk6CWtRPnkZcGwu/D1DdUMr4tMI6o+BeqOkicMImqaOoIM6wY3vFf4hnavC+8Ju2PoQ7HpG/Rs1elQ1qwibJGEtri4zHg7PhMOfqCv2QLWR1r1XBUBQF/mqbS1MThDSQ91uek99+zn8qbrY6O/31S20LzR+DMJuV9sLmyFhLUqXcggOTVcnDAsKB9fyrg9NJ0O9B+RiDWvnFgjNnlH/XmdXwD8z4cxvqndJ3ErwbggtX4TI+6yiR464NglrUdy5DfDXf9XFK0UCO0Kzf0H4YDkaszWaSV2ME9Yf0mLg8Gdw9EtIOwJbxsC+16DFC6oZS3qRWDW5HEooidthTW9Y3b0wqDXVm6P3Rui7WfX9laC2bd714MZpMOg4tHkH3GtCegxsGwdLG6kgz8++9usIQ0hYO7rUv2HjUFjRAeLXqK/EDcfD7X9B1GKo2VXapO2Nizc0/xfcEQM3vQ/uoZBxArY/Cr80gL8/ViMeCqsiYe2oMk7B1nGwrAWc/BHQVFv07f9Ah1ng28ToCkVVc/aEphPhjmPQ9iPwqA2Zp2Hnk/BrUzj+Q1lT6QgDSFg7muwk2D1Ffe09+qUagrT2HXDbXug8F7wjja5QVDdnD2jyBNxxFNp/qoaZTT8Om+6F1VFqwClhOAlrR1GQr7px/dIA/npXfc0N7gZ9NkH3JWrYUeHYnNyg0SNw+9/Q6lVw8lBXpi5vD1seVANNCcNIWDuCpF2wsjNsfwxyk6HGDdB9GfT+HYK7GF2dsDbOntDqZRj4j+rah676bC9tBAfelvZsg0hY27PcVNg5EVa0V2Mmu/hCu4/h1l1Q+zY5cSiuzjMcunyregMFdlCTDe95Hn5tDmeWG12dw5Gwtke6Did+hF+bwd8fqFlZ6g6D2w+psSKkC56oiKBOKrA7zwOPMNXdb31/1U/7ygkkRJWRsLY3acdg/W3wx1A1TZZ3A+i5Am7+n5p1RYjK0ExQ737Vnt1kEqCpMUiWtYBTS6/1bGEBEtb2Qtfh6Ffw2w1wdrmaIqvlVBiwX83nJ4QluHhD2+nQZyP4NFaj/G24A/68X/U0ElVGwtoeZCfCH3fD1rFqyNKaUXDbPrjhFTWjiBCWFnwz9I9W449oJoj9FpY1h5M/G12Z3ZKwtnVxq9XR9MlFoDlDm7eh11rwbWx0ZcLeOXvAje9Cnz/BtxlkxcPGIbDpPnVyW1iUhLWtys+CnZNhbR/VNu3bBPptgebPyglEUb2COkL/XdD8edCc1ByRy9vBhT1GV2ZXJKxtUfIBWNFRjU8M0PAR1R0voK2xdQnH5eQObd5UA395RqgJKlZ2giNfyCXrFiJhbWti5sOKdpC8F9yCIeoX6PCpTNskrENwZ+i/G8JuU9/+to2HzaPUfJ3iukhY24qCPDU90+aR6j9BrX5qPI/wgUZXJkRxboHQfamaH1JzUicfV3RQ3whFpUlY24LsJNV3+tB76ucWL6jLxT1Cja1LiLJoJmjxHNyyVvXvT/1LBfaxeUZXZrMkrK1d8j51uXjcKnDyhK4/QOs35CSisA01o1QXv9DekJ8BWx6A6OfUVbWiQiSsrdmJn9QATGnHwKte4YwtQ42uSoiKca8JPZZDi3+rnw9Og03DIC/T2LpsjIS1NdJ12PuyutAlLx1CboFbt4P/DUZXJkTlmJyg9X+g09dqNqITC2HtLZB13ujKbIaEtbUpyFNXIu7/j/q5ySTouVydtBHC1tUfBT1XgksNSNisuvelHDK6KpsgYW1N8jLV0fSxOeoETccv1TgMJpmEXtiRkB6qSc+7vmriW9kZ4tcbXZXVk7C2FjkpsP5WOLUETG7QbRE0GGt0VUJUDb+m0HcLBHVWE2Ks6wsx3xpdlVWTsLYGmfGwpgec26AmCOi5AsIHGV2VEFXLPRh6rVEnzQty1cUzR74wuiqrJWFttLRjsOpmuBCtzprfsh5CuhtclBDVxNkDbv4OGj8J6OqKx38+MboqqySNoUZK3gdr+0JWnOqa12sl+DQ0uiohqpdmgrYfqF4ih6bDjsehIAeaTjS6MqsiR9ZGSfkL1tyigrpGK+i7SYJaOC5Ngxv/C82fUz/vmgQH3zW2JisjYW2Ei0dhbW/IPg/+N6lZxmXKLeHoNA1avwktX1Y/R0+BA28aW5MVkbCubukn1MUAmWfAr4U6mejqb3RVQlgHTYMbXoUbCq8z2PMi7H3FyIqshoR1dco8q5o+0o+DTyPotRrcg4yuSgjr0/LfatYjgP2vwl//NbYeKyBhXV2yElTTR9oR8IpUXZZk1Dwhytb8WWgzTS3v/pfD98OWsK4OOcmq03/KQfCoDbesAa8Io6sSwvo1nwJNJ6vlLWPgzApj6zGQhHVVy8+G3wfChd2qH3Wv1eoyWyFE+dz4LtQdAXoe/HEXJG43uiJDSFhXJV2HrQ/B+T/AxQ96rlKX2Qohyk8zQac5akzsvHRYPwBSDxtdVbWTsK5KB95UUxppTtDtJxniVIjKcnJV4+X436S6vK7rB5lxRldVrSSsq8rxH2Bv4WDr7T+B0FuMrUcIW+fiAz1+U82I6TGwvr9DTcQrYV0VErap6YtAjUfdcLyx9QhhLzxC1LUJ7jXVeDpbx6rmRgcgYW1p6Sdgwx1qBvKwAerkiBDCcnwaQtefQHOGEz9cmkjazklYW1LuRdXzIyseatwAN/9PJrYVoirU7AptZ6jl6Gchbo2h5VQHCWtLKer5kbwX3EOg+1LVxiaEqBqNHoN6D6iZ0jfdq64MtmMS1pZy5HP1lUxzhm4/g1cdoysSwr5pGrT/tLCHSCJsGGLXM6ZLWFvChb2wc4JabvM2BHc2th4hHIWzB0QtUhNKX9gFOx6z2xOOEtbXKzcNNt0DBdnqhGLTSUZXJIRj8aqrZpvRTHBsLhz5zOiKqoSE9fXa8Tik/q3G/Og0V31ghBDVK7Q3tC4cpW/XZDW5h52RZLkex76GmHkqoG/+nwx3KoSRmj0DoX1Vt9nN96tJeO2IhHVlpRyC7Y+p5VavQs1uxtYjhKPTNOj0lZrMI2kn7H/d6IosSsK6MgpyYdMwyM+AkFug+fNGVySEAPCsrXqIABx4AxK2GluPBUlYV8bBdyB5jzoD3eUbufBFCGtS916oOxz0fNUckpdudEUWIWFdUSmHYP9ravmmGTLRrRDWqP1MddL/4mHYPcXoaixCwroi9ALY9hAU5ECt/hB5n9EVCSFK4+oPneeq5cOf2MUMMxLWFXH4Uzi/CZy9ocNn6oSGEMI6hfaGxk+q5W3jbL45RMK6vNKPQ/RzarnN23I5uRC2oM3baoLqjJM23ztEwro8dB22PQJ5aRB8MzR61OiKhBDl4ewJbT9Qy4feU+ecbJSEdXnEzoezy8HkCh2+lKsUhbAltQeqoSAKcmHnkzY7doikzrXkpsHuf6nlli/LhLdC2BpNg3YfgskN4lbDiYVGV1QpEtbX8tc7kBUH3g2g2b+MrkYIURne9aFF4cVruyapiUJsjIT11WScgr/+q5bbTFMzLAshbFOzKSq0M89culbChkhYX82eFyE/E4K7QsQQo6sRQlwPZw9o+6FaPjQDUg4aWk5FSViXJWmnGlEP4Kbp0qdaCHtQewDUvgP0PNjzb6OrqRAJ69LoOux6Wi1H3geB7Y2tRwhhOW3eAjQ49TMk7jC6mnKTsC7NqSVw7ndwcofWbxpdjRDCkvyaQ+RItbzXdo6uJayvVJAH0YUDvzSdLFcqCmGPWk1Vk1ufXQHnNhpdTblIWF/p+P/USF1uQdD8OaOrEUJUBZ8G0OBBtbznRZu4UEbC+nJ6ARx4Sy03nQwuPsbWI4SoOi1fUhfKnN8IcauMruaaJKwvd2oxpP4FLn7Q6DGjqxFCVCXP8Evj/NjA0bWEdRFdh/1vqOXGT4Crn7H1CCGqXovnwckTknbA6V+MruaqJKyLnF0JF3apf7gmE42uRghRHdxrQpPCMa//etfYWq5BwrrIgcKj6objwT3I2FqEENWn8VNgclETiyRuN7qaMklYg+q6c36j+gdr9ozR1QghqpNnGNS5Vy0fmmFoKVcjYQ2XeoDUG62mshdCOJamk9T9iR8g47SxtZRBwvriETj7f4AGze1jFmQhRAUF3AQ1o9SYIf98bHQ1pZKwPvK5uq/VD3waGluLEMI4TQqPro/MgrwMY2sphWOHdX42HJujlhs9YmwtQghj1R6oxrvOuXBpxE0r4thhffJnyE4Aj9pqjjYhhOMyOameIQB/z1BXNFsRxw7rI7PUfYOxYHI2thYhhPEaPAjOPpD6t+rKZ0UcN6xTDsG59Wqm8gYPGV2NEMIauPhAnaFq2cqaQhw3rM0nFm8DrwhjaxFCWI9696v7Ez9AXqaxtVzGMcM6PwtivlbLcmJRCHG5mlHgWQdyU61qvBDHDOvTyyAnCTwjoNatRlcjhLAmmunS0XXMN8bWchnHDOsTC9V93XvVGWAhhLhcUVifXQ6Z8cbWUsjxwjovE878qpYjhhpbixDCOvk2gcAOoOer2aOsgOOF9dnlkJeu2qRk1nIhRFnqjVL3VtIrxPHCuqgJpM7doGnG1iKEsF51h6mROC/sVv2uDeZYYZ2XCaeXquU60gQihLgKt0Co2UMtn/7V0FLA0cI6biXkpaleIIEdja5GCGHtat+u7iWsq1lRE0jEXdIEIoS4tqIxg87/ATnJhpbiOGGdnyNNIEKIivFpAL5N1TjXZ1caWorjhHXiNnVFklsQBHUyuhohhK2wkqYQxwnr+DXqPqSXukJJCCHKo6gp5Oz/QUG+YWU4TmrFXRbWQghRXsE3g4ufGvs+cZthZThGWOelQ+IWtRx6i7G1CCFsi8nl0hhCZ4xrCnGMsD73BxTkqqsWvRsYXY0QwtaEFYZ1/HrDSnCMsC5qrw69RbrsCSEqLriruk/aoeZuNYBjhLW5vVqaQIQQleDdANyCoSAHknYZUoL9h3V2krq2HyCkp7G1CCFsk6ZBcBe1nGDM3Iz2H9bnNwG66tjuGWZ0NUIIWxVUGNbn/zRk9/Yf1hcKv7IEdjC2DiGEbQu+Wd0n/Am6Xu27t/+wLmpf8r/R2DqEELYtoK3qxpcVD+kx1b57+w/rovbqgJuMrUMIYduc3MG/rVo2oCnEvsM6OwEyTqpl/zaGliKEsAPmk4wS1halJUerBe+G4OJraC1CCDvgX/gNPXl/te/avsNamkCEEJbk10zdp/5V7buWsBZCiPLybaLusxPUrRrZd1gXNYNITxAhhCU4e4FXXQC01EPVumu7DWuTngtpR9UPNW4wthghhP3wLWwKuShhbREe+nk0dHDyBPcQo8sRQtgLv+YAaNXcbm23Ye2pn1ML3pEy0p4QwnIKj6ylGcRCPAvi1YJXPWMLEULYFz8Ja4u6dGQtYS2EsKCiI+vMkzjp1Te2tf2GtfnIOtLQOoQQdsbVH5w8AHDTL1Tbbu02rL30wrCWI2shhCVpGnjUAsBdwvr6eRYUNoNIm7UQwtLcQwE5sr5+eem4kaKW5chaCGFpcmRtIdnqqFp38gDXGsbWIoSwPxLWFpKTrO5d/A0tQwhhp6QZxDK03GS14OpnaB1CCDslR9YWUnhkrbvUYMOGDQwcOJCwsDA0TWPx4sXFNl20aBF9+/YlMDAQTdOIjo6u9nKFEDbGfGSdbF41c+ZMIiMjcXd3p2PHjmzbts38WFZWFo8//jiBgYGEhamJu8+dO1ehXdpnWOcWnlx09Sc9PZ3WrVszc+bMUjdNT0+na9euTJs2rRoLFELYNA813pCbrrLm+++/Z/LkyUydOpVdu3bRunVr+vXrZw7kSZMmsXTpUhYuXMiyZcsAGDlyZIV26WzB8q2GllP41cTFj/49+9O/f/8yt73//vsBiI2NrYbKhBB2wckTAJOeA8D06dMZN24cY8aMAeCzzz5j2bJlfPXVVzz66KPMnj2bBQsW0KtXL1JTUwHYunUrW7ZsoVOnTuXapZ0eWScDoLvKCUYhRBVwcld35JKTk8POnTvp3bu3+WGTyUTv3r3ZvHkzO3fuJDc3t9jjABEREWzevLncu7TTsC5sBnGRE4xCiCpgDuscEs6fJz8/n5CQ4kMxh4SEEBcXR1xcHK6urtSoUaPY48HBwcTFxZV7l3bXDJKfD79vrUX838Oomd2SHjeAk5PRVQkh7Ek+7mw82J2zybXQtIJq2We1HFnfc889ODs7o2ka3t7ezJkzp0r2s2gRREbCLU/9mxEz/0fvB0cQGanWCyGEJSxaBJGNa9DzjfWMmPk/ho8IB5xYvDi+2Hbx8fGEhoYSGhpKTk4OycnJxR4/f/48oaGh5d5vlYf1hAkTWLhwIaNGjWLJkiVEREQwduxYDhw4YNH9LFoEd98Np04VX3/6tFovgS2EuF6l54wr0JZ33lljzpmCggLWrFlD586dadu2LS4uLqxZs6bYa508eZLOnTuXe99V3gwye/ZsWrVqxVdffQXAbbfdhpubG08//TTLly+3yD7y82HCBND1ko/pehpwhMceUz/HxMQQHR1NQEAAderUISkpiRMnTnDmzBkA/v77bwDzX0QhhIArc+bK2acmAw8wblw7GjfuwEcfzSA9PZ0xY8bg5+fH2LFjmTx5MgEBAZhM6hi5Q4cO5e4JAlUc1mlpaaSnpzNgwIBLO3R2JjIykj179pTYPjU11dytBeDixYsAZGRk4OxcdqkbNpg4dcq9jEd3AD2JL/yGMnnyZADuu+8+Pv/8cxYuXMgjjzxi3nrYsGEAvPDCC7z44ovleZvCDmRlZRW7F+JKV8+Ze4HzJCW9zI03xtGmzQ0sXrwYHx8fMjIyeOONNygoKOCuu+4yf8a+/fbbCu1f0/XSjkctY9euXbRt25ZZs2Yxfvx48/oOHTpw8OBB0tLSim3fo0cPfv/99xKvs2DBAjw9Pcvcz4YNtZk+vd0165k8eQdRUacr8A6EEEKxVM5kZGQwYsQIUlJS8PX1Lff+rao3yC+//FLiyLp58+b07Nnzqm/Kzc3E9OnXfv0+fVoSFdXcEqUKO5OVlcXGjRvp1q0b7u5lHT0JR2apnLk84yqiSsO6cePGgGonvlxiYiI+Pj4ltvf19S0WykVvytPT86pH1n36QHi4OplY2vcETVOP9+njLt34xFW5u7tf9bMmHJelciYvL69S+6/S3iDe3t54eXmZr4UHVWhsbCytW7e22H6cnOCDD9SydkW7f9HPM2ZIf2shROUVz5niaV0dOVPlXffGjh3Lvn37GDduHL/++iutWrVC13X++9//WnQ/Q4bAjz9C7drF14eHq/VDhlh0d0IIB2TOmbDiYV0dOVOlJxiLDB06lJ9//pn8/Hy8vLz44IMPGDt27DWfl5qaip+fX4Ua4vPz4ffPphH/VzQ1b+xPj9Gj5IhaXFNGRgarVq2iT58+0gwirik/PYGNb93N2eRaBA/6mp69XMudM5XJNaimE4wLFy6sjt0A6itI947xOPl/R36TMAlqIYTFOWlZ9Gj+O/k4U9BjXrXkjH0O5FQ4gJNWNL2XEEJYUl4mAAW4Vtsu7TOsi4ZGLZreSwghLKlAXdiSj0u17dIuw1ovGho1J8XYQoQQ9qkwW/I0j2rbpV2GNa411H1u9U1mKYRwIFlnAcjWqm+CE/sMaxf1C9TkyFoIURUy1aQBWRLW10d3LWwGkSNrIURVyJQja8soPLImJxkK8g0tRQhhh7KKjqxrVNsu7TOs3WtSgDMaBZApo+wJISzMfGQdUG27tM+w1pzI0ILVclrM1bcVQoiKKgxrObK2gAytplpIl7AWQlhYlpxgtJgMU+G08HJkLYSwpII8yDoHQLZJmkGum/nIWsJaCGFJ6bGAjm5yJ5uS4/JXFfsN66Ija2kGEUJYUspf6t6nMWjVN1Kc/Ya1Js0gQogqkKrCWvdtVq27tduwTjcVNoNknoH8bGOLEULYj5SDAOi+Tat1t3Yb1jn4oTt7AzpcPGJ0OUIIe2E+spawtgxNQ/e7QS1f2G1sLUII+6Dr5jZr3UfC2mJ0/zZqQcJaCGEJmWcg76I6sejTqFp3bd9hXeNGtZC0y9hChBD2obC9Gu8GYKq+WWLA3sP68iPrqp8XWAhh74rC2q96e4KAnYc1vs3VX7/cFOlvLYS4folb1L1/22rftX2HtckFarRSy9IUIoS4Xuf/VPfBXap91/Yd1gD+0m4thLCAjFOQcQI0EwR2qPbd239YB9yk7i9IWAshrkPCZnVfozW4VN+YIEUcIKzbq/uEzWq0LCGEqIzzm9R9UPU3gYAjhLX/jeBSA3JTpSlECFF5BrZXgyOEtckJQnqo5fg1hpYihLBReRmXLq6TI+sqFNJL3cdJWAshKiFpB+h54FELvOoaUoJjhHXoLeo+YRPkZxlbixDC9sSvU/dBN4OmGVKCY4S1bzP1FzE/61K7kxBClNfpZeo+7FbDSnCMsNa0S00h8WuNrUUIYVsy4yFpu1oOu82wMhwjrAFCCptCpN1aCFERZ35T9wFt1Td0gzhOWIcWHlknbYecC8bWIoSwHWd+VfdhtxtahuOEtVdd8GsJej6cWmJ0NUIIW5CfA2dXquXaEtbVp85QdX/iR2PrEELYhvMbIC8N3EMuDV1hEMcM67iVkJNsaClCCBtwuqgJZIAawMlAjhXWfs3ArzkU5MKpX4yuRghhzXT9Ulgb3AQCjhbWABGFR9cnpSlECHEVidsg7Sg4eUBoH6OrccCwLmoKObsCclKMrUUIYb1ivlH3EUPAxdvYWnDEsPZrDr5NoSAHTi81uhohhDXKz4Hj/1PL9UYZW0shxwtrTbusV8hCY2sRQlinM79BTpK6CKbogjqDOV5YA9S5V92f+Q0y44ytRQhhfWLmqfvI+9Qwy1bAMcO6RgsI7KSGPDw2x+hqhBDWJDvp0lWLVtIEAo4a1gCNHlb3Rz4HvcDYWoQQ1uPE96p7r38bqNHK6GrMHDes69wDLn6QHnvpclIhhDhW2ARiRUfV4Mhh7ewJ9R5Qy0dmGVuLEMI6XIiGxC2gOUHd4UZXU4zjhjVcago5vRQyzhhbixDCeIfeV/d1hoJHqLG1XMGxw9qvOQR3VSPxHZ1tdDVCCCNlnr3Ut7rJJGNrKYVjhzVAw8Kj66NfQEG+sbUIIYxz+FN1YjGoCwR1MLqaEiSs69wNrgGQcRJO/mR0NUIII+RlqrAGaDrR0FLKImHt5A6Nn1TLB95UI20JIRxL7HzITlCTlITfaXQ1pZKwBmjyJDh7QfKeS/OtCSEcg67D3zPUcuMnweRsaDllkbAGcAuERo+q5QNvyNG1EI4kbjWkHABnb2jwkNHVlEnCukjTyWByg4TNcO53o6sRQlQHXVcHaAD1x4Crn7H1XIWEdRGPWtDgQbVc9I8nhLBvcavVwZnJFZr9y+hqrkrC+nLNpqgrl+JWQ8I2o6sRQlQlXYc9L6rlRo+CV4Sx9VyDhPXlvCPVkIgAB980tBQhRBU7/QskbQcnT2j+vNHVXJOE9ZWaPw9ocGoJJGw1uhohRFXQC2DvS2q5yQTwCDG2nnKQsL6SX1OoXzjA067J0jNECHt0/HtI3gcuvtDsGaOrKRcJ69Lc8Lr6apTwp8yCLoS9KciDfVPVctNnwC3A2HrKScK6NJ61L50Z3v0s5GcbW48QwnJi5sHFw+AWZLWXlpdGwroszf+luvOlx8A/HxtdjRDCEnJSLvUAaf4cuPgYW08FSFiXxdkLbijsb73/P5CVYGw9Qojrt+8VyIoDn0bQ+Amjq6kQCeurqTcKarSG3BTY/5rR1QghrseFvfDPR2q57Ufg5GZsPRUkYX01Jie46T21fPhTSDlkbD1CiMrRddjxmJpoJOIuCOtndEUVJmF9LaG3QO2BoOfBtvEyE7oQtijmGzi/SfXyuul9o6upFAnr8mj3kWrDPr9RJtcVwtbkJEN0Ye+uVi9b/WXlZZGwLg+vutD6LbW8+1lIP2lsPUKI8tv7MmSdA9+mVjm3YnlJWJdXo8fU3Gx5F2H7o3JloxC2IHE7HJ6pltt9DE6uxtZzHSSsy8vkBB2/VEMpnll2aRZkIYR1ysuAzfer80x1h6vzTzZMwroi/JpBy8LBX3ZOgKzzxtYjhChb9HOQ+re6uK2d7V/YJmFdUc2mQI1WanLNnRONrkYIUZqzqy71qe44x2bG/7gaCeuKcnKFjrNBM8HxBXBiodEVCSEul3MBtoxRy40es8k+1aWRsK6MwPZqXAGArQ9B2jFj6xFCXLL9ccg8rS4pv/Edo6uxGAnrymr1KgTfDLmp8Me9kJ9jdEVCiNjv1Ml/zQk6f6Ouj7ATEtaVZXKGLv8D1wBI2qFOZgghjJNxSl1SDtDiRQjqaGw9FiZhfT28IqDTHLX89/twaqmx9QjhqPKzYeNdqr06oC20/LfRFVmchPX1Cr8DmkxUy1tGy9WNQhhhx5OQuA1c/aHrD2ByMboii5OwtoQ20yCgHeQkwZ/D1bRBQojqceQLOPoFoEGXBeBd3+iKqoSEtSU4ucLN36nJN89vgt1TjK5ICMeQsBV2FE4i0Pp1CLvV2HqqkIS1pfg0gI5fqeW/34cjnxtbjxD2LjNetVMX5ED4ndD8eaMrqlIS1pZU5y5oVTijzPbHIW6NsfUIYa8KcmHTPao/tW9T6DwXNM3oqqqUhLWltfw3RN6nJivYeJfMLiNEVdj1NJzbAM4+0O1n1QRp5ySsLU3T1Oh8QV3U3I2/3w7ZiUZXJYT9+Ou/l8b96Pw1+DU1tp5qImFdFZzcIepn8IqEtKOwcYhc4SiEJcR8C7sLZ31p8w5E3GlsPdVIwrqquNeE7r+qr2nnNsD2R2TCAiGux9mVlwZoajIJmj1jbD3VTMK6KtVooTroayY4Ngf2PC+BLURlJO5Q31D1PDWRwE3/tfsTileSsK5qYbdC+0/V8sFpsP91Y+sRwtZcPALrb4O8dAjtDZ3mqgMgB+N479gIDcfDTdPV8r6X4a/3jK1HCFuRGQfr+kH2efC/Cbotsul5FK+HhHV1aToJbig8qt79DPzzibH1CGHtss6roE47pi4h7/EbuPgYXZVhJKyrU8sXL11lteNxODbX0HKEsFqZ8bCmJyTvBfdQ6LkCPEKMrspQEtbVrfUb0GSCWt46Vg2WLoS4JOMMrOkBKQfAIwx6rwefhkZXZTgJ6+qmaXDT+6odWy+AzSPh+PdGVyWEdUg/Cau7Q+oh8IyA3r+DbxOjq7IKEtZG0DTVQyTyftDzYdNwacMWIi1WBXXaEXVBWe/f5Yj6MhLWRtFMapaZRo8CumrD3veq9MMWjintmArq9BjwbqCC2rue0VVZFQlrI5mcoN1MaDlV/bzvFdj5lGoeEcJRJO9XQZ1xAnwaq6D2qmN0VVZHwtpomgY3vAJtPwI0+Odj+PM+GUtEOIazK2HVzWqyW99m6mSiZ22jq7JKEtbWoskT0GU+aM5w/DvYcIe6YksIe3XkC3VlYm4q1IyCPn+ARy2jq7JaEtbWJHK4GvzJyRPOroDVPVU3JiHsiV4A0c/BtvHqBHvkSOi5EtwCjK7MqklYW5uwfnDLWnANgKTtsLwtnN9sdFVCWEZeJmwapsbJAWj1CnSeB05uhpZlCySsrVFQR+i3DfxaQlYcrOkOR740uiohrk/WeVh7C5xYCCYXFdKtpjrc6HmVJWFtrXwaQN/NEHGXmm9u2zg1r6OceBS2KHE7rGgPCZvB1R96roJ69xtdlU2RsLZmLt7QdWHhAFAaHP4E1vaGrHNGVyZE+eg6/P2R6vGRflz1oe67GUK6G12ZzZGwtnaapgaAilqiZp05vxGWt1ODsQthzXJS4I971LUDBbkQMQRu3SmXj1eShLWtCB+o2rF9GkPGSVjVRU0cKhfQCGuUtFudHD/5o2qfbvsBdP0RXP2MrsxmSVjbEr+mKrDDB6sjld3/grV91AUFQlgDXYfDs2BlZzVZtFdd6P0HNHlKTiReJwlrW+Pqp2bL6PC56o8dvxZ+u0GdYRfCSNlJ6urb7Y9AQTbUHgi37oKgDkZXZhckrG2RpkHDcdB/NwS0g5wLqm1wyxjIvWh0dcIRnVoCy1rA8f+B5gQ3vqvOs8iFLhYjYW3LfBtD3z+hxQuApmae+b82chGNqD5ZCbBpBGwYrK4J8G0KfTZBs2ek2cPCJKxtnclFzT7T+3fVPph2DFZ3hR0T1JgLQlSVEz/Cb0VH0yZo/pz6thfU0ejK7JKEtb2o2Q367ymc0KAA/vkQfm0Kx3+QMbKFZWWdg41D4Y+hatmvJfTdCm3eAid3o6uzWxLW9sTVD7rMU4PieDeEzLOw6V5Y3x8uHjW6OmHrCvLh6GxY1lx1ydOcoMW/4dYdENjO6OrsnoS1ParVBwbsU4PkmFzVCH6/tYT9r0N+ttHVCVt0bqO6XHzrQ5CdCDVaQ7/t0Po/MghTNZGwtldO7mqQnNv2QWhvyM+CvS/B/7VWA75L04goj7RY1dNodRRc2A0ufnDje6q/f8CNRlfnUCSs7Z1vY9Us0mUBuIdA6t+wrp8aYyRhm9HVCWuVmwZ7/q3Oe5xYqE4gNnwYBh6GZpPBydXoCh2OhLUj0DQ1scHth6DJRNU0Er8WVnaEjXdByiGjKxTWoiAfjn0NvzaGA2+oi1tCesGtu6HDZ+AebHSFDkvC2pG41oC278PAf6DeA4AGJxep7ldbH4L0k0ZXKIxSkAcx36iTh1tGq5PT3vWh28/QazX432B0hQ5PwtoRedWFznPhtr0QPkh19Ts6G5Y2gl3PqEHihWMoyIWjc1Rzx+ZRcPEfNUtRm2kw4CBEDJaLW6yEhLUjq9ESoharK86Cu6mvvIfegyV1YNujkHrY6ApFVcnPURPWLm0MWx9Ugy65BUGbt2FQLDSfIr08rIyz0QUIKxDcRV0BeXY57H0ZknbAkc/gyCw1wl+zZ9Q2wvblpkHMPDj4thpqF9SJ52b/gkaPgLOXsfWJMklYC0XTIKw/1LoVzm1QY2Wf+RVO/axuQZ1VaNceBCYno6sVFZX6N/zzCcTMvTQMgUctaPasGhTM2dPQ8sS1SViL4jRNTbkU0h1SDsKh6erEU8Jm1XPEuwE0fgIi75OeAdauIA9OL4V/ZkL8mkvrvRtC04nQYKxcHm5DJKxF2fyaQ8cv1RyQ/3ys5oBMOwq7JkH0FDVecf0x6mjcJB8lq5EZD0e/UM1YRRNTaCYIux0aP64uktLkdJWtkX8xcW0eodD6dRh8Etp/osbQLshV3f5+HwiLI2D3FEj5y+hKLWLDhg0MHDiQsLAwNE1j8eLFxR7XdZ2XX36ZWrVq4eHhQe/evTl82OCTsblpELsAfr8DlkSoq1UzToFbMDR/Hu44Bt2XQK2+EtQ2Sv7VRPk5e0GjR+HW7arbX5NJKgyy4uCvd1Uf3RWd4fCnqp+ujUpPT6d169bMnDmz1MffeecdPvzwQz777DO2bt2Kl5cX/fr1Iysrq3oLzctUfzD/uAcW1VSztJxeqv6QBnWGzt+qP7Bt3lTdNYVNk++uonJqtIK201VXrzO/wbE5cGYZJG5Rt+2PQWBH1Y87fBD4NrOZ/rr9+/enf//+pT6m6zozZszg3//+N4MGDQJg3rx5hISEsHjxYoYNG1a1xeXnQNxqOP4dnFoMeZfNDOTTCOoOh7r3qiYsYVckrMX1cXJVF05EDFZtpbHfqrEkErdeuu15QZ3UKgruoC4226MkJiaGuLg4evfubV7n5+dHx44d2bx5s+XDWtfVeYKzK9XoifHrige0Zx2oO0zd/NvYzB9EUXES1sJyPEKg2dPqlnlWfSU/tQTi1kDaEXXBzaH31MUXIb2gZpS6+bWwmXbUuLg4AEJCQoqtDwkJMT923XJS1NgtZ1eokE6PKf64ewjUuUcdRQd1tJnfnbg+EtaianjUgobj1S03TQXPqSWq73Z2Apz4Qd0AXP0huKsK7uAoNfSmyaXaSs3Phw0bTGzYUBs3NxN9+oBTdR346zqkH4ek7ZC4Dc7/qb6N6PmXtjG5QNDN6uRgrX6FR9AS0I6mysL6jTfeYNmyZURHR+Pq6kpycnJV7UpYOxdvqHOXuhXkqT7b535XF98k/KlmZz+9VN0AnDwhqJMKJb+Wqn3cr3mVXLixaBFMmACnTrkD7Zg+HcLD4YMPYMiQktuHhoYCEB8fT61atczr4+PjadOmzbV3mHUOErcX3rapkM5OKLmdbxMI7asCumYP9TsUDq3KwjonJ4ehQ4fSuXNnZs+eXVW7EbbG5Kzmi6zZTf1ckAsXolVwn9sA5zeq8I5fq25mGvg0LAzuVmpcE7/m4BkBLj6VKmXRIrj77pLzMJw+rdb/+GPJ59SrV4/Q0FDWrFljDufU1FS2bt3Ko48+qjbKz1ITF188AhcPX3b/z6VLvIv9Tlygxg0Q0B4CO0BoL+m9IUqosrB+9dVXAZg7d25V7ULYA5MLBLZXt2ZPqxEAUw5CwhZI3gcp+9R9dkJh4B1W3dUu5+KrQtszvPBWuOwRrtrRnb0vu3mCZiI/Xx1RlzZhjq6nAUd47DH1c0xMDNG7dxPg60adEHcmjruL1/8zlUY+J6kX4sxLM34hLNCVwX6zYPGzhYFc1kw8Gvg2Ve83oPB9+7eWKwnFNVlVm3V2djbZ2ZfmCExNVWMY5ObmkpubW+7XKdq2Is8RVsSriboVHVzqOmTHo6UcQEvZj5ayH1L2o6UdQctNUWNdpBxQt2vQ0cDZiw2H+nDq1KIyttoB9CQ+Xv00efJkAB7oBnMfgSlNIL0XjJ/yAckZ0LUxLJ8M7hfWX9qPsw94N0T3aYju3QDdu6H62a+l+uNyuQLUNwxhUyqbM5XNJasK67feest8RH65lStX4ulZ8fbKVatWWaIsYVUaFd7uBFdwdsnEXU/EQ0/EoyABdz0BDz3B/LMrF3HSs3AmCw0dDR3y0og7d7XhP3tQdGS84PHhDO/ynfmRPNzIMfky+R4fnrjXl2z8yNF8yNF82KUFk2YKI90USg5+kKtBEuoGQDLwh+V/JcJQFc2ZjIyMSu2nQmH93HPPMW3atKtu89dff9G0adNKFfP888+bj2JAHVlHRETQt29ffH19r/LM4nJzc1m1ahV9+vTBxaX6ehUI65Wn65CfCXlpkHeRYE8NSr9AsZjg3q+Q2/VZ1S7uGgTOnrgALoAMJurYKpszRS0GFVWhsH766acZPXr0VbepX79+pQoBcHNzw82t5BGPi4tLpUK3ss8T9soV8AOg50DV6+P06dLbrTVNPd5zYJPq68YnbFJFc6aymVShsA4ODiY4WIbFFLbPyUl1z7v7bhXMlwd20UWAM2ZUY39rIa6hynrWnzhxgujoaE6cOEF+fj7R0dFER0eTlpZWVbsUokKGDFHd82rXLr4+PFytL62ftRBGqbITjC+//DJff/21+ecbb7wRgHXr1tGjR4+q2q0QFTJkCAwaBKtWZbFq1X769GlJnz7uckQtrE6VHVnPnTsXXddL3CSohbVxcoKoqAKiok4TFVUgQS2skgwwIIQQNkDCWgghbICEtRBC2AAJayGEsAES1kIIYQMkrIUQwgZY1UBOV9ILLyur6LX0ubm5ZGRkkJqaKpebi3LJyMgwf2by8vKMLkfYgMrmTFGe6aWNc3AVVh3WFy+qiUEjIiIMrkQIISzr4sWL+Pn5lXt7Ta9ovFejgoICzpw5g4+PD1oFZm0uGq3v5MmTFRqtTziu06dP07x5cw4ePEjtK68/F6IUlc0ZXde5ePEiYWFhmEzlb4m26iNrk8lEeHh4pZ/v6+srYS3KpeirqY+Pj3xmRIVUJmcqckRdRE4wCiGEDZCwFkIIG2CXYe3m5sbUqVNLnchAiNL4+vrSvXt3aQIR5VbdOWPVJxiFEEIodnlkLYQQ9kbCWgghbICEtRBC2AAJayGEsAEOEdZvvPEGXbp0wdPTkxo1ahhdjrBC99xzD87Ozmiahre3N3PmzDG6JGGlNmzYwMCBAwkLC0PTNBYvXlwt+3WIsM7JyWHo0KE8+uijRpcirNCECRNYuHAho0aNYsmSJURERDB27FgOHDhgdGnCCqWnp9O6dWtmzpxZrft1qK57c+fOZeLEiSQnJxtdirAi3t7e1K9fn7179wKQl5eHm5sbffr0Yfny5QZXJ6yZpmn8/PPPDB48uMr35RBH1kKUJS0tjfT0dAYMGGBe5+zsTGRkJHv27DGwMiGKk7AWDu2ff/4BoF69esXWBwYGmofoFcIa2GxYP/fcc2iadtXboUOHjC5TCCEswqqHSL2ap59+mtGjR191m/r161dPMcJmNW7cGICYmJhi6xMTE/Hx8TGiJCFKZbNhHRwcTHBwsNFlCBvn7e2Nl5cXy5Yt46233gLUCcbY2Fj69OljcHVCXGKzzSAVceLECaKjozlx4gT5+flER0cTHR1NWlqa0aUJKzB27Fj27dvHuHHj+PXXX2nVqhW6rvPf//7X6NKEFUpLSzNnCKhvZUX5UqV0B/DAAw/oQInbunXrjC5NWIm7775bd3Jy0gHdy8tL//LLL40uSVipdevWlZonDzzwQJXu16H6WQshhK1yiGYQIYSwdRLWQghhAySshRDCBkhYCyGEDZCwFkIIGyBhLYQQNkDCWgghbICEtRBC2AAJayGEsAES1kIIYQMkrIUQwgZIWAshhA34f2Uaee+7Mb96AAAAAElFTkSuQmCC",
       "text/plain": [
        "<Figure size 400x400 with 1 Axes>"
       ]
@@ -111,7 +89,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 400x400 with 1 Axes>"
       ]
@@ -121,7 +99,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWgAAAF2CAYAAABDOQI+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAfHUlEQVR4nO3de3BU5f3H8c8GzS5IshBJIIEAAVQa0XREudeCRcV2goyFWigalKIwwSlFraS31D9s2uKoHaRIpxZEg6EXQmQ6tTBUwBtg0a1cBsZo0oQkkGBkN8SS2OT8/uDHtiG33SSb50nyfs2cqTn7nPN899vMJ2efPbu4HMdxBACwTpTpAgAALSOgAcBSBDQAWIqABgBLEdAAYCkCGgAsRUADgKUIaACwFAENAJYioAHAUgQ0rHfs2DEtXrxYw4cPl9vtVlJSkhYvXqzjx4+3esxvfvMbuVwuTZ48udUxLpdLLpdL3/3ud1t8/Ec/+lFwzNmzZ4P7T548qe9///uaNm2aPB6PXC6XiouLW52npqZGP/jBD5SSkiK3263hw4dr/vz5+vzzz9t/8ujTXHwXB2y2fft2LVy4UHFxcVq6dKlSUlJUXFysF198UdXV1dq2bZvuvvvuZsdNnz5d5eXlKi4u1kcffaRx48Y1G+NyueTxeOTxeHTmzBlFR0c3eXzMmDGqqKjQhQsXVFVVpSFDhkiSNm/erKVLlyo1NVVXXHGFfD6fioqKNHr06GZz+P1+ffWrX9WpU6f00EMPady4caqqqtKbb76pl19+WYMHD+6aRqF3cgBLFRYWOgMGDHDGjx/vVFZWNnmsqqrKGT9+vDNw4EDnk08+afLYJ5984khytm/f7sTHxzs/+9nPWjy/JGfevHlOVFSUs2PHjiaPvf32244k55vf/KYjyamqqgo+9umnnzqBQMBxHMdZu3atI8kpKipqcY4VK1Y4gwYNalYjEAqWOGCttWvX6vPPP9dvf/tbxcfHN3lsyJAh2rhxo86fP6+1a9c2eSw3N1eDBw/WN77xDc2fP1+5ubmtzjF8+HDdeuut2rp1a7Nz3HDDDZowYUKzY+Li4hQTE9Nu/efOndOmTZv00EMPKSUlRfX19aqrq2v3OOASAhrW2rlzp0aPHq2vfOUrLT5+6623avTo0dq5c2eT/bm5ubrnnnsUHR2thQsX6qOPPtJ7773X6jyLFi3Szp07df78eUnSf/7zH/3xj3/UokWLOlX/W2+9pQsXLmjcuHGaP3++BgwYoP79+2v69Ony+XydOjf6BgIaVvL7/SovL1daWlqb42688UadOnVKNTU1kqTDhw/rxIkT+va3vy1JmjFjhkaMGNHmVfT8+fPV0NCgHTt2SJJ27dqls2fPauHChZ16Dh999JEkKSsrS6WlpdqyZYvWr1+vjz/+WLfddpsqKio6dX70fgQ0rHQpcNtbSrj0+KXxubm5Gjp0qGbNmiXp4huB9957r/Ly8tTQ0NDiOQYPHqw5c+bo1VdflSRt3bpV06ZN06hRozr1HC5dkbtcLu3Zs0eLFi3SihUrtGPHDn322Wdav359p86P3o+AhpUuD97W1NTUyOVyaciQIWpoaFBeXp5mzZqloqIiFRYWqrCwUJMnT9aZM2e0Z8+eVs+zaNEi7d69WyUlJdqxY0enlzckqX///pKk9PR0DRw4MLh/ypQpSklJ0TvvvNPpOdC7XWG6AKAlXq9XSUlJ+vDDD9sc9+GHH2rEiBGKjo7W7t27VVFRoby8POXl5TUbm5ubqzvuuKPF88ydO1dut1sZGRmqq6vTt771rU4/h6SkJEnS0KFDmz2WkJCgzz77rNNzoHcjoGGt9PR0bdy4UW+99ZZmzJjR7PE333xTxcXFWr16taSLAZyQkNDi0sH27duVn5+vF154IXhl+7/69++vefPm6ZVXXtFdd90VvOe5MyZOnChJKisra/ZYeXm5xo8f3+k50LsR0LDWY489ppdfflkPP/yw9u/fr6uvvjr4WHV1tZYvX67Y2FitXLlS//73v7V9+3YtWLBA8+fPb3aupKQkvfrqq3rttdd07733tjrf2LFjdeedd3ZJ/dddd53S0tJUUFCgs2fPBkN/165dKi0t1SOPPNIl86D3IqBhrXHjxmnLli1auHChbrjhhmafJPzss8+Ul5enlJQUbdu2TTU1NZo7d26L55oyZYri4+OVm5vbakCnpaW1e9eIdPEOk3Xr1kmS3n77bUnS888/r0GDBmnQoEFauXJlcOyzzz6r22+/XTNmzNDDDz8sv9+vZ555Rtdee61WrFgRbkvQ15j+pAzQniNHjjiLFi1yhg0b5kRFRTmSHI/H4xw7diw4Jj093fF4PE5tbW2r51myZIlz5ZVXOmfPnnUc5+InCTMzM9ucOzs7u9knCYuKihxJLW6jRo1qdo7du3c7U6ZMcTwejxMXF+fcd999TkVFRZhdQF/Ed3Ggx9myZYuWLFmixYsXa8uWLabLASKGJQ70OPfff78qKiq0Zs0ajRgxQj//+c9NlwREBFfQAGApPqgCAJYioAHAUgQ0AFiKgAYAS1l9F0djY6PKy8sVExMjl8tluhwA6DTHcVRTU6OkpCRFRbV9jWx1QJeXlys5Odl0GQDQ5UpLSzVixIg2x1gd0Je+crK0tFSxsbGGqwGAzgsEAkpOTg7pn02zOqAvLWvExsYS0AB6lVCWbXmTEAAsRUADgKUIaACwFAENAJYioAHAUgQ0AFjK6tvsOqKh0dGhompV1lxQQoxHk1Li1C+KTyFGGn03g76b0V19j2hAb9iwQRs2bFBxcbEk6frrr9dPf/pT3XXXXRGZ7/WjFXpy53FV+C8E9yV6PcpOT9WcCYkRmRP03RT6bkZ39j2iX9i/c+dO9evXT9dcc40cx9FLL72ktWvX6oMPPtD111/f7vGBQEBer1d+v7/dD6q8frRCK155X5c/mUt/0zYsvolf2gig72bQdzO6ou/h5FpE16DT09P19a9/Xddcc42uvfZaPfXUUxo4cKAOHDjQpfM0NDp6cufxZk2TFNz35M7jamjkH4/pSvTdDPpuhom+d9ubhA0NDcrLy1Ntba2mTp3a4pi6ujoFAoEmWygOFVU3eblxOUdShf+CDhVVd6R0tIK+m0HfzTDR94gH9JEjRzRw4EC53W4tX75c+fn5Sk1NbXFsTk6OvF5vcAv1m+wqa1pvWkfGITT03Qz6boaJvkc8oK+77jr5fD4dPHhQK1asUEZGho4fP97i2KysLPn9/uBWWloa0hwJMZ4uHYfQ0Hcz6LsZJvoe8YCOjo7WuHHjNHHiROXk5CgtLU2//vWvWxzrdruD31wXzjfYTUqJU6LXo9ZucnHp4rusk1LiOvYk0CL6bgZ9N8NE37v9gyqNjY2qq6vr0nP2i3IpO/3issnlzbv0c3Z6KveHdjH6bgZ9N8NE3yMa0FlZWdq/f7+Ki4t15MgRZWVlae/evfrOd77T5XPNmZCoDYtv0jBv05cXw7webjmKIPpuBn03o7v7HtH7oJcuXao9e/aooqJCXq9XN954o5544gndfvvtIR0fzv2Cl/DJKjPouxn03YzO9D2cXItoQHdWRwIaAGxmzQdVAAAdR0ADgKUIaACwFAENAJYioAHAUgQ0AFiKgAYASxHQAGApAhoALEVAA4ClCGgAsBQBDQCWIqABwFIENABYioAGAEsR0ABgKQIaACxFQAOApQhoALAUAQ0AliKgAcBSBDQAWIqABgBLEdAAYCkCGgAsRUADgKUIaACwFAENAJYioAHAUgQ0AFiKgAYASxHQAGApAhoALEVAA4ClCGgAsFREAzonJ0e33HKLYmJilJCQoHnz5unkyZORnBIAeo2IBvS+ffuUmZmpAwcOaPfu3friiy90xx13qLa2NpLTAkCv4HIcx+muyaqqqpSQkKB9+/bp1ltvbXd8IBCQ1+uV3+9XbGxsN1QIAJEVTq516xq03++XJMXFxXXntADQI13RXRM1NjZq1apVmj59uiZMmNDimLq6OtXV1QV/DgQC3VUeAFin266gMzMzdfToUeXl5bU6JicnR16vN7glJyd3V3kAYJ1uWYNeuXKlCgoKtH//fqWkpLQ6rqUr6OTkZNagAfQa4axBR3SJw3EcPfLII8rPz9fevXvbDGdJcrvdcrvdkSwJAHqMiAZ0Zmamtm7dqoKCAsXExOj06dOSJK/Xq/79+0dyagDo8SK6xOFyuVrcv2nTJi1ZsqTd47nNDkBvY9USBwCgY/guDgCwFAENAJYioAHAUgQ0AFiKgAYASxHQAGApAhoALEVAA4ClCGgAsBQBDQCWIqABwFIENABYioAGAEsR0ABgKQIaACxFQAOApQhoALAUAQ0AliKgAcBSBDQAWIqABgBLEdAAYCkCGgAsRUADgKUIaACwFAENAJYioAHAUgQ0AFiKgAYASxHQAGApAhoALEVAA4ClCGgAsBQBDQCWIqABwFIENABYKqIBvX//fqWnpyspKUkul0s7duyI5HSSpIZGR+9+/KkKfGV69+NP1dDoRHxO0HdT6LsZ3dX3KyJy1v9XW1urtLQ0Pfjgg7rnnnsiOZUk6fWjFXpy53FV+C8E9yV6PcpOT9WcCYkRn7+vou9m0HczurPvLsdxuuVPrsvlUn5+vubNmxfyMYFAQF6vV36/X7GxsW2Off1ohVa88r4ufzKu///fDYtv4pc2Aui7GfTdjK7oezi51ivWoBsaHT2583izpkkK7nty53Fe/nUx+m4GfTfDRN+tCui6ujoFAoEmWygOFVU3eblxOUdShf+CDhVVd1GlkOi7KfTdDBN9tyqgc3Jy5PV6g1tycnJIx1XWtN60joxDaOi7GfTdDBN9tyqgs7Ky5Pf7g1tpaWlIxyXEeLp0HEJD382g72aY6LtVAe12uxUbG9tkC8WklDglej3BhfrLuXTxXdZJKXFdVivouyn03QwTfY9oQJ8/f14+n08+n0+SVFRUJJ/Pp5KSki6dp1+US9npqZLUrHmXfs5OT1W/qNZai46g72bQdzNM9D2it9nt3btXs2bNarY/IyNDmzdvbvf4cG5Hkbgv1BT6bgZ9N6OzfQ8n17rtPuiOCDegpYu3whwqqlZlzQUlxFx8ucGVROTRdzPouxmd6XufDmgAsFmf+6AKAPRGBDQAWIqABgBLEdAAYCkCGgAsRUADgKUIaACwFAENAJYioAHAUgQ0AFiKgAYASxHQAGApAhoALEVAA4ClCGgAsBQBDQCWIqABwFIENABYioAGAEsR0ABgKQIaACxFQAOApQhoALAUAQ0AliKgAcBSBDQAWIqABgBLEdAAYCkCGgAsRUADgKUIaACwFAENAJYioAHAUgQ0AFiKgAYAS3VLQK9fv16jR4+Wx+PR5MmTdejQoe6YFgB6tIgH9LZt27R69WplZ2fr/fffV1pamu68805VVlZGemoA6NEiHtDPPPOMli1bpgceeECpqal64YUXNGDAAP3+97+P9NQA0KNFNKDr6+t1+PBhzZ49+78TRkVp9uzZevfdd5uNr6urUyAQaLIBQF8V0YA+e/asGhoaNHTo0Cb7hw4dqtOnTzcbn5OTI6/XG9ySk5MjWR4AWM2quziysrLk9/uDW2lpqemSAMCYKyJ58iFDhqhfv346c+ZMk/1nzpzRsGHDmo13u91yu92RLAkAeoyIXkFHR0dr4sSJ2rNnT3BfY2Oj9uzZo6lTp0ZyagDo8SJ6BS1Jq1evVkZGhm6++WZNmjRJzz33nGpra/XAAw9EemoA6NEiHtD33nuvqqqq9NOf/lSnT5/Wl7/8Zb3++uvN3jgEADTlchzHMV1EawKBgLxer/x+v2JjY02XAwCdFk6uWXUXBwDgvwhoALAUAQ0AliKgAcBSBDQAWIqABgBLEdAAYCkCGgAsRUADgKUIaACwFAENAJYioAHAUgQ0AFiKgAYASxHQAGApAhoALEVAA4ClCGgAsBQBDQCWIqABwFIENABYioAGAEsR0ABgKQIaACxFQAOApQhoALAUAQ0AliKgAcBSBDQAWIqABgBLEdAAYCkCGgAsRUADgKUIaACwFAENAJa6IlInfuqpp/SXv/xFPp9P0dHROnfuXKSmaqKh0dGhompV1lxQQoxHk1Li1C/K1S1z92X03Qz6bkZ39T1iAV1fX68FCxZo6tSpevHFFyM1TROvH63QkzuPq8J/Ibgv0etRdnqq5kxI7JYa+iL6bgZ9N6M7++5yHMfp0jNeZvPmzVq1alWHrqADgYC8Xq/8fr9iY2PbHPv60QqteOV9Xf5kLv1N27D4Jn5pI4C+m0HfzeiKvoeTa71iDbqh0dGTO483a5qk4L4ndx5XQ2NE/xb1OfTdDPpuhom+WxXQdXV1CgQCTbZQHCqqbvJy43KOpAr/BR0qqu6iSiHRd1Pouxkm+h5WQK9Zs0Yul6vN7cSJEx0uJicnR16vN7glJyeHdFxlTetN68g4hIa+m0HfzTDR97DeJHz00Ue1ZMmSNseMGTOmw8VkZWVp9erVwZ8DgUBIIZ0Q4wnp/KGOQ2jouxn03QwTfQ8roOPj4xUfH99lk1/O7XbL7XaHfdyklDglej067b/Q4vqQS9Iw78VbYdB16LsZ9N0ME32P2Bp0SUmJfD6fSkpK1NDQIJ/PJ5/Pp/Pnz3f5XP2iXMpOT5X033dTL7n0c3Z6KveHdjH6bgZ9N8NE3yN2m92SJUv00ksvNdv/xhtvaObMmSGdI5zbUSTuCzWFvptB383obN/DybWI3wfdGeEGtMQnq0yh72bQdzM60/c+HdAAYLM+90EVAOiNCGgAsBQBDQCWIqABwFIENABYioAGAEsR0ABgKQIaACxFQAOApQhoALAUAQ0AliKgAcBSBDQAWIqABgBLEdAAYCkCGgAsRUADgKUIaACwFAENAJYioAHAUgQ0AFiKgAYASxHQAGApAhoALEVAA4ClCGgAsBQBDQCWIqABwFIENABYioAGAEsR0ABgKQIaACxFQAOApQhoALAUAQ0AlopYQBcXF2vp0qVKSUlR//79NXbsWGVnZ6u+vj5SUwJAr3JFpE584sQJNTY2auPGjRo3bpyOHj2qZcuWqba2Vk8//XSkpgWAXsPlOI7TXZOtXbtWGzZs0CeffBLS+EAgIK/XK7/fr9jY2AhXBwCRF06udesatN/vV1xcXHdOCQA9VsSWOC5XWFiodevWtbm8UVdXp7q6uuDPgUCgO0oDACuFfQW9Zs0auVyuNrcTJ040OaasrExz5szRggULtGzZslbPnZOTI6/XG9ySk5PDf0YA0EuEvQZdVVWlTz/9tM0xY8aMUXR0tCSpvLxcM2fO1JQpU7R582ZFRbX+N6GlK+jk5GTWoAH0GuGsQYe9xBEfH6/4+PiQxpaVlWnWrFmaOHGiNm3a1GY4S5Lb7Zbb7Q63JADolSK2Bl1WVqaZM2dq1KhRevrpp1VVVRV8bNiwYZGaFgB6jYgF9O7du1VYWKjCwkKNGDGiyWPdeGcfAPRYEbvNbsmSJXIcp8UNANA+vosDACxFQAOApQhoALAUAQ0AliKgAcBSBDQAWIqABgBLEdAAYCkCGgAsRUADgKUIaACwFAENAJYioAHAUgQ0AFiKgAYASxHQAGApAhoALEVAA4ClCGgAsBQBDQCWIqABwFIENABYioAGAEsR0ABgKQIaACxFQAOApQhoALAUAQ0AliKgAcBSBDQAWIqABgBLEdAAYCkCGgAsRUADgKUIaACw1BWmC+hqDY2ODhVVq7LmghJiPJqUEqd+US7TZfV69N0M+m5Gd/U9ogE9d+5c+Xw+VVZWavDgwZo9e7Z++ctfKikpKSLzvX60Qk/uPK4K/4XgvkSvR9npqZozITEic4K+m0LfzejOvrscx3G69Iz/49lnn9XUqVOVmJiosrIyPfbYY5Kkd955J6TjA4GAvF6v/H6/YmNj2xz7+tEKrXjlfV3+ZC79Tduw+CZ+aSOAvptB383oir6Hk2sRDejLvfbaa5o3b57q6up05ZVXtjs+1CfS0Ohoxi//3uQv2v9ySRrm9eitJ27j5V8Xou9m0Hczuqrv4QR0t71JWF1drdzcXE2bNq3VcK6rq1MgEGiyheJQUXWrTZMkR1KF/4IOFVV3pHS0gr6bQd/NMNH3iAf0E088oauuukpXX321SkpKVFBQ0OrYnJwceb3e4JacnBzSHJU1rTetI+MQGvpuBn03w0Tfww7oNWvWyOVytbmdOHEiOP7xxx/XBx98oF27dqlfv366//771dqqSlZWlvx+f3ArLS0NqaaEGE+XjkNo6LsZ9N0ME30P+y6ORx99VEuWLGlzzJgxY4L/PWTIEA0ZMkTXXnutvvSlLyk5OVkHDhzQ1KlTmx3ndrvldrvDLUmTUuKU6PXotP9Cs8V76b9rQ5NS4sI+N1pH382g72aY6HvYV9Dx8fEaP358m1t0dHSLxzY2Nkq6uNbclfpFuZSdnirpv++mXnLp5+z0VN4w6WL03Qz6boaJvkdsDfrgwYN6/vnn5fP59K9//Ut///vftXDhQo0dO7bFq+fOmjMhURsW36Rh3qYvL4Z5PdxyFEH03Qz6bkZ39z1it9kdOXJE3/ve9/TPf/5TtbW1SkxM1Jw5c/TjH/9Yw4cPD+kc4dyOcgmfrDKDvptB383oTN+tvQ86XB0JaACwmZX3QQMAwkNAA4ClCGgAsBQBDQCWIqABwFIENABYyup/UeXSHYChfqsdANjuUp6Fcoez1QFdU1MjSSF/qx0A9BQ1NTXyer1tjrH6gyqNjY0qLy9XTEyMXK7QPx0VCASUnJys0tLSHvcBF2o3g9rN6Iu1O46jmpoaJSUlKSqq7VVmq6+go6KiNGLEiA4fHxsb2+P+T7+E2s2gdjP6Wu3tXTlfwpuEAGApAhoALNUrA9rtdis7O7tDX/5vGrWbQe1mUHvbrH6TEAD6sl55BQ0AvQEBDQCWIqABwFIENABYqk8E9Ny5czVy5Eh5PB4lJibqvvvuU3l5uemy2lVcXKylS5cqJSVF/fv319ixY5Wdna36+nrTpbXrqaee0rRp0zRgwAANGjTIdDntWr9+vUaPHi2Px6PJkyfr0KFDpktq1/79+5Wenq6kpCS5XC7t2LHDdEkhy8nJ0S233KKYmBglJCRo3rx5OnnypOmyQrJhwwbdeOONwQ+oTJ06VX/9618jMlefCOhZs2bpD3/4g06ePKk///nP+vjjjzV//nzTZbXrxIkTamxs1MaNG3Xs2DE9++yzeuGFF/TDH/7QdGntqq+v14IFC7RixQrTpbRr27ZtWr16tbKzs/X+++8rLS1Nd955pyorK02X1qba2lqlpaVp/fr1pksJ2759+5SZmakDBw5o9+7d+uKLL3THHXeotrbWdGntGjFihH7xi1/o8OHD+sc//qHbbrtNd999t44dO9b1kzl9UEFBgeNyuZz6+nrTpYTtV7/6lZOSkmK6jJBt2rTJ8Xq9psto06RJk5zMzMzgzw0NDU5SUpKTk5NjsKrwSHLy8/NNl9FhlZWVjiRn3759pkvpkMGDBzu/+93vuvy8feIK+n9VV1crNzdX06ZN05VXXmm6nLD5/X7FxcWZLqPXqK+v1+HDhzV79uzgvqioKM2ePVvvvvuuwcr6Fr/fL0k97ne7oaFBeXl5qq2t1dSpU7v8/H0moJ944gldddVVuvrqq1VSUqKCggLTJYWtsLBQ69at08MPP2y6lF7j7Nmzamho0NChQ5vsHzp0qE6fPm2oqr6lsbFRq1at0vTp0zVhwgTT5YTkyJEjGjhwoNxut5YvX678/HylpqZ2+Tw9NqDXrFkjl8vV5nbixIng+Mcff1wffPCBdu3apX79+un+++8P6QuzbahdksrKyjRnzhwtWLBAy5Yt6zF1A+3JzMzU0aNHlZeXZ7qUkF133XXy+Xw6ePCgVqxYoYyMDB0/frzL5+mxH/WuqqrSp59+2uaYMWPGKDo6utn+U6dOKTk5We+8805EXpa0J9zay8vLNXPmTE2ZMkWbN29u9ztkI6UjPd+8ebNWrVqlc+fORbi6jqmvr9eAAQP0pz/9SfPmzQvuz8jI0Llz53rMKy2Xy6X8/Pwmz6EnWLlypQoKCrR//36lpKSYLqfDZs+erbFjx2rjxo1del6rvw+6LfHx8YqPj+/QsY2NjZKkurq6riwpZOHUXlZWplmzZmnixInatGmTsXCWOtdzW0VHR2vixInas2dPMNwaGxu1Z88erVy50mxxvZjjOHrkkUeUn5+vvXv39uhwli7+zkQiT3psQIfq4MGDeu+99zRjxgwNHjxYH3/8sX7yk59o7NixRq6ew1FWVqaZM2dq1KhRevrpp1VVVRV8bNiwYQYra19JSYmqq6tVUlKihoYG+Xw+SdK4ceM0cOBAs8VdZvXq1crIyNDNN9+sSZMm6bnnnlNtba0eeOAB06W16fz58yosLAz+XFRUJJ/Pp7i4OI0cOdJgZe3LzMzU1q1bVVBQoJiYmOB6v9frVf/+/Q1X17asrCzdddddGjlypGpqarR161bt3btXf/vb37p+si6/L8QyH374oTNr1iwnLi7OcbvdzujRo53ly5c7p06dMl1auzZt2uRIanGzXUZGRot1v/HGG6ZLa9G6deuckSNHOtHR0c6kSZOcAwcOmC6pXW+88UaLPc7IyDBdWrta+73etGmT6dLa9eCDDzqjRo1yoqOjnfj4eOdrX/uas2vXrojM1WPXoAGgt+uxd3EAQG9HQAOApQhoALAUAQ0AliKgAcBSBDQAWIqABgBLEdAAYCkCGgAsRUADgKUIaACwFAENAJb6P7j2CagAcKrIAAAAAElFTkSuQmCC",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 400x400 with 1 Axes>"
       ]
@@ -131,60 +109,91 @@
     }
    ],
    "source": [
-    "plt.figure(figsize=(4, 4))\n",
-    "plt.title(\"PAM8\")\n",
+    "\n",
+    "# PAM-8\n",
+    "plt.figure(figsize=(4, 1))\n",
+    "plt.title(\"PAM-8 modulation, gray coding\")\n",
     "plt.plot(PAM8, [0]*8, 'o')\n",
+    "plt.yticks([])\n",
+    "plt.xticks(PAM8)\n",
+    "plt.grid(True)\n",
+    "for (k, s) in g_PAM8.items():\n",
+    "    plt.text(s, 0, k)\n",
     "\n",
+    "# QPSK\n",
     "x = [x for x, y in QPSK]\n",
     "y = [y for x, y in QPSK]\n",
     "\n",
+    "circle_x = np.linspace(0, 2*np.pi, 100)\n",
+    "\n",
     "plt.figure(figsize=(4, 4))\n",
-    "plt.title(\"QPSK\")\n",
-    "plt.plot(x,y,'o')\n",
+    "plt.title(\"QPSK modulation, gray coding\")\n",
+    "plt.plot(np.cos(circle_x), np.sin(circle_x), color=\"orange\")\n",
+    "plt.plot(x,y,'o', color=\"blue\")\n",
+    "plt.xticks(x)\n",
+    "plt.yticks(y)\n",
+    "plt.grid(True)\n",
+    "for (k, s) in g_QPSK.items():\n",
+    "    plt.text(*s, k)\n",
     "\n",
+    "# PSK8\n",
     "x = [x for x, y in PSK8]\n",
     "y = [y for x, y in PSK8]\n",
     "\n",
     "plt.figure(figsize=(4, 4))\n",
-    "plt.title(\"PSK8\")\n",
-    "plt.plot(x,y,'o')\n",
+    "plt.title(\"PSK-8 modulation, gray coding\")\n",
+    "plt.plot(np.cos(circle_x), np.sin(circle_x), color=\"orange\")\n",
+    "plt.plot(x,y,'o', color=\"blue\")\n",
+    "plt.xticks(x, rotation=45)\n",
+    "plt.yticks(y)\n",
+    "plt.grid(True)\n",
+    "for (k, s) in g_PSK8.items():\n",
+    "    plt.text(*s, k)\n",
     "\n",
+    "# QAM16\n",
     "x = [x for x, y in QAM16]\n",
     "y = [y for x, y in QAM16]\n",
     "\n",
     "plt.figure(figsize=(4, 4))\n",
     "plt.title(\"QAM16\")\n",
-    "plt.plot(x,y,'o')"
+    "plt.plot(x,y,'o')\n",
+    "plt.xticks(x, rotation=45)\n",
+    "plt.yticks(y)\n",
+    "plt.grid(True)\n",
+    "for (k, s) in g_QAM16.items():\n",
+    "    plt.text(*s, k)\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 647,
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "num_symbols = 10**4\n",
+    "SNR_list = np.linspace(-20, 20, 21)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "errors:  0\n",
-      "PAM8 Symbol error rate (SER):  0.0\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7fc1da226500>]"
+       "<matplotlib.legend.Legend at 0x7f178faf0ca0>"
       ]
      },
-     "execution_count": 647,
+     "execution_count": 68,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 400x400 with 1 Axes>"
+       "<Figure size 400x100 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -192,7 +201,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 400x400 with 1 Axes>"
       ]
@@ -203,17 +212,14 @@
    ],
    "source": [
     "# PAM8\n",
-    "SNR_list =np.linspace(-10, 100, 100)\n",
     "symbol_error_rate = []\n",
+    "bit_error_rate = []\n",
     "\n",
-    "symbols = np.zeros(10**2)\n",
-    "for i in range(10**2):\n",
-    "    symbols[i] = np.random.randint(0, 2)\n",
-    "    \n",
-    "PAM8_symbols = []\n",
-    "for i in symbols:\n",
-    "    PAM8_symbols.append(PAM8[int(i)])\n",
+    "symbols = np.random.randint(0, len(PAM8), size=(num_symbols))\n",
     "\n",
+    "PAM8_symbols = np.zeros(num_symbols, dtype=int)\n",
+    "for i, s in enumerate(symbols):\n",
+    "    PAM8_symbols[i] = PAM8[s]\n",
     "\n",
     "for SNR_dB in SNR_list:\n",
     "\n",
@@ -221,268 +227,88 @@
     "\n",
     "    signal_power = np.mean(np.abs(PAM8_symbols)**2)\n",
     "    noise_power = signal_power / SNR_linear\n",
-    "    num_symbols = len(PAM8_symbols)\n",
     "\n",
     "    noise = noise_power * np.random.normal(0, 1, len(PAM8_symbols))\n",
-    "    rx_signal = [PAM8_symbols[i] + noise[i] for i in range(len(PAM8_symbols))]\n",
+    "    rx_signal = PAM8_symbols + noise\n",
     "\n",
-    "    detected_idx = np.zeros(num_symbols, dtype=int)\n",
+    "    distances = np.zeros(len(PAM8), dtype=float)\n",
+    "    detected_symbols = np.zeros(num_symbols, dtype=int)\n",
     "    for i, r in enumerate(rx_signal):\n",
-    "        distances = [np.linalg.norm(np.array(r) - s) for s in PAM8]\n",
-    "        detected_idx[i] = np.argmin(distances)\n",
-    "\n",
-    "    detected_symbols = []\n",
-    "    for i in detected_idx:\n",
-    "        detected_symbols.append(PAM8[int(i)])\n",
+    "        for j, s in enumerate(PAM8):\n",
+    "            distances[j] = np.linalg.norm(r - s)\n",
+    "            \n",
+    "        detected_symbols[i] = PAM8[np.argmin(distances)]\n",
     "        \n",
     "    errors = 0\n",
-    "    for i in range(len(PAM8_symbols)):\n",
+    "    bit_errors = 0\n",
+    "    for i in range(num_symbols):\n",
     "        if PAM8_symbols[i] != detected_symbols[i]:\n",
     "            errors += 1\n",
-    "            \n",
+    "            code = \"\"\n",
+    "            expected_code = \"\"\n",
+    "            for k, v in g_PAM8.items():\n",
+    "                if v == PAM8_symbols[i]:\n",
+    "                    expected_code = k\n",
+    "                elif v == detected_symbols[i]:\n",
+    "                    code = k\n",
+    "                \n",
+    "                if code != \"\" and expected_code != \"\":\n",
+    "                    break\n",
+    "                    \n",
+    "            bit_errors += diff_letters(code, expected_code)\n",
+    "        \n",
     "    SER = errors / num_symbols\n",
     "    \n",
-    "    symbol_error_rate.append(SER)\n",
-    "\n",
-    "print(\"errors: \", errors)\n",
-    "print(\"PAM8 Symbol error rate (SER): \", SER)\n",
+    "    BER = bit_errors / num_symbols\n",
+    "    \n",
+    "    # print(\"errors: \", errors)\n",
+    "    # print(\"PAM8 Symbol error rate (SER): \", SER)\n",
+    "    \n",
+    "    # Make the plot for specific SNR_dB\n",
+    "    if SNR_dB == 20:\n",
+    "        plt.figure(figsize=(4, 1))\n",
+    "        plt.title(\"Recieved symbols, PAM-8 modulation (SNR_dB = 20)\")\n",
+    "        plt.plot(rx_signal, np.zeros(num_symbols), 'o', color=\"red\")\n",
+    "        plt.plot(PAM8, [0]*len(PAM8), 'o', color=\"blue\")\n",
+    "        plt.yticks([])\n",
+    "        plt.xticks(PAM8)\n",
+    "        plt.grid(True)\n",
+    "        for (k, s) in g_PAM8.items():\n",
+    "            plt.text(s, 0, k)\n",
     "\n",
-    "plt.figure(figsize=(4, 4))\n",
-    "plt.title(\"PAM8\")\n",
-    "plt.plot(rx_signal, [0]*len(rx_signal), 'o', color=\"red\")\n",
-    "plt.plot(PAM8, [0]*len(PAM8), 'o', color=\"blue\")\n",
+    "            \n",
+    "    symbol_error_rate.append(SER)\n",
+    "    bit_error_rate.append(BER)\n",
     "\n",
+    "# Final curve plot\n",
     "plt.figure(figsize=(4, 4))\n",
-    "plt.title(\"PAM8 symbol error rate\")\n",
-    "plt.plot(SNR_list, symbol_error_rate, 'o', color=\"blue\")\n",
+    "plt.title(\"PAM-8 modulation error rate\")\n",
+    "plt.plot(SNR_list, symbol_error_rate, 'o-', color=\"blue\")\n",
+    "plt.plot(SNR_list, bit_error_rate, 'o-', color=\"red\")\n",
+    "plt.xlabel(\"SNR (dB)\")\n",
+    "plt.ylabel(\"Error rate\")\n",
+    "plt.legend([\"Symbol error rate\", \"Bit error rate\"])\n",
     "\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 632,
+   "execution_count": 73,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[-0.7071067811865477, -0.7071067811865475]\n",
-      "errors:  75\n",
-      "QPSK Symbol error rate (SER):  0.75\n",
-      "errors:  67\n",
-      "QPSK Symbol error rate (SER):  0.67\n",
-      "errors:  61\n",
-      "QPSK Symbol error rate (SER):  0.61\n",
-      "errors:  65\n",
-      "QPSK Symbol error rate (SER):  0.65\n",
-      "errors:  71\n",
-      "QPSK Symbol error rate (SER):  0.71\n",
-      "errors:  64\n",
-      "QPSK Symbol error rate (SER):  0.64\n",
-      "errors:  70\n",
-      "QPSK Symbol error rate (SER):  0.7\n",
-      "errors:  76\n",
-      "QPSK Symbol error rate (SER):  0.76\n",
-      "errors:  80\n",
-      "QPSK Symbol error rate (SER):  0.8\n",
-      "errors:  66\n",
-      "QPSK Symbol error rate (SER):  0.66\n",
-      "errors:  67\n",
-      "QPSK Symbol error rate (SER):  0.67\n",
-      "errors:  72\n",
-      "QPSK Symbol error rate (SER):  0.72\n",
-      "errors:  60\n",
-      "QPSK Symbol error rate (SER):  0.6\n",
-      "errors:  61\n",
-      "QPSK Symbol error rate (SER):  0.61\n",
-      "errors:  62\n",
-      "QPSK Symbol error rate (SER):  0.62\n",
-      "errors:  64\n",
-      "QPSK Symbol error rate (SER):  0.64\n",
-      "errors:  66\n",
-      "QPSK Symbol error rate (SER):  0.66\n",
-      "errors:  61\n",
-      "QPSK Symbol error rate (SER):  0.61\n",
-      "errors:  54\n",
-      "QPSK Symbol error rate (SER):  0.54\n",
-      "errors:  56\n",
-      "QPSK Symbol error rate (SER):  0.56\n",
-      "errors:  67\n",
-      "QPSK Symbol error rate (SER):  0.67\n",
-      "errors:  59\n",
-      "QPSK Symbol error rate (SER):  0.59\n",
-      "errors:  56\n",
-      "QPSK Symbol error rate (SER):  0.56\n",
-      "errors:  58\n",
-      "QPSK Symbol error rate (SER):  0.58\n",
-      "errors:  60\n",
-      "QPSK Symbol error rate (SER):  0.6\n",
-      "errors:  57\n",
-      "QPSK Symbol error rate (SER):  0.57\n",
-      "errors:  53\n",
-      "QPSK Symbol error rate (SER):  0.53\n",
-      "errors:  52\n",
-      "QPSK Symbol error rate (SER):  0.52\n",
-      "errors:  55\n",
-      "QPSK Symbol error rate (SER):  0.55\n",
-      "errors:  49\n",
-      "QPSK Symbol error rate (SER):  0.49\n",
-      "errors:  56\n",
-      "QPSK Symbol error rate (SER):  0.56\n",
-      "errors:  41\n",
-      "QPSK Symbol error rate (SER):  0.41\n",
-      "errors:  52\n",
-      "QPSK Symbol error rate (SER):  0.52\n",
-      "errors:  46\n",
-      "QPSK Symbol error rate (SER):  0.46\n",
-      "errors:  49\n",
-      "QPSK Symbol error rate (SER):  0.49\n",
-      "errors:  47\n",
-      "QPSK Symbol error rate (SER):  0.47\n",
-      "errors:  40\n",
-      "QPSK Symbol error rate (SER):  0.4\n",
-      "errors:  39\n",
-      "QPSK Symbol error rate (SER):  0.39\n",
-      "errors:  35\n",
-      "QPSK Symbol error rate (SER):  0.35\n",
-      "errors:  34\n",
-      "QPSK Symbol error rate (SER):  0.34\n",
-      "errors:  32\n",
-      "QPSK Symbol error rate (SER):  0.32\n",
-      "errors:  32\n",
-      "QPSK Symbol error rate (SER):  0.32\n",
-      "errors:  19\n",
-      "QPSK Symbol error rate (SER):  0.19\n",
-      "errors:  35\n",
-      "QPSK Symbol error rate (SER):  0.35\n",
-      "errors:  13\n",
-      "QPSK Symbol error rate (SER):  0.13\n",
-      "errors:  21\n",
-      "QPSK Symbol error rate (SER):  0.21\n",
-      "errors:  25\n",
-      "QPSK Symbol error rate (SER):  0.25\n",
-      "errors:  20\n",
-      "QPSK Symbol error rate (SER):  0.2\n",
-      "errors:  16\n",
-      "QPSK Symbol error rate (SER):  0.16\n",
-      "errors:  10\n",
-      "QPSK Symbol error rate (SER):  0.1\n",
-      "errors:  12\n",
-      "QPSK Symbol error rate (SER):  0.12\n",
-      "errors:  11\n",
-      "QPSK Symbol error rate (SER):  0.11\n",
-      "errors:  11\n",
-      "QPSK Symbol error rate (SER):  0.11\n",
-      "errors:  10\n",
-      "QPSK Symbol error rate (SER):  0.1\n",
-      "errors:  10\n",
-      "QPSK Symbol error rate (SER):  0.1\n",
-      "errors:  9\n",
-      "QPSK Symbol error rate (SER):  0.09\n",
-      "errors:  6\n",
-      "QPSK Symbol error rate (SER):  0.06\n",
-      "errors:  6\n",
-      "QPSK Symbol error rate (SER):  0.06\n",
-      "errors:  7\n",
-      "QPSK Symbol error rate (SER):  0.07\n",
-      "errors:  3\n",
-      "QPSK Symbol error rate (SER):  0.03\n",
-      "errors:  4\n",
-      "QPSK Symbol error rate (SER):  0.04\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  1\n",
-      "QPSK Symbol error rate (SER):  0.01\n",
-      "errors:  1\n",
-      "QPSK Symbol error rate (SER):  0.01\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  1\n",
-      "QPSK Symbol error rate (SER):  0.01\n",
-      "errors:  1\n",
-      "QPSK Symbol error rate (SER):  0.01\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "QPSK Symbol error rate (SER):  0.0\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7fc1dc58b6a0>]"
+       "Text(0, 0.5, 'Error rate')"
       ]
      },
-     "execution_count": 632,
+     "execution_count": 73,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcQAAAGACAYAAAAzlhJlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/GU6VOAAAACXBIWXMAAA9hAAAPYQGoP6dpAABbVElEQVR4nO3dd3hTZfvA8W+a7tIyWyi07CWCZQmKVArIkmmpAipDEfUVFFB4f06WA0UUUFBAfQU3CpWhbGRURYYIKrKXLaOUWaCUtsn5/fE0oekeSU+S3p/rypXk5OScO01P7vPMY9A0TUMIIYQo4zz0DkAIIYRwBpIQhRBCCCQhCiGEEIAkRCGEEAKQhCiEEEIAkhCFEEIIQBKiEEIIAUhCFEIIIQBJiEIIIQTgIgnx+PHjGAwGFixYoHcoedq0aRMGg4FNmzbpHUqhDRs2jHLlytl1m7Vr12bYsGF23aawv5J8T1FRUURFRdk1nkmTJmEwGOy6zaKIj4/H19eXX375RbcYHMER35WzW716NeXKlSMpKanI7y1SQlywYAEGg8F68/T0pEaNGgwbNoyTJ08WeedCFEd6ejrvvfcet99+O4GBgZQrV47bb7+d999/n4yMjBzr165d2+b/NiQkhMjISL7//nub9cxmM5999hlt27alUqVKBAYG0rBhQ4YMGcJvv/1mXc9y8rN48WKb96elpdGrVy88PDz43//+55gP78JSUlKYNGmSU540TpkyhbZt23LXXXfZLF+xYgUdOnQgJCQEf39/6tatywMPPMDq1aut61hO2A0GA0uWLMmxbUuyP3funHXZsGHDbP4nfXx8aNiwIRMmTCA1NdVhnzNrrJZbUFAQzZs3Z/bs2ZhMJoftOzdXr15l4sSJdO/enUqVKhVY8Nm3bx/du3enXLlyVKpUicGDB+dIfN27d6d+/fpMnTq1yPF4FvkdqH+eOnXqkJqaym+//caCBQv4+eef+fvvv/H19S3OJvNVq1Ytrl+/jpeXl923LVzLtWvX6NmzJ5s3b6ZXr14MGzYMDw8PVq9ezTPPPMPSpUtZsWIF/v7+Nu9r3rw5zz33HACnTp1i3rx5REdH8+GHH/Lkk08C8MwzzzBnzhz69u3LQw89hKenJwcOHGDVqlXUrVuXO+64I8+40tPTiYmJYeXKlXz00Uc8+uijjvsjuKiUlBQmT54MkKPU8vLLL/P888/rEBUkJSWxcOFCFi5caLN8+vTpjB8/ng4dOvDCCy/g7+/P4cOHWb9+Pd988w3du3fPsa0pU6YQHR1dqNKuj48PH3/8MQCXL19m2bJlvPrqqxw5coQvv/zSPh8uD4MGDeLee++17nvlypU8/fTTnDhxgrffftuh+87q3LlzTJkyhZo1axIREZHvyVJCQgJ333035cuX54033uDq1atMnz6dv/76i+3bt+Pt7W1d94knnmDcuHFMnjyZwMDAwgekFcGnn36qAdqOHTtslv/f//2fBmiLFi0qyubcysaNGzVA27hxo96hFNrQoUO1gIAAu26zVq1a2tChQ+26zawef/xxDdDef//9HK/Nnj1bA7SnnnoqR0w9e/a0WXb69GktICBAa9iwoaZpmnbmzBnNYDBoI0aMyLFds9msJSYmWp9bvuvvvvtO0zRNS0tL0/r166cZDAZt/vz5Jf6MpaEk31OHDh20Dh06FPl9SUlJGqBNnDixWPt1lHfffVfz8/PTrly5Yl2Wnp6uBQUFaV26dMn1PVn/H44dO6YBWvPmzTVAW7Jkic26EydO1AAtKSnJuiy3Y89sNmt33HGHZjAYtDNnztjjo+X4riyxvv322zn2ffvtt2vVq1e3y34LKzU1VTt9+rSmaZq2Y8cODdA+/fTTXNf9z3/+o/n5+WknTpywLlu3bp0GaPPmzbNZNzExUTMajdonn3xSpHjs0oYYGRkJwJEjR2yW79+/n5iYGCpVqoSvry+tW7dm+fLlOd5/6dIlxo4dS+3atfHx8SEsLIwhQ4ZYqxjyakMsaPs7d+7EYDDkOPMDWLNmDQaDgR9++MG67OTJkzz66KNUrVoVHx8fbr311lyrvhISEujXrx8BAQGEhIQwduxYbty4Uai/1ZUrVxgzZoz1s4aEhNClSxd27doFwMSJE/Hy8sq1/vvxxx+nQoUK1iqV2rVr06tXLzZt2kTr1q3x8/OjWbNm1rOs2NhYmjVrhq+vL61ateKPP/7INaajR4/SrVs3AgICqF69OlOmTEHLdhGUa9eu8dxzzxEeHo6Pjw+NGjVi+vTpOdbLLj09ncmTJ9OgQQN8fX2pXLky7du3Z926dYX6e2WVkJDAJ598QqdOnRg1alSO10eOHEnHjh2ZP39+gVX41apV45ZbbuHYsWMAHDt2DE3TclSZAdZq1txkZGQwcOBAli1bxocffsiIESMK/ByWKtdvv/2WyZMnU6NGDQIDA4mJieHy5cvcuHGDMWPGEBISQrly5XjkkUdy/H9lZGTw6quvUq9ePXx8fKhduzYvvvhijvU0TeO1114jLCwMf39/OnbsyN69e3PElFcbnqWZ5Pjx43l+nrS0NCZMmECrVq0oX748AQEBREZGsnHjRus6x48fJzg4GIDJkydbq+smTZqU5/4L+xktx8HPP/9MmzZt8PX1pW7dunz22Wd5xpzV0qVLadu2rU17+rlz50hOTs71/wHI9f9h4MCBNGzYMNfjpzAMBgPt27dH0zSOHj1a5PfPnz+fevXq4efnR5s2bYiLiyvSvqtWrYqnZ7EqDYvNx8eHatWqFWrdJUuW0KtXL2rWrGldds8999CwYUO+/fZbm3VDQkK47bbbWLZsWZHisUtCtBwsFStWtC7bu3cvd9xxB/v27eP555/nnXfeISAggH79+tm03Vy9epXIyEjef/99unbtyqxZs3jyySfZv38/CQkJee6zMNtv3bo1devWzfHHAli0aBEVK1akW7duACQmJnLHHXewfv16Ro0axaxZs6hfvz7Dhw9n5syZ1vddv36dzp07s2bNGkaNGsVLL71EXFwc//3vfwv1t3ryySf58MMP6d+/Px988AHjxo3Dz8+Pffv2ATB48GAyMjJYtGiRzfvS0tJYvHgx/fv3t6mWPnz4MA8++CC9e/dm6tSpXLx4kd69e/Pll18yduxYHn74YSZPnsyRI0d44IEHMJvNNts1mUx0796dqlWrMm3aNFq1asXEiROZOHGidR1N0+jTpw8zZsyge/fuvPvuuzRq1Ijx48fz7LPP5vt5J02axOTJk+nYsSOzZ8/mpZdeombNmtYTgKJYtWoVJpOJIUOG5LnOkCFDyMjIsGnjyU16ejrx8fFUrlwZUNXyAN999x0pKSmFiicjI4NBgwbx/fffM2fOHJ544olCfhJl6tSprFmzhueff55HH32U2NhYnnzySR599FEOHjzIpEmTiI6OZsGCBbz11ls2733ssceYMGECLVu2ZMaMGXTo0IGpU6cycOBAm/UmTJjAK6+8QkREBG+//TZ169ala9euXLt2rUix5ic5OZmPP/6YqKgo3nrrLSZNmkRSUhLdunVj9+7dAAQHB/Phhx8CcN999/H555/z+eefEx0dned2C/sZQR0HMTExdOnShXfeeYeKFSsybNiwXJN/Vunp6ezYsYOWLVvaLA8JCcHPz48VK1Zw4cKFQv0djEYjL7/8Mnv27MnRPl1Yuf2WFsYnn3zCE088QbVq1Zg2bRp33XUXffr0IT4+Ptf1U1JSOHfuHOfOnePo0aPMmTOH1atXM3To0AL3dePGDet7C7rZy8mTJzl79iytW7fO8VqbNm1yPdlv1aoVv/76a9F2VJTipKXKdP369VpSUpIWHx+vLV68WAsODtZ8fHy0+Ph467qdO3fWmjVrpqWmplqXmc1mrV27dlqDBg2syyZMmKABWmxsbI79mc1mTdNuFvOzFqULu/0XXnhB8/Ly0i5cuGBdduPGDa1ChQrao48+al02fPhwLTQ0VDt37pxNDAMHDtTKly+vpaSkaJqmaTNnztQA7dtvv7Wuc+3aNa1+/fqFqjItX768NnLkyHzXufPOO7W2bdvaLIuNjc2x/Vq1ammA9uuvv1qXrVmzRgNyVC3Mmzcvx/uHDh2qAdrTTz9tXWY2m7WePXtq3t7e1iqepUuXaoD22muv2cQUExOjGQwG7fDhwzYxZa2Ki4iIyFFdWVxjxozRAO2PP/7Ic51du3ZpgPbss8/axNS1a1ctKSlJS0pK0vbs2aMNHDgwx2cfMmSIBmgVK1bU7rvvPm369Onavn37cuzDUmVq+fvPmTOnSJ/D8v6mTZtqaWlp1uWDBg3SDAaD1qNHD5v177zzTq1WrVrW57t379YA7bHHHrNZb9y4cRqg/fTTT5qmadrZs2c1b29vrWfPntZjSdM07cUXX9QAm+/JUq2XneWYP3bsmHVZ9mq4jIwM7caNGzbvu3jxola1alWbYyy/KtPs+y/sZ9S0m8fBli1brMvOnj2r+fj4aM8991yOfWV1+PDhPKvgLb9NAQEBWo8ePbTXX39d+/3333Osl7UaMiMjQ2vQoIEWERFh/ZvnV2Vq+Z88fPiwNn36dM1gMGhNmza1+b4KkpaWpoWEhGjNmze3+R7mz5+vAblWmeZ2+89//lOo/Vr+JwpzK4r8qkwtr3322Wc5Xhs/frwG2OQCTdO0N954QwNsqrcLUqwS4j333ENwcDDh4eHExMQQEBDA8uXLCQsLA+DChQv89NNPPPDAA1y5csV6tnD+/Hm6devGoUOHrFVaS5YsISIigvvuuy/HfvJqmC7K9gcMGEB6ejqxsbHW969du5ZLly4xYMAAUN8aS5YsoXfv3miaZnOG061bNy5fvmwt0axcuZLQ0FBiYmKs2/P39+fxxx8v1N+uQoUKbNu2jVOnTuW5zpAhQ9i2bZtNFfSXX35JeHg4HTp0sFm3SZMm3Hnnndbnbdu2BaBTp042VQuW5blVxWStfjQYDIwaNYq0tDTWr19v/cxGo5FnnnnG5n3PPfccmqaxatWqfD/v3r17OXToUJ7rFNaVK1cA8m0kt7xmWddi7dq1BAcHExwcTEREBN999x2DBw+2KXl9+umnzJ49mzp16vD9998zbtw4brnlFjp37pxrFWxiYiKenp7UqVOnWJ9nyJAhNh3F2rZti6ZpOTrktG3blvj4eGsP2pUrVwLkKJ1bOg39+OOPAKxfv560tDSefvppm2NpzJgxxYo3L0aj0dqhwWw2c+HCBTIyMmjdunWxagKg8J/RokmTJtamG1Al0kaNGhVY9Xj+/Hkg9xLZ5MmT+eqrr2jRogVr1qzhpZdeolWrVrRs2dJao5Nd1lLi0qVL8933tWvXrP+T9evXZ9y4cdx1110sW7asSENQdu7cydmzZ3nyySdtOpYMGzaM8uXL5/qexx9/nHXr1rFu3TqWLFnCyJEjmTdvXoE1PgDdunWzvregm71cv34dUFWs2VlqzCzrWFi+06KUVItVYTxnzhwaNmzI5cuX+d///seWLVtsAj18+DCapvHKK6/wyiuv5LqNs2fPUqNGDY4cOUL//v2LtP+ibD8iIoLGjRuzaNEihg8fDqjq0ipVqtCpUydA9TK7dOkS8+fPZ/78+XluD+DEiRPUr18/xz9so0aNChX7tGnTGDp0KOHh4bRq1Yp7772XIUOGULduXes6AwYMYMyYMXz55ZdMmDCBy5cv88MPPzB27Ngc+82a9ADrARAeHp7r8osXL9os9/DwsNk3QMOGDYGb1TcnTpygevXqORLRLbfcYn09L1OmTKFv3740bNiQpk2b0r17dwYPHsxtt92W53vykleyy8ryWvY2nrZt2/Laa69hMBjw9/fnlltuoUKFCjbreHh4MHLkSEaOHMn58+f55ZdfmDt3LqtWrWLgwIE52mSmTZvGzJkziYmJYe3atXm2N+WlKN+d2Wzm8uXLVK5cmRMnTuDh4UH9+vVt1qtWrRoVKlSwfh+W+wYNGtisFxwcXOQquYIsXLiQd955h/3795Oenm5dXtyThcJ+Rovsf0tQP4jZ/9/zouXR5jdo0CAGDRpEcnIy27ZtY8GCBXz11Vf07t07z171Dz30EK+++ipTpkyhX79+ee7T19eXFStWAKp9fNq0aZw9exY/P79CxWyR1/fs5eWV49i2aNCgAffcc4/1uaVn7MyZM3n00Udp1qxZnvsLDQ0lNDS0SDGWlOVvkltfDUufiux/N8t3WpSTi2IlxDZt2ljrcvv160f79u158MEHOXDgAOXKlbO2U40bN87aRpdd9n/0oijq9gcMGMDrr7/OuXPnCAwMZPny5QwaNMjagGzZ3sMPP5xnHXpxfsBz88ADD1jHwK1du5a3336bt956i9jYWHr06AGoA7lXr17WhLh48WJu3LjBww8/nGN7RqMx1/3ktTyvA99R7r77bo4cOcKyZctYu3YtH3/8MTNmzGDu3Lk89thjRdpWkyZNAPjzzz9p3rx5ruv8+eefADl+CKpUqWLzA1CQypUr06dPH/r06UNUVBSbN2/mxIkT1rZGUD8M69ato3379tahIBEREYXeR0m/O3sOZM9rW4UZl/bFF18wbNgw+vXrx/jx4wkJCcFoNDJ16tQcHe3sFVd2xf1/t7QhF5Q4g4KC6NKlC126dMHLy4uFCxeybdu2HDU2llhefvllhg0blm+nDqPRaPM/2a1bNxo3bswTTzyRa+dDR+vcuTOzZ89my5Yt+SbE69evc/ny5UJts7AdZgpiScCnT5/O8drp06epVKlSjtKj5TutUqVKofdT4k41ln/8U6dOMXv2bODmj5GXlxf33HNPrjfL2X69evX4+++/i7TPomwfVELMyMhgyZIlrFq1iuTkZJuG+eDgYAIDAzGZTHluz1LiqFWrFkeOHMlxoB04cKDQ8YeGhvLUU0+xdOlSjh07RuXKlXn99ddt1hkyZAgHDx5kx44dfPnll7Ro0YJbb721SH+nwjCbzTmqlQ4ePAio3nugPvOpU6dylMz2799vfT0/lSpV4pFHHuHrr78mPj6e2267zdq7sCh69OiB0Wjk888/z3Odzz77DG9vb/r27Vvk7efFcvKX28FYt25d1qxZg4eHh7W63tFq1aqF2WzOsa/ExEQuXbpk/T4s99nXS0pKypEALCXGS5cu2SzPr/RvsXjxYurWrUtsbCyDBw+mW7du3HPPPTkGmBclgRf2M5ZUzZo18fPzs/Y2Loz8/h8sHn74YerXr8/kyZMLfRIaGhrK2LFjWbFihc1EEAXJ63tOT08v0ueyVMlfvXo13/UWLVpkLSUWdLOXGjVqEBwczM6dO3O8tn379lxPkI8dO0aVKlWsvZsLwy69TKOiomjTpg0zZ84kNTWVkJAQoqKimDdvXq7/NFmHFPTv3z/PXll5/SMVZfugqvaaNWvGokWLrF/m3XffbX3daDTSv39/lixZkmtyzrq9e++9l1OnTtnMUpKSkpJnVWtWJpMpx5lVSEgI1atXz1EV0KNHD6pUqcJbb73F5s2bcy0d2ovlRAbU33z27Nl4eXnRuXNnQH1mk8lksx7AjBkzMBgM1pJtbixtNBblypWjfv36hR6mklVYWBjDhw9n/fr11h6LWc2dO5effvqJJ554wnrmX1hnzpzhn3/+ybE8LS2NDRs25Fp9Z9GsWTN+/PFHrl69SpcuXRw+a5NlQHXW3s8A7777LgA9e/YEVFu/l5cX77//vs2xlP19oE5MAbZs2WJddu3atVyHLGVnKZ1l3ce2bdvYunWrzXqWyRKyJ93cFPYzlpSXlxetW7fO8UObkpKSI34LS5t5fs0kllLi7t27i1Tae/rpp/H39+fNN98s9Htat25NcHAwc+fOJS0tzbp8wYIFhfpbW1iqbwuq5dCjDRFUrvjhhx9ses5u2LCBgwcPcv/99+dY//fff7fpX1EYdht0Mn78eO6//34WLFjAk08+yZw5c2jfvj3NmjVjxIgR1K1bl8TERLZu3UpCQgJ79uyxvm/x4sXcf//9PProo7Rq1YoLFy6wfPly5s6dm+eXU9jtWwwYMIAJEybg6+vL8OHD8fCwPRd488032bhxI23btmXEiBE0adKECxcusGvXLtavX2/tej1ixAhmz57NkCFD+P333wkNDeXzzz/PMTNKbq5cuUJYWBgxMTFERERQrlw51q9fz44dO3jnnXds1vXy8mLgwIHMnj0bo9HIoEGDCv1dFIWvr6+1u3Xbtm1ZtWoVP/74Iy+++KL1zKp379507NiRl156iePHjxMREcHatWtZtmwZY8aMsf6Y5qZJkyZERUXRqlUrKlWqxM6dO1m8eLFNR57jx49Tp04dhg4dWuB8te+++y779+/nqaeeYvXq1dbZQtasWcOyZcvo1KlTsWbaSEhIoE2bNnTq1InOnTtTrVo1zp49y9dff82ePXsYM2ZMvlUvd955J7GxsfTu3ZsuXboQFxdX5KRcWBEREQwdOpT58+dz6dIlOnTowPbt21m4cCH9+vWjY8eOgKr5GDduHFOnTqVXr17ce++9/PHHH6xatSrHZ+natSs1a9Zk+PDhjB8/HqPRyP/+9z+Cg4P5999/842nV69exMbGct9999GzZ0+OHTvG3LlzadKkiU1pw8/PjyZNmrBo0SIaNmxIpUqVaNq0KU2bNi32Z7SHvn378tJLL5GcnExQUBCgEmK7du2444476N69O+Hh4Vy6dImlS5cSFxdHv379aNGiRb7btbQlWoaeFEblypV55JFH+OCDD9i3b5+1nT4/Xl5evPbaazzxxBN06tSJAQMGcOzYMT799NM82xB37drFF198AajfpQ0bNrBkyRLatWtH165d892fvUt/s2fP5tKlS9aOhitWrLAOuXv66aetbesvvvgi3333HR07dmT06NFcvXqVt99+m2bNmvHII4/YbPPs2bP8+eefjBw5smjBFLo/qpb3TDWapmkmk0mrV6+eVq9ePS0jI0PTNE07cuSINmTIEK1atWqal5eXVqNGDa1Xr17a4sWLbd57/vx5bdSoUVqNGjU0b29vLSwsTBs6dKh1CERuwy6Ksn1N07RDhw5ZuwL//PPPuX6+xMREbeTIkVp4eLjm5eWlVatWTevcuXOO2UdOnDih9enTR/P399eqVKmijR49Wlu9enWBwy5u3LihjR8/XouIiNACAwO1gIAALSIiQvvggw9yXX/79u0aoHXt2jXX13ObgUXTNA3IMbQjtxkqLF2/jxw5onXt2lXz9/fXqlatqk2cOFEzmUw2779y5Yo2duxYrXr16pqXl5fWoEED7e23387RTTv7sIvXXntNa9OmjVahQgXNz89Pa9y4sfb666/bDDf466+/NEB7/vnnc//DZZOWlqbNnDlTa9Wqlebv72/9XocOHZoj7vz+TlklJydrs2bN0rp166aFhYVpXl5eWmBgoHbnnXdqH330kc3nzD5TTVaLFi3SPDw8tNtvv11LTk7OdV95vT+v4yu3bvvp6ena5MmTtTp16mheXl5aeHi49sILL+Toem4ymbTJkydroaGhmp+fnxYVFaX9/fffuc5U8/vvv2tt27bVvL29tZo1a2rvvvtuoYZdmM1m7Y033tBq1aql+fj4aC1atNB++OEHbejQoTbDRTRN03799VetVatWmre3t80QjNyGfRT2M+b1/RZ2Rp3ExETN09NT+/zzz232/dFHH2n9+vWzfi5/f3+tRYsW2ttvv20zvCGv2V80zXaIQkEz1VgcOXJEMxqNRZ5J6IMPPtDq1Kmj+fj4aK1bt9a2bNmS50w1WW+enp5a3bp1tfHjx9vM1lNaLMNmcrtl/b/TNE37+++/rb9VFSpU0B566KFcZ/X58MMPNX9//zyPwbwYNK2Ue1mIQtuzZw/Nmzfns88+Y/DgwXqH4zAffPAB//3vfzly5AhVq1Yt8vuTk5Pp0KEDR44cYcuWLXl2uBEiL8OHD+fgwYNFmt1FOK8WLVoQFRXFjBkzivQ+SYhObNSoUSxcuJAzZ84QEBCgdzgOc//999OgQQPeeOONYm/jzJkztGvXjtTUVLZu3Wq3TheibPj3339p2LAhGzZsKPLwGeFcVq9eTUxMDEePHs1zysW8SEJ0QitWrOCff/7hlVdeYdSoUdaOBEKIsuXChQs2HWWyMxqNRepFKfInCdEJ1a5dm8TERLp168bnn39etMuXCCHchmUMbF5q1aqV78TromgkIQohhJP6/fff8500wM/PT6p47UgSohBCCIGdBuYLIYQQrq50rwbpQsxmM6dOnSIwMNCuc0YKIYReNE3jypUrVK9ePcfkJEISYp5OnTqV46oDQgjhDuLj462X6xM3SULMg6VnZ3x8vHU6J72kp6ezdu1aunbtanP9POE+UlJS2LhxIx07dizUNIDC9TjDcZycnEx4eLj0XM+DJMQ8WKpJg4KCnCIh+vv7ExQUJAnRTXl6elq/Y0mI7smZjmNpBsqdVCILIYQQSEIUQgghAEmIQgghBCAJUQghhAAkIQohhBCAJEQhhBACkGEXQujLZIK4OIzHj1M5IQE6dbJZzunTEBoKkZFgNOobqxBuThKiEHowmeD112HWLLhwAR+gPWD+4ANo3Bi2b4dr126uHxam1o2O1itiIdyeJEQhSltsLIwYARcu5HjJcPq0KhVmd/Ik9O8PkydDgwY3S40gJUkh7EQSohD2lLWqMyRELTt7ViWrtm1h5Ej49NM8357n/CGWq7RNnHhzWeXK6v78+ZvLpCQpRLFJQhTCXmJjYfRoSEgonf1lTYQWJ09CTAwsXixJUYgikl6mQthDbKxKRKWVDPNiKUmOGaNKq0KIQpOEKERJmUyqZGhJRnrTNIiPV1W3QohCk4QoRElt2qR/yTA3uXXOEULkSRKiECURGwsPPKB3FLkLDdU7AiFcinSqEaK4LO2GzlJVamEwqN6mlmEZQohCkRKiEMXhbO2GWWkazJwp4xGFKCJJiEIUR1ycc7YbAgQFQd++ekchhMuRhChEcThzh5XkZOlhKkQxSEIUojicvcPKsmV6RyCEy5GEKERxREZCQIDDNj8HqA34Am2B7Vlemw9EAUGoqd4u5baBL7+UgflCFJEkRCGKyjJfaatWDtn8IuBZYCKwC4gAugFnM19PAboDL+a3kaQkqTYVoohk2IUQRVEK85W+C4wAHsl8Phf4Efgf8DwwJnP5poI2FB9v/+CEcGNSQhSisEphvtI04HfgnizLPDKfby3qxkaNUjELIQpFEqIQhVFK4w7PASagarblVYEzRd1YcrJK4JIUhSgUSYhCFIYDxx2a8GATHfiagfzKHfbfgVz5QohCcduEuGXLFnr37k316tUxGAwsXbpU75CEK3PQuMNY7qM2x+nIJh7ka+5nM2BkKW1t1ksEqhVnB3LlCyEKzW0T4rVr14iIiGDOnDl6hyLcgQPGHcZyHzEsJoEaWZZ6A62YRmtiuQ8AM7ABuLMkO5NxiUIUyG17mfbo0YMePXroHYZwF5GRasJsO1WbmvBgNLNQLZLZz0ufBYYygjdoyFLeR+MaN3udnsm8Hc58/hcQCNQEKuW1w5kz1WeIjrZL/EK4I7dNiEV148YNbty4YX2enJwMQHp6Ounp6XqFZY0h673Qh8ejj2KcMsUu24ojkgTC83h1AJDEBd6mJdACWM3NjjZzgclZ1r478/5TYFgeW9QARo8m4957ZdJvnTjDcSy/IfmThJhp6tSpTJ48OcfytWvX4u/vr0NEOa1bt07vEMq0Glev0tpO2zpNQVWwo4BRLGQQg/jG5pVJmbeiMAAkJLBt+nTON2tWxHcLe9LzOE5JSdFt365AEmKmF154gWeffdb6PDk5mfDwcLp27UpQUJCOkamzunXr1tGlSxe8vLx0jaVM0cyQvBePpJ8xnN+Kocpvdtt0KIXrpFPY9QqrnecfmFs2R6vYGnwq23XbIn/OcBxbar5E7iQhZvLx8cHHxyfHci8vL6dJQs4Ui1syp8OFPyBpC5zdAkk/Q9rFm6+HoxrpLpR8V5HEEUY8J6mBlkvfNgNmwkggEvv2DvW4GotHXOa4xHJ1IeRuqNYVqnUB3yp23ZfInZ7Hsfx+5E8Soijbrp+GkysgYRmc3QwZ12xf9wyAKndBcHuo1BL+8xO8/m6Jd2vEzCxGE8NiDJhtkqIBMwAzGYMx87FdeBjA9y4ITIQrh+DqUXU7ugAwqM9XrSuEdoMqd4LR2377FsIFuG1CvHr1KocPH7Y+P3bsGLt376ZSpUrUrFlTx8iErjQNkvepBJiwDM5vs33duyIER6qSU8jdULE5eGQ5q77VflVO0XzPYmIYzSybDjZhJDCTMUTzvd32BYBZgwm/wOLFENMRzm2HxPVwei1c+hMu/K5u/0wFz3JQrTPUHAA1eoNXOfvGIoQTctuEuHPnTjp27Gh9bmkfHDp0KAsWLNApKqGbS3/Dsc8gYakqHWVVuS2E9YXqPaFCUzDkMzzXzuMRo/meviwjjkhOE0oop4kkzr4lw+zGjIG+x6B6N3Vr8bYqKZ9eB2fWqgR5I+nmSYPRTyXFWoOgencw+jouNiF05LYJMSoqCs3B804KJ5d2CU58DUc+hQs7bi738IaqnVUSrNEb/KsXfpuW8YgnT9ptXlMjZqLYbJdtFSjrzDVRUTeX+4VC3SHqppnh4m6I/179/a4egX+/VTevIAi7TyXHaveAhwzhEO7DbROiKKM0M5zZAEc/hfhYMGeOLTV4Qo1emaWcHuAVWLztG40wa5aaNNuV5TcVncFDtSdWagm3TVHVqCe+gX8XQUoCHFuobgG1ocGTUHe4dMgRbkESonAPaZfh8Hw4OBtS/r25vEIzqPsI1H4IfEPss6/oaNUO98wzqqToigpb9WswQOXW6tZiGiT9opLjia/h2nHY/Tz8ORFqDYAGT0HlNuo9QrggSYjCtV2LhwMz4fBHkHFFLfOqALUfVImwUivH/EBHR0P58nDPPQWv60wMBlXlGxlZjPd6QEikurWYrhLjoTmqBHnsM3Wr1AoajFR/f2POYUxCODNJiMI1XfgD9r8DJxaBlqGWlb8VGj8HtQeVTsePs2cdvw97spwYzJxZ8unbPP2g3iNQdxic3w4H56gq1Qu/w7ZH4c9XoMnzUP8x6YQjXIbbXu1CuKmkX+CnLrC6JRz/UiXDqh0haiXc+5f6kS6tH+BDhwpex5mEhamqXntO8G0wQJW20O4z6JcAzd8Evxpw/ST8/jQsrwv7Z0HGdfvtUwgHkYQoXMOlv2FzH1jXHs6sB4MRag2E7juh80+qo0xptl3FxsKkSaW3v5KaMQOOHXPs1S58g6HJ/0GfI3D7B+AfroZz7BoDy+vAvndzTnwghBORhCic27UTsHUorLxNzShj8IB6j0Hvw3DX16rNqrSZTDB6tN2GXThceDg8/XTpXeXC6AMN/qO+ozbzIKAWpCbCH8+pEuOhuWA2lU4sQhSBJEThnFLPwe9jYUVD1VkDDcL7w717oe1HUK62frHFxdntuogOZzDYp82wOIzeUP9x6H0I2n4MAXUg9Szs+A+sbgFnfir9mITIhyRE4VzMJjgwG1bUU71HzWlQtRN02w6Ri6F8Y70jzH8Mn56yVxmHh9u/zbA4PLyg3nDofQBavaemx7v0F/zUGbZEq/lUhXAC0stUOI8Lv8P2J9Q9QMWWqpNGtXuca2ybnadvs5tvv4UqVVTCDg1VQyuc6WLAHl7Q6Gk1JOOvSXDoQ0j4Hk79CI3Hwq0vFX/CBCHsQEqIQn9pl2HnM7CmjUqGXuXh9g9VqTC0i3MlQ7g5fVt+cQUHwxdfwMsvOz6e8HBYskTNnhMVBYMGqXtnSoZZ+VSG1u9Djz3qslPmNPjnLfihMZz8Qe/oRBkmCVHoR9PgxLfw4y1w8H017VqtB6HXfjUlmLPOk2mZvg1yJkWDQd3mzoWHHoLOnR0Xx8svw8aNju896igVboWOa+Du5VCuPlw/BZt7w69D4IYdLjopRBFJQhT6SD0LW/rCLwNU1/zABtBpHdz1JfhV0zu6glmmb6tRw3Z59rF+hSlNFpXBoEqFkyY5d0mwMAwGCOsN9/4Jt4xTvYiPfw4/3qqutCFEKZKEKErfqVU3h1F4eEOzSeoHsZqLTYMWHQ3Hj6tS2ldf5V5ay680WRJ69Rx1FE8/dRmqLr9AUGNIPQNb+sEvD6oex0KUAkmIovRkXFdthZvuVePSyt8K3XZAs4muO72X0Vhwu11epcniCA52jp6jjlLlDujxhxrgb/BQk4ivvBVOrdE7MlEGSEIUpePiHlhzu2orBGj4jEqGFW/TN67SkrU0OWaMWpatxKhl3vIUHKzGP7prMrQw+qrexV22Qvkmqnp9Uw/Y84oM6BcOJQlROJamqbks17SBy3vBtypErYLWs1Q1WVliKU3OmKF6hWYrMaYFZg45yK+jjrd36cTqDKq0ge6/q1lv0GDva7CxC1w/o3dkwk1JQhSOk3Edtg5Wc1ma06BGHzUBd/Xuekemv2ztj6mrVrF6wQLSvvqq4I46ZYnRV82L2u5L8AyAxI2wqjkkbtI7MuGGZGC+cIxr8RB3nxpXaDBCy3eh4dPON6ZQT5YSI2BOSYF16zD17QsPPKCmh3PWAfZ6qP2gmqjh5xhV0/BTZ2g2BW59QbU1CmEHkhCF/Z2NUz9cqWfBpwq0/w6qRukdlevIkihFFuUbq8kado6Eowvgz5fh4i6483Pw9Nc7OuEG5NRK2NehubChk0qGFZuryzNJMhT24ukPd3wKbT9RQ3biY2FDR7ieqHdkwg1IQhT2YTbBjqfUlQy0DKg5QI0pC6ild2TCHdV7FDqtB+9KcH47rL0DLu/TOyrh4iQhipIz3VAzzhz6EDBAxFR1rUKpxhKOFBIJXbeqad+uHYe17VSnGyGKSRKiKJn0K2qgffwSVYXV/ju49XnpPCNKR1BDlRSrtIP0S/BTVzi6UO+ohIuShCiKLzVJtRcm/gSe5dT4wpr99Y5KlDW+VaDzBlVNr2XAb8Ng37t6RyVckCREUTzX/oX1kXBhp+pJ2nkjVOukd1SirDL6wl1fwS3/Vc//eE5dUkqIIpCEKIru8n5YdxckHwD/mtDlZ6jcWu+oRFln8IAWb0Gzyer57ufh79f0jUm4FBmHKIrmyhH4qZO6ZFPQLdBpLfiH6R2VEDc1mwAenrDnJfjzFTBnqAnkpV1bFEBKiKLwrv2rZgi5fhrKN4V7tkgyFM7p1heh+TT1+O/JahC/lu/U6UJIQhSFdP00bOgM105AYEM1Bsy3it5RCZG3JuPVlIEAe99QJUYh8iEJURQs9Rz8dA9cPQwBtVWPPr+qekclRMEaj4VWmZcc+2equvKKEHmQhCjyl3YJNnaFy/+AXw2VDKWaVLiSRqPUZBEAu8bCiUX6xiOcliREkTdTKmzuBRf/AJ9gVU1arq7eUQlRdE3+T11tBU1dkuzMT3pHJJyQJESRO02DbSMg6RfwKq+SYfnGekclRPEYDNByBtS8H8zpsKUfXNytd1TCyUhCFLnb+wYc/0JdyzByMVS8Te+IhCgZDyPc+RmEREHGFdjYA64e0zsq4UQkIYqc/v1OdVMHaD0bqt2jbzxC2IvRF+5eChVug9Qzah7e9GS9oxJOQhKisHV+B2wdqh43GgMNntQ1HCHszru8mnfXrwYk74etw2SMogAkIYqsrsXD5j5gug7V74UW0/WOSAjH8K8OkZlXaEn4XuY9FYAkRGFhSoO4aFWNVL6pup6hh1HvqIRwnCptVZMAwJ8vwem1+sYjdCcJUSi7n1dXrvCuBB1WgFeQ3hEJ4Xj1R0C9x0Azwy+DpJNNGScJUUDCCjgwQz2+YwGUq61nNEKUrtbvQ6XbIe2CqiXJSNE7IqETSYhl3bV4dUFVUJ1ownrrGY0Qpc/oq9oTfYLV2MTfx+gdkdCJJMSyzJwBvz6ozowrtYbm0rFAlFEB4XDXN4ABjnykak1EmSMJsSz7axIk/QyegerHwOitd0RC6KdaJ2j8rHq8/TFITdI3HlHqJCGWVYmb1Ww0AG0/gsB6+sYjhDOIeE31sk49C9ufkPGJZYwkxLIo4zpsewzQoN5wqDVA74iEcA5GX2j3OXh4qfGJxz7TOyJRiiQhlkV/T1bXNvSrDi3e0TsaIZxLxebQbLJ6vPNpdVFsUSZIQixrLuyCfZkz0Nz+oZrGSghh65b/QpV2ahLw3x6RqtMyQhJiWWJOh23DQTNBzQEQ1kfviIRwTpYrYxj9IXEjHP9S74hEKZCEWJbse0eNs/KuBK3f0zsaIZxbYD1o+op6/Mc4SLusbzzC4SQhlhXJB9UwC1AXSvUN0TUcIVxC42chqBGkJsJfE/WORjiYJMSyYtdYMN+Aal2hzmC9oxHCNRi9odX76vHB9+HiHn3jEQ4lCbEsOLMeTq0Eg6eat9Fg0DsiIVxHaBeoeb+aAHznSOlg48YkIbo7swl2PaceN3gKghrqG48Qrqjlu+AZAEm/wLHP9Y5GOIgkRHd3bCFc+hO8KkCzCXpHI4Rr8g+DppnHz+7/QsY1feMRDiEJ0Z2lX4U/X1aPm74MPpX1jUcIV9ZoDJSrqzrYHJytdzTCASQhurN90+H6aXUQNxyldzRCuDajNzTN7Gn6z1syDMMNSUJ0V9dPw7631ePmb4LRR994hHAHtR+CoMaQdhEOzNQ7GmFnkhDd1f53wZQCldtCeIze0QjhHjyMcNsU9XjfO3DjvL7xCLuShOiOblyAQx+qx00nyDALIewpvL+aADzjys1aGOEWJCG6owPvqV5wFSKgeg+9oxHCvRg84LZX1eMD78H1M/rGI+xGEqK7Sb8CBzPnKb31RSkdCuEI1XtC5TvAdB32z9A7GmEnkhDdzeF5qsE/sKGq2hFC2J/BALe+oB4f+UjGJboJSYjuxJSqGvoBmjyvOgAIIRyjRi8oV0+dgB77TO9ohB1IQnQnRxdC6hnwrwl1HtY7GiHcm8EDGo1Wj/fPVHOdCpcmCdFdaBoc+kA9bjwWPLz0jUeIsqDuMPAKgisH4dRqvaMRJSQJ0V2c36bmLDX6Qt2hekcjRNngFQj1RqjHB6RzjauThOguDs9T9zUfAO+K+sYiRFnScJSqPj2zHi79rXc0ogQkIbqDtEtwYpF6XP8JXUMRoswpVxvCotVjy4QYwiVJQnQHxz5X46HKN4Uqd+odjRBlT73H1P2Jb8CUpm8sotgkIbo6TbtZXVr/CRmIL4QeqnUGv1BIuwCnV+kdjSgmSYiu7txWuLwXjH4y1EIIvXh4qithgIxJdGGSEF3diW/UfXgMeFfQNRQhyrTag9X9yRVqgn3hciQhujLNDPFL1ONaA/SNRYiyruJtakJ9czr8+63e0YhikIToys5theun1MDgavfoHY0Qos4QdS/Vpi5JEqIr+/c7dV+jLxh99I1FCAG1H1RjEs9thavH9I5GFJEkRFeVtbq0Zoy+sQghFL9qEBypHp/8Ud9YRJFJQnRV57dDSgJ4BkJoV72jEUJYVO+p7k/9oG8cosgkIboqa3VpbzV/qRDCOdTITIiJGyH9qr6xiCKRhOiqTmaefYZH6xuHEMJW0C0QUAfMaZC4Qe9oRBFIQnRFKQnqcjMGDzVDhhDCeRgMN0uJ0o7oUiQhuqIzmWedFVvJYHwhnFH1Xur+1I9qekXhEiQhuqLEn9S9lA6FcE5VO4DRX40Tvrhb72hEIUlCdDWadrOEKAlRCOdk9IWqUerx2S03l5tMGDZvhq+/hk2bwGTSIzqRB0mIrubKQbh+Ejy8oUo7vaMRQuQl+C51f+5XAAzff0/Xxx/Hs0sXePBB6NgRateG2Fj9YhQ2JCG6GkvpsEo78PTXNxYhRN4sJ6znfoXYWIwDB+J7/rztOidPQkyMJEUnIQnR1ZzdpO6lulQI51b5djAY4WoCPDMKNI0cVyu1dLgZM0aqT52AJERXYjLB5p/hV+CgnxxAQjgzzwCo2Bz2AydP50yGFpoG8fEQF1d6sYlcSUJ0NiaTamzP1ugeunUrnvXrwsunYQ7Qf5y0PwjhjLIewydqwsVCvu/0aUdGJQrBU+8ARBaxsTB6NCQk3FwWFobHAw9w+7vv5lzf0v6weDFEy4w1Qugut2M4sJDvPXTIISGJwpMSorOIjVXJLeuBBJCQgEdmMpT2ByGcWF7H8BV1V+Dw/IkTYcoUOZZ1JAnRGZhM6qwyjxktDOSSDC1ya3/Io9pVCOEgBRzDFoVKitIUohtJiM5g06acZ5VFZWl/iI1VB1THjjLWSQh7yu9EMy6uwGM43xPbrBISZCiGTiQh6i02Fvr1K/l2vv0Wnn4a+vfPeWDKWCchSia3E83QUBg7ViVHex9bmiZNITowaJrMPJub5ORkypcvz+XLlwkKCnLMTmJjVQIrDQYDhIXBsWNgNJbOPkWhpaSksG7dOrp06YK/v0y44FQsbYN6/FSuXw+d7TfmuFR+11yYlBD1YmlzKC0y1kmIoitk26DDdO8uNTulSBKiXuzRblgcJ0+W/j6FcFWFaBt0qIwMVYskSbFUSELUQ2ws9Oypz77HjpWDS4jCcpbB8g89BBs2SJuig0lCLG2WdsMbN/TZf1KSdLARorBCQ/WOQElNhXvukR7jDiYJsTSZTPD443pHIT3YhCisyEjVGc1QqAETjpeQoE6ov/tO70jckkzd5iiWMUubNqnnUVGqVJj98i96sXSwiYrSOxIhnJfRCLNmqVoVZzJwoDqxfeABvSNxK5IQHSE2VpUEsya/117TL568OEv7iBDOLDoaeveG5cv1juQmsxkGDICdO2HaNL2jcRtSZWpvljZCZykJ5kcmExaiYN9951zJMKu335bqUzuShGhPpT22sKRmz4a0NL2jEMJ5mUwwfLjeUeRv5EjpD2AnkhDtqRTGLG0BegPVUfMiLs32eizQFaic+fru/DaWlATBwdJrTYi8vPoqXLnikE3PAWoDvkBbYHuW11KBkajjuBzQH0jMa0NJSTLhhp1IQrSnUmiTuwZEoA6mvF5vD7xV2A0mJ8vAXyFyExsLkyc7ZNOLgGeBicAu1DHdDTib+fpYYAXwHbAZOAXke8VT6Q9gF9Kpxp5KYcxSj8xbXgZn3h8v6oZHj4a+fWWeUyFAVUE+9pjDNv8uMAJ4JPP5XOBH4H/Af4BPgK+ATpmvfwrcAvwG3JHbBqU/gF1ICdGeLGOWXFFCglS7CGHx0ENw8aJDNp0G/A7ck2WZR+bzrZmvpWd7vTFQM/P1XH30kbQj2oEkRHsyGmHGDLtu0oQHm+jA1wxkEx0wOfIrk2oXIVSvzUWL7LrJrMfxcu7ABFTNtk5V4EzmzRuokMfruZITWrtw+4T4wAMP4OnpicFgoFy5cnz66aeO3WGVKnbbVCz3UZvjdGQTD/I1HdlEbY4Ty31224cNZ5mmSgi9mEzw1FN23WT24/h+lgCwibvtuh85oS05t06Io0eP5rvvvmPIkCEsW7aM8PBwhg8fzt69ex23Uzv9U8ZyHzEsJoEaNstPUoMYFts/KRoM0K6dfbcphKuJi4Nz5+y2udyP4yqAkRcZbXMcJwLVMm9pwKVs27K8nic5oS0xt06In3zyCc2aNeN///sfffr04a+//sJgMPDcc885bqd2aNw24cFoZqGuwGb7FWmZz8cws8T7sd2wBr/+at9tCuFq7FjKyvs49gZaAT8xhpmY8MAMbADuzHzFK/O5xQHg38zXc1W+vOrDIErEbXuZXr16lWvXrtEzy2WWPD09qV27Nnv27MmxfnJyMsnJydbnVzLHHqWkpODpWcg/k8mE77x5GFBjAIsrjkgSCM/j1atoHCY+89kx1FjDSqhG9wuoA+dU5usHMu8tZ575uXH8OKaUlGLHLYovNTXV5l7ow6NiRXzttK38j+NngaHEcztf0JJf2ck1VK/T8sDwzDUqAUHA06hkmGsPUyD9wQdJL8QVdFLk+M6X2ybEgwcPAlCnTh2b5ZUrVyYxMecQ1z59+rB58+Ycyzdu3Ii/v3+h9ll5zx7anzpV8IoFOE1+VR87gY7WZ89m3g8FFgDLudmVG2Bg5v1EYFIB+92RkMD5deuKEKmwtzjpGKEvk4mulSvje/58iU5qoaDjeACQBEzgMRJoCazmZkebGagyZX/gBmqM4gf5bO1SXBy/FuLYlYSYP7dNiEW1fPnyHCXEJk2a0LFjR4KCggp8v3HZMrxnzrRLLKHkV20TBZmVMBuJIgrbJD4s81YUGqDVqEHL0aNlHKJOUlNTiYuLIzIyEl9fe5VRRHF4zJoFDz9c4u3kfxwDjAJGsS6X49gXNflGXhNwZFfl77/p0qEDeHvnu17W3ziRk9smxIYNGwJw7Ngxm+Xnz58nMDAwx/pBQUE2ic/yj+Pv719wCTE2Vo1b0rQSRq1EEkcY8ZykhrXNMCsDZsJIIBL7lCYMgOG99/DP5e8iSpevr2+haySEg9SoUfA6hVCax7EB8F+wQF3nNB8ZGRkl3pc7c9tONeXKlSMgIIAff/zRuiwjI4Pjx48TERFhvx1ZJvS2UzIEMGJmFmqScANmm9csz2cyBmO214qtcmU1S40Qwm4da0r9OD5yxD7bKcPcNiECDB8+nL/++osRI0bwww8/0KxZMzRNY/r06fbbiYMm9I7mexYTQw1O2iwPI4HFxBDN9/bb2fnzMqhXCAs7Dl8o1eP42jX7bauMctsqU4BZs2Zx6tQpPv30Uz7++GMCAgL46KOPaNq0qf124sDBsNF8T1+WEUckpwkllNNEEme/M8qsZFCvEIplCkY7neiW2nG8bp2qsZJ+AMXm1gkR4DtHXzzTwYNhjZhzNLg7REiI4/chhCuwTMF4//3222RpHMeW6duiohy7Hzfm1lWmpcKVJ/QWQuTun3/0jqB4pKanRCQhlpTRCLNm6R1FyZ09W/A6QpQFJpPrHtMyfVuJSEK0h+joArs7Oz05kIRQ4uLgwgW9oyi68HCZvq2EJCHai6sOWzAY5EASIitXrHY0GGDmTOlQU0KSEO0lMhIKMaONUzFkTk4lB5IQN7labUlgICxerGqqRIlIQrQXoxGGDdM7iqIJC5MDSYjsIiPtNluNw3XsCBcvyjFsJ5IQ7ek+B1241xFmzIBjx+RAEiI7oxEee0zvKApWo4Yaeyi1O3YjCdGeXGkIRtWqciAJkReTSe8I8mcwwHvvyTFsZ5IQ7cmVhmC4WjuJEEKpVEmaOhxEEqK9RUfDkiVqwmxnFRYmvUqFyI8zz/by7beSDB1EEqIjREdDYiLYcxJxexoxQqpahMhPVJRzntSGhzt3snZxkhAdxWhUg/XDwm4Ob3AWDRroHYEQzs1ohPnz81+ntIdZyVhDh5OE6EhZ2xSdKSlK+6EQBbM0f2TvKBcWppYnJUFwcOnEEh4u7YalQBKio0VHq3/k7OOaPHT408usNEIUTXQ0HD8OGzfCV1+p++PH1XJvb5g7Vx1XjjjhDQ6GL75Q+5QhUqXC7S//5BSio9XUbnFxalqoxEQYO7Z0Y5BZaYQoHqMx73Y7ywnv6NH2vVC4waCSrSTBUiUlxNJiOagGDVJjAEubzEojhGPkVor89tscVa2atxemwpyMSvWobqSEqAd7tOEFBqr7K1cKXnfGDHj6aSkZCuEouZUio6Nh+WzYMAaqViZjfAIrV66k1549GGfPtr2iRvnyMHSomu0qMlKOVZ1IQtSDZUabkydB0wr1FstahjZAF0+YeBY0D7WdpKTc32QwqNclGQpR+oxGaHgdrgPhHdVzoxHzyy9jnDDhZhNKaKgkQSchVaZ6yK/3qeV5tjFQ16tUwbToG3guEJpkwLVD+TfqS5uhEPo796u6D25nuzxrE0pUlByjTkISol7y6n1q6dKdmGhtk8hYt4518+ah3RcNFZur9c7vLHg70g4hhH407WZCrNIu/3WFU5AqUz1l732aveoks01CS0+HlSvVsuC7ICkOzm6Ceo8UbjtCiNJ35RDcOA8ePlCxBZj1DkgURBKi3vLr0p2bqp3gnzfhzAZ1BmqpGi3qdoQQjmUpHVa+HYzeYE7XNx5RIKkydTXBd4GHN1w/CVcO6h2NECIvSb+oe6kudRmSEF2Np//NAyzxJ31jEULkLXGTus/eoUY4LUmIrqhaZ3V/ZoO+cQghcpd8EK4eBg8vqNpR72hEIUlCdEVVMxNi4kbQpKVeCKdz6kd1H3w3eJXyVTFEsUlCdEWVW4NnOUi7ABd36x2NECK7kz+o+xq99I1DFIkkRFfk4aV6mwIkLNc3FiGErfRkOLtFPa7eU99YRJFIQnRV4f3VffxifeMQQtg6vQ60DAhsCEFyMW5XIgnRVYX1USXFy3vh8j69oxFCWJzKrC6V0qHLkYToqrwrQLUu6vG/UkoUwimYM+BU5qxS0n7ociQhurLwGHUv1aZCOIcz6yD1LPhUgZBIvaMRRSQJ0ZWF9QWDJ1z6U417EkLo69jn6r7WINWkIVyKJERX5lPp5iB9KSUKoa/0ZEj4Xj2uM0TfWESxSEJ0dTXvV/fHPi/0xYaFEA7w72IwpUJQY6jUSu9oRDFIQnR1Ne8HzwBI3q8uCyWE0IelurTOkJwX7BYuQRKiq/MKgloPqseH5ukbixBl1bUT6hqlGKD2Q3pHI4pJEqI7qP+4uo9fDKnn9I1FiLLIUjqsGgUBNXUNRRSfJER3ULk1VGwJ5jQ4tlDvaIQoW0xpcOhD9bjuI/rGIkpEEqK7aPCEuj88XzrXCFGa4hfD9VPgWw1qDtA7GlECkhDdRa1B6goYVw7C2c16RyNE2aBpsH+GetxwJBi99Y1HlIgkRHfhFXizMf/ATF1DEaLMOPcrXNgJHj5Q/wm9oxElJAnRnTQaAxggYRlc+lvvaIRwf/tnqvs6g8E3WNdQRMlJQnQn5RvfvCzU3qn6xiKEu7t6HBJi1eNGo3UNRdiHJER3c+uL6v7fb+DKEX1jEcKdHZgFmllddaZCU72jEXYgCdHdVGoBoT3UgfrPW3pHI4R7SjkFh+eqx42f0zcWYTeSEN2RpZR4bAGknNQ1FCHc0t7X1bylwe0htKve0Qg7kYTojkLaQ8jdYE6HfdP1jkYI93L1OBz5SD2+7TWZt9SNSEJ0V00yS4mHPlTzLAoh7OPvKepks1oXqNpB72iEHUlCdFehXSGkA5hvwO4X9Y5GCPeQfODm9Ii3vapvLMLuJCG6K4MBWr6jHp/4Cs7v0DceIdzBX5NUh7UavaFKW72jEXYmCdGdVWoFtQerx7uekzlOhSiJ8zvhxDfqsZQO3ZIkRHcX8ToY/dTFgxOW6h2NEK5JM8OOp9Tj2g9DxQh94xEOIQnR3QWE3xwn9cd/1aVqhBBFc+QTuLBDXZC7xdt6RyMcRBJiWdDkv+BbFa4ehoOz9Y5GCNdy4zzsfl49bjYF/KrpG49wGEmIZYFXoKo6BfjzFTWOSghROHtehLQLUKGZusSTcFuSEMuKuo+owfqmFNj+hHSwEaIwzm2Hw5mD8FvPAQ9PfeMRDiUJsawweECbj9R1286shWOf6R2REM7NbIKdIwEN6gyBkEi9IxIOJgmxLAlqCLdNVo93jYXrifrGI4Qz2zdNXfzXqzw0n6Z3NKIUSEIsaxo/BxVbQNpF+P0ZvaMRwjld3A1/TVSPW80Cv6q6hiNKhyTEssbDE9p+AgYj/PstJCzTOyIhnIspFX59WM1XGnafqi4VZYIkxLKoUgu4Zbx6vG2EurabEELZ8zJc3quGKrWZJ1ezKEMkIZZVzSZChQi4kQRbH1YdCIQo6xI3wf531eO2H4NvsK7hiNIlCbGsMvpC+0XgGQCJG2HvG3pHJIS+0i7D1qGABvVGQI1eekckSpkkxLIsqBHc/qF6/PckSNysazhC6EbTYNujkPIvlKsLLd/VOyKhA0mIZV2dwVBnqJq8+NcHITVJ74iEKH37pkF8LHh4Qbsvwauc3hEJHUhCFNB6tiotXj8Fvw1TyVGIsuL0OjU9G0Cr96HKHfrGI3QjCVGos+G7vlWz2JxaCX9N1jsiIUrH1ePw6yB1ElhvONR/XO+IhI4kIQql4m1Z2hOnwPGv9I1HCEfLuA5x/dXVLCq1VjUlMsSiTJOEKG6q98jN8Ym/PQpJW/WNRwhH0TTY+RRc3AU+VSByiep5Lco0SYjCVsRUqNEHzDcgrh9cO6F3RELY3z9vwtEFatL7uxZBQE29IxJOQBKisOVhVL3sKkRA6lnY1AvSk/WOSgj7OfLpzU40LWdCtU66hiOchyREkZNXOeiwAnyrweW/4ZdBYM7QOyohSu7kj7B9hHrc5P+g0dP6xiOciiREkbuAcOiwXLWrnFqp2hRlOIZwZee2wc/3g2ZSE3ZHTNU7IuFkJCGKvFW+XbWvGIxw/HPY8ZTqjCCEq0k+AJt7guk6hHZX85RKj1KRjSREkb+wPnDnF4ABDs+DXc9JUhSuJSUBNnbLHF5xO7T/Ts1II0Q2khBFwWoPVNdQBDgwA/6coG88QhTWtROw7m51X64+RP0o07KJPElCFIVT7xE1cBlg72uw90194xGiIFePwvoOcO0YlKsHnTfI5ZxEviQhisJrOBKaT1OP97wA/7ylbzxC5OXK4cxkeAICG8A9m2WsoSiQJERRNE3GQ7NJ6vHu5+GP8dKmKJxL8gGVDFMSIKixSob+NfSOSrgASYii6JpNhBbT1eN909V15GSconAGl/+B9VHqyi3lb4XOm8AvVOeghKuQhCiK55bn4I4FakjG0QVqkuSM63pHJcqyxM2wrj2knoEKt0HnjeBXVe+ohAuRhCiKr+5QiIxVl406uRw2dYe0y3pHJcqiY1/Axi6QdhEqt4XOP0kHGlFkkhBFyYT1gU5rwSsIzm7J7Mjwr95RibJC0+CvKbB1MJjTITxGlQx9KusdmXBBkhBFyYXcrTou+FaFS3tgze1wNk7vqIS7M6XBb4/AXxPV81v+C+0XgaefvnEJlyUJUdhHxebQbZu6Tz0LGzrBobl6RyXcVdpFVUV/bKFqx759LrR4S13OSYhikv8eYT8BtaDLL1BzAGgZsOM/sP0JdSYvhL2c3wGrWkLiRvAMhA4/QIMn9I5KuAFJiMK+PP3hrq+h+Zuo+U/nw0+d4Hqi3pEJV6dpcHCO6kl67TiUqwtdfobq3fWOTLgJSYjC/gwGda25Dj+AV3lI+gVWt4QzP+kdmXBV6cnwy0DYOQrMaRB2H3T/HSrepndkwo1IQhSOU+Ne6LYdgm5RA6V/6qxmtjHd0DsyfZlMsGkTfP21ujeZHPs+V3dxD6xuDf9+CwZPaDkDIpeAdwW9IxNuxlPvAISbC2oI3Xeoy0YdnqdmtjmzHtp9BeVv0Tu60mMyQVwcLFsGX3wB587dfC0sDOO0aeDvn//7vvwSkpJs3sesWRAd7fj49aCZ4dCH8Mc4MKWCfzi0/xaq3KF3ZMJNSQlROJ5nALSZC3cvBZ8qcHG3qkI9+EHZmAc1NhZq14aOHWHmTNtkCJCQgPdDDxG6dWv+78uaDAFOnoSYGLWeu7l6FDZ0VlWkplSofi/0+EOSoXAoSYii9IT1hXv/hNBu6kdu50jY3EtNwuyuYmNV0koo4DNqGhFz5qgSockEU6ZA//75v89yMjFmjPtUn2pmOPA+/NgMzm4Coz+0eg86rJDB9sLhJCGK0uUXClErodUsNeXbqZXwwy2wf6b7TRBuMsHo0YUqBRsAn6tX8bnjDqhVCyZOLNw+NA3i41W1qqu7clhNzP37M2BKgZAo6PkXNHpaxheKUiH/ZaL0GTyg0TPQfSdUuRMyrsKusbCmDZzbrnd09hMXV3DJMBvjP/+oqtCiOn266O9xFuZ02PcurLwNkuJUFXvrOeqCvuXq6h2dKEOkU43QT4WmahzZkU9g9//BxT9g7R3Q4D8Q8brr9SK0dIA5eVK19x06VHr7DnXRSxydWgW7noXk/ep51c7Q9mMoV1vXsETZJAlR6MvgAfVHqPbFP8bDsc/g0AcQvwSaT4PaD4GHUe8oCxYbq6pHi1gitIuwMIiMLP39lsTl/SoRnl6lnvsEQ8QbUG+4GscqhA6kylQ4B98QuHOhumxPUCNITYTfhsLqFnDyR+fujVrYjjOOcv26GpbhCtIuwu9jYWUzlQw9vKDxc9D7ENR/TJKh0JUkROFcqnaEHnug+VvgVQEu/aV6oq6/W81442yK0HHGYc6fVz1Sv/tOvxgKkpGiOk6taAAHZqq5bmv0hnv3Qsvp4F1e7wiFkIQonJDRB5r8F/oeVZf0MfpC0s9qDsvNfVSSdBbF6DjjMAMHwuLFekdhK+Ma7HsHltdVHadunIfyTaDjGuiwHIIa6B2hEFaSEIXz8q6oLunT+xDUG6Eu83NyBayMgLj7naNHqjP17jSb4f77nWOgfvpV+OctWFZbzTSTmggBtaHNfFUDENpV7wiFyEESonB+/mHQdj7c+zeE9wc0iF8Ma9vC+g5w8gc1oFsPISH67Dc/o0frN1A/7SLsfQOW14bdz8ONc2roRNtPoPdB1YHKQ/ryCeck/5nCdZRvDJGL4eKfsP8dOP4VnN2ibkG3wC3PqV6pRt/SiSc2FkaMKJ19FUVCgqrKjYoqvX1e3K0uzXT8SzBdV8vK1YemL2f2FJafGuH85L9UuJ6Kt6keqRGvq2m+Ds+F5H2w7THY85Lqul/3EQis77gYYmNVRxZnVRpVuaYb8O9iODQHzmWZh7V8U3X5r1oDJREKlyJVpsJ1+YepNsZ+8dDiHXU1hNREVWW3ogGsuxuOfKras+zJ0rPUQbYAvYHqqCndlmZ7XQMmAKGAH3APkGMKgDVrHFdteuWwOvFYGg5bH1bJ0OAJNQfAPVvUfLV1HpZkKFyOJETh+ryC4JZnoc8RdXmg0B5qwH9SHGx7FL6vBr89oqpW7TE8wsE9S68BEcCcPF6fBrwHzAW2AQFANyA160oLF6orZdirg821eNVbdHVrdbKx9w24kQR+NaDZFOj3L7T/BkIiZSyhcFlyCifch4cX1Lxf3VJOqllvjn4KVw7B0QXq5h8GNfpAWD8I6QBG76Lvx8HVkT0yb7nRgJnAy0DfzGWfAVVRJcmBWVdOSFATBixeXLxrJl5PVJ2XTnyjhr1YGIxqirX6j0NYH/V3F8INSEIU7sm/Btz6AjR5Xg3oP/qpuuJ6SoKaGu7QB6pkWf1elRyr91DPC0PHnqXHgDOoalKL8kBbYCvZEiKoEvGYMdC3LxgLmAJPM6v5ZE+vgdNrVQk7a+/dkLtVu2B4fzWzkBBuRhKicG8GA4S0V7fb58CZDZCwVI1nTE1UpZ8T36hSTnCkKjWG3A2V24Knn97R53Am875qtuVVs7yWg+XyULn1Ok05CWfWqSR4Zr0aJpFVpdtVEqz1gCpdC+HGJCGKssPoCzV6qptmhnPb4OQySFimrraQ+JO6gUqQldtA8N0qQQa3u1mCPHvWrmGZ8CCOSE4TSiiniSQOI3YeV3nyJJjS4NKfcGEHnN8B57fB5X9s1/MMhGqdoFpXqN5dLr8kyhS3TYivv/46P/74I7t378bb25tLly7pHZJwJgYPCL5T3Zq/CckHVDK0jGu8fkpVtSb9Av9MBQxQrh5UaAZxF+wWRiz3MZpZJBBuXRZGPLMYTTTf51i/WuZ9IqqXKVmeN89vR1teAOOjYE7L9oIBKrWG0G5q9pgqd0iboCiz3DYhpqWlcf/993PnnXfyySef6B2OcHZBjdStwX9Uu9vVo6oNzZIgrx6Bq4ch+TAsss8uY7mPGBaTvd/rSWoQw2IWEwPZkmIdVFLcwM0EmIzqbfqf/HZ2Ih7MqOnwKt0OlTNvwe3Bp7IdPo0Qrs9tE+LkyZMBWLBggb6BCNdjMEBgPXWrO0wtu54Il/+Ctd/DhQ9KvAsTHoxmVmYytB39pJECHOQpRgDfcwzYDVQCagJjgNeABqgE+QpqzGK//Hb4sw98swfKN5RhEULkwW0TYlHduHGDGzduWJ8nJycDkJ6eTnp6ul5hWWPIei904FkJKnfAYDiNJyVPiHFE2lST2toJdCQx89mzmfdDgQXAf1FjFR8HLgHtgdVAvhPWXbtBxvYTaB2lTVAvznAcy29I/iQhZpo6daq1VJnV2rVr8ff31yGinNatW6d3CGVe5RMnaG+H7Zy2aQHMLgoyy45fMYhBfGPzqgGYknkrisMff8yB69eL+C5hb3oexykpKbrt2xW4VEJ8/vnneeutt/JdZ9++fTRu3LjI237hhRd49tlnrc+Tk5MJDw+na9euBAUVcnyag6Snp7Nu3Tq6dOmCl5d0eNBVt25ob76J4dq1Em0mlMIN7i/seoXRoH596t17r922J4rGGY5jS82XyJ1LJcTnnnuOYcOG5btO3brFqxLy8fHBx8cnx3IvLy+nSULOFEuZ5eUFTZrAjh0l2kwkcYQRz0lqoOUyg6IBM2EkEElcifaTlbFzZ4zy/6M7PY9j+f3In0slxODgYIKDg/UOQ5R1jRqVOCEaMTOL0cSwGANmm6RoyByDOJMx9huPGBRUupeDEsIFue3k3v/++y+7d+/m33//xWQysXv3bnbv3s3Vq3a+8oEoewYPtstmovmexcRQg5M2y8NIYDExuY5DLLahQwueuk2IMs6lSohFMWHCBBYuXGh93qJFCwA2btxIlJwpi5Lo3BnKlQM7nFxF8z19Web4mWrMdt6eEG7IbRPiggULZAyicAyjUV1eyU4XCDZiJorNdtlWnuxx2Ssh3JzbVpkK4VDR0TBxot5RFF6DBnpHIITTk4QoRHG1a6d3BIVjNMJTT+kdhRBOTxKiEMUVZ78hEQ717LPgXYwLIQtRxrhtG6IQZZ7RqJLhtGl6RyKES5ASohDF5cy9lZ98ElJSJBkKUQSSEIUorqgoqOykl066+26pJhWiiCQhClFcRiPMn693FLkLzW/ycCFEbiQhClES0dHw3XfOMwuMwQDh4RAZqXckQrgcSYhClFRMDHz9td5R3DRzpvMkaCFciCREIezh/vthyRIIC9M3jkmTVKlVCFFkMuxCCHuJjoa+fdX4xJMnISkJzpyBAq7haVcyI40QxSYJUQh7Mhpth2OUdlWqdKYRotgkIQrhSKWVoAwGVV0rnWmEKDZpQxTCkSIjVaIyGBy/L+lMI0SJSEIUwpGMRpg1Sz12VFIMDobFi6UzjRAlJAlRCEeLjlYJq0YN+287OBgSEiQZCmEH0oYoRGnI2gP19GkICVHLf/gBPvkErlyxXb9yZTULjskEDzyQc3uW0ubcuTJFmxB2IglRiNKSvQcqQOfOMH06qatXc2LhQurUrYt3ly5qPUt74JIlMHq0KglahIWpNkMpGQphN5IQhdCb0Yi5Y0f2Z2QQ3qUL3v7+tq9nL12GhqrOOtKBRgi7koQohCvIrXQphLAr6VQjhBBCIAlRCCGEACQhCiGEEIAkRCGEEAKQhCiEEEIAkhCFEEIIQIZd5EnTNACSk5N1jgTS09NJSUkhOTkZLy8vvcMRDpCSkmL9jjMyMvQORziAMxzHlt8zy++bsCUJMQ9XMqfSCg8P1zkSIYSwrytXrlC+fHm9w3A6Bk1OFXJlNps5deoUgYGBGErj0j35SE5OJjw8nPj4eIKCgnSNRTjGyZMnadKkCf/88w81HDEJuNCdMxzHmqZx5coVqlevjoeHtJhlJyXEPHh4eBAWFqZ3GDaCgoIkIbopS1VWYGCgfMduTu/jWEqGeZNTBCGEEAJJiEIIIQQgCdEl+Pj4MHHiRHx8fPQORThIUFAQHTp0kOpSNybHsfOTTjVCCCEEUkIUQgghAEmIQgghBCAJUQghhAAkIQohhBCAJEQhhBACkIQohK4yMjJIS0vTOwwhBJIQXYrJZNI7BGFHy5cvp0GDBlSrVo1bb72VefPm6R2SsDM5Zl2LJEQXkJiYCIDRaJQDzE2sWrWKvn37YjabadSoEUePHuXZZ5+lf//+eocm7OTgwYPMnDmT06dP6x2KKCRJiE5u//79hIeH06dPH0CSojswm8289tprhIeHc+LECbZu3cqRI0do164dq1at4t5779U7RFFChw8f5s4772T8+PG8//77nDt3Tu+QRCFIQnRip0+fZvjw4bRq1Yq9e/daSw+SFF2bh4cHZ8+etbn4dPXq1Vm4cCGdO3dm8+bNPPXUUzpGKEri2rVrTJ06lT59+jB79mzefPNNpk2bJknRBUhCdGKbNm2iWrVq1gNq165dNklRrqzuesxmMwARERGYzWZWrVplfa169eq899571KxZky+++EJ+QF2Uh4cHrVq1onv37jz11FN88803TJ8+XZKiK9CE07p27Zq2bNkyTdM0LT09Xfv222+12rVra9HR0dZ1MjIy9ApPlMCGDRs0g8GgNWjQQDt9+rSmaZpmMpk0TdO03377TQO0V199Vc8QRQlcvXrV5vk333yjGQwGbdy4cdq5c+c0TVPf99GjR/UIT+RBSohOymw24+/vb2079PT0pHfv3rz99ts5SoofffQRhw4d0jNcUUSdOnVi+vTpHDp0iK5du3LgwAHrFcz9/Pzw9fUlJCRE5yhFcQUEBACql6mmaQwYMICvvvqKd955h7feeotTp04xbtw4xo0bR0pKis7RCgtPvQMQubP8OGbl6+tLz549MRgMjBs3jpiYGMLCwnjvvfc4cuSIDlGKknj22We5ePEir732Gp06dSImJoYuXbrw+uuvk5aWRosWLfQOUZSQ0WhE0zTMZjMDBw7EYDAwePBgli9fzpEjR9ixYwf+/v56hykyyeWfnFhGRgaenjfPWTRNw2AwkJqayrJlyxg0aBAVK1Zk3bp1tGzZUsdIRUl8+eWXjBw5kqtXr2IwGDAYDCxcuJBBgwbpHZqwE8vPrMFgoHPnzuzevZtNmzbRrFkznSMTWUkJ0UmZTCY8PT05fvw4mzdvZujQoRgMBkCVFNevX4+/vz9xcXE0adJE52hFSTz00EN06NCB48ePk5iYSNOmTWnUqJHeYQk7MhgMmEwmxo8fz8aNG9m9e7ckQyckCdEJWUqGx48fp1GjRgwcOJChQ4daX1+5ciWbN29m8+bNkgzdRFhYGGFhYXqHIRzs1ltvZdeuXdx22216hyJyIVWmTiZrMmzZsiX33Xcf8+bNs6k6vX79OpcvX6ZatWo6RiqEKCpLs4dwTpIQnUj2ZNinTx8+/vhjm2RoNptz7XAjhBCiZCQhOgmTyYTRaMw3GQohhHAcKWo4CaPRyIkTJ7j11lvp168fn3zyiSRDIYQoRVJCdBImk4nHH38cg8HA3LlzJRkKIUQpk4ToRC5evEj58uWljVAIIXQgCVEIIYRA2hCFEEIIQBKiEEIIAUhCFEIIIQBJiEIIIQQgCVEIIYQAJCEKIYQQgCREIYQQApCEKIQQQgCSEIUQQghAEqIQQggBSEIUQgghAEmIQgghBCAJUQghhADg/wGhQszL9f7KFgAAAABJRU5ErkJggg==",
       "text/plain": [
        "<Figure size 400x400 with 1 Axes>"
       ]
@@ -492,7 +318,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 400x400 with 1 Axes>"
       ]
@@ -503,18 +329,14 @@
    ],
    "source": [
     "# QPSK\n",
-    "SNR_list =np.linspace(-10, 10, 100)\n",
     "symbol_error_rate = []\n",
+    "bit_error_rate = []\n",
     "\n",
-    "symbols = np.zeros(10**2)\n",
-    "for i in range(10**2):\n",
-    "    symbols[i] = np.random.randint(0, 4)\n",
-    "    \n",
-    "QPSK_symbols = []\n",
-    "for i in symbols:\n",
-    "    QPSK_symbols.append(QPSK[int(i)])\n",
-    "    \n",
-    "print(QPSK_symbols[1])\n",
+    "symbols = np.random.randint(0, len(QPSK), size=(num_symbols))\n",
+    "\n",
+    "QPSK_symbols = np.zeros((num_symbols, 2), dtype=float)\n",
+    "for i, s in enumerate(symbols):\n",
+    "    QPSK_symbols[i] = QPSK[s]\n",
     "\n",
     "for SNR_dB in SNR_list:\n",
     "\n",
@@ -522,274 +344,93 @@
     "\n",
     "    signal_power = np.mean(np.abs(QPSK_symbols)**2)\n",
     "    noise_power = signal_power / SNR_linear\n",
-    "    num_symbols = len(symbols)\n",
     "\n",
-    "    noise_x = noise_power * np.random.normal(0, 1, len(QPSK_symbols))\n",
-    "    noise_y = noise_power * np.random.normal(0, 1, len(QPSK_symbols))\n",
-    "    QPSK_x = [x for x, y in QPSK_symbols]\n",
-    "    QPSK_y = [y for x, y in QPSK_symbols]\n",
-    "    rx_signal = list(zip(QPSK_x + noise_x, QPSK_y + noise_y))\n",
+    "    noise = noise_power * np.random.normal(0, 1, size=(num_symbols, 2))\n",
+    "    rx_signal = QPSK_symbols + noise\n",
     "\n",
-    "    detected_idx = np.zeros(num_symbols, dtype=int)\n",
+    "    distances = np.zeros(len(QPSK), dtype=float)\n",
+    "    detected_symbols = np.zeros((num_symbols, 2), dtype=float)\n",
     "    for i, r in enumerate(rx_signal):\n",
-    "        distances = [np.linalg.norm(np.array(r) - s) for s in QPSK]\n",
-    "        detected_idx[i] = np.argmin(distances)\n",
-    "\n",
-    "    detected_symbols = []\n",
-    "    for i in detected_idx:\n",
-    "        detected_symbols.append(QPSK[int(i)])\n",
-    "\n",
+    "        for j, s in enumerate(QPSK):\n",
+    "            distances[j] = np.linalg.norm(r - s)\n",
+    "            \n",
+    "        detected_symbols[i] = QPSK[np.argmin(distances)]\n",
+    "    \n",
     "    errors = 0\n",
-    "    for i in range(len(QPSK_symbols)):\n",
-    "        if QPSK_symbols[i] != detected_symbols[i]:\n",
+    "    bit_errors = 0\n",
+    "    for i in range(num_symbols):\n",
+    "        if QPSK_symbols[i][0] != detected_symbols[i][0] or QPSK_symbols[i][1] != detected_symbols[i][1]:\n",
     "            errors += 1\n",
+    "            code = \"\"\n",
+    "            expected_code = \"\"\n",
+    "            for k, v in g_QPSK.items():\n",
+    "                if v[0] == QPSK_symbols[i][0] and v[1] == QPSK_symbols[i][1]:\n",
+    "                    expected_code = k\n",
+    "                elif v[0] == detected_symbols[i][0] and v[1] == detected_symbols[i][1]:\n",
+    "                    code = k\n",
+    "                \n",
+    "                if code != \"\" and expected_code != \"\":\n",
+    "                    break\n",
+    "                    \n",
+    "            bit_errors += diff_letters(code, expected_code)\n",
+    "        \n",
     "    SER = errors / num_symbols\n",
-    "\n",
-    "    print(\"errors: \", errors)\n",
-    "    print(\"QPSK Symbol error rate (SER): \", SER)\n",
     "    \n",
+    "    BER = bit_errors / num_symbols\n",
+    "    \n",
+    "    # print(\"errors: \", errors)\n",
+    "    # print(\"QPSK Symbol error rate (SER): \", SER)\n",
+    "    \n",
+    "    # Make the plot for specific SNR_dB\n",
+    "    if SNR_dB == 10:\n",
+    "        r_x = [x for x, y in rx_signal]\n",
+    "        r_y = [y for x, y in rx_signal]\n",
+    "\n",
+    "        x = [x for x, y in QPSK]\n",
+    "        y = [y for x, y in QPSK]\n",
+    "\n",
+    "        plt.figure(figsize=(4, 4))\n",
+    "        plt.title(\"Recieved symbols, QPSK modulation (SNR_dB = 10)\")\n",
+    "        plt.plot(np.cos(circle_x), np.sin(circle_x), color=\"orange\")\n",
+    "        plt.plot(r_x, r_y, 'o', color=\"red\")\n",
+    "        plt.plot(x,y,'o', color=\"blue\")\n",
+    "        plt.xticks(x, rotation=45)\n",
+    "        plt.yticks(y)\n",
+    "        plt.grid(True)\n",
+    "        for (k, s) in g_QPSK.items():\n",
+    "            plt.text(*s, k)\n",
+    "        \n",
     "    symbol_error_rate.append(SER)\n",
+    "    bit_error_rate.append(BER)\n",
     "\n",
-    "r_x = [x for x, y in rx_signal]\n",
-    "r_y = [y for x, y in rx_signal]\n",
-    "\n",
-    "x = [x for x, y in QPSK]\n",
-    "y = [y for x, y in QPSK]\n",
-    "\n",
+    "# Final curve plot\n",
     "plt.figure(figsize=(4, 4))\n",
-    "plt.title(\"QPSK\")\n",
-    "plt.plot(r_x, r_y,'o', color=\"red\")\n",
-    "plt.plot(x,y,'o', color=\"blue\")\n",
-    "\n",
-    "plt.figure(figsize=(4, 4))\n",
-    "plt.title(\"QPSK symbol error rate\")\n",
-    "plt.plot(SNR_list, symbol_error_rate, 'o', color=\"blue\")"
+    "plt.title(\"QPSK modulation error rate\")\n",
+    "plt.plot(SNR_list, symbol_error_rate, 'o-', color=\"blue\")\n",
+    "plt.plot(SNR_list, bit_error_rate, 'o-', color=\"red\")\n",
+    "plt.legend([\"Symbol error rate\", \"Bit error rate\"])\n",
+    "plt.xlabel(\"SNR (dB)\")\n",
+    "plt.ylabel(\"Error rate\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 633,
+   "execution_count": 70,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "errors:  86\n",
-      "PSK8 Symbol error rate (SER):  0.86\n",
-      "errors:  80\n",
-      "PSK8 Symbol error rate (SER):  0.8\n",
-      "errors:  88\n",
-      "PSK8 Symbol error rate (SER):  0.88\n",
-      "errors:  90\n",
-      "PSK8 Symbol error rate (SER):  0.9\n",
-      "errors:  83\n",
-      "PSK8 Symbol error rate (SER):  0.83\n",
-      "errors:  82\n",
-      "PSK8 Symbol error rate (SER):  0.82\n",
-      "errors:  86\n",
-      "PSK8 Symbol error rate (SER):  0.86\n",
-      "errors:  82\n",
-      "PSK8 Symbol error rate (SER):  0.82\n",
-      "errors:  81\n",
-      "PSK8 Symbol error rate (SER):  0.81\n",
-      "errors:  84\n",
-      "PSK8 Symbol error rate (SER):  0.84\n",
-      "errors:  79\n",
-      "PSK8 Symbol error rate (SER):  0.79\n",
-      "errors:  82\n",
-      "PSK8 Symbol error rate (SER):  0.82\n",
-      "errors:  85\n",
-      "PSK8 Symbol error rate (SER):  0.85\n",
-      "errors:  81\n",
-      "PSK8 Symbol error rate (SER):  0.81\n",
-      "errors:  77\n",
-      "PSK8 Symbol error rate (SER):  0.77\n",
-      "errors:  80\n",
-      "PSK8 Symbol error rate (SER):  0.8\n",
-      "errors:  79\n",
-      "PSK8 Symbol error rate (SER):  0.79\n",
-      "errors:  83\n",
-      "PSK8 Symbol error rate (SER):  0.83\n",
-      "errors:  83\n",
-      "PSK8 Symbol error rate (SER):  0.83\n",
-      "errors:  75\n",
-      "PSK8 Symbol error rate (SER):  0.75\n",
-      "errors:  77\n",
-      "PSK8 Symbol error rate (SER):  0.77\n",
-      "errors:  77\n",
-      "PSK8 Symbol error rate (SER):  0.77\n",
-      "errors:  73\n",
-      "PSK8 Symbol error rate (SER):  0.73\n",
-      "errors:  75\n",
-      "PSK8 Symbol error rate (SER):  0.75\n",
-      "errors:  68\n",
-      "PSK8 Symbol error rate (SER):  0.68\n",
-      "errors:  81\n",
-      "PSK8 Symbol error rate (SER):  0.81\n",
-      "errors:  74\n",
-      "PSK8 Symbol error rate (SER):  0.74\n",
-      "errors:  73\n",
-      "PSK8 Symbol error rate (SER):  0.73\n",
-      "errors:  74\n",
-      "PSK8 Symbol error rate (SER):  0.74\n",
-      "errors:  73\n",
-      "PSK8 Symbol error rate (SER):  0.73\n",
-      "errors:  82\n",
-      "PSK8 Symbol error rate (SER):  0.82\n",
-      "errors:  60\n",
-      "PSK8 Symbol error rate (SER):  0.6\n",
-      "errors:  69\n",
-      "PSK8 Symbol error rate (SER):  0.69\n",
-      "errors:  67\n",
-      "PSK8 Symbol error rate (SER):  0.67\n",
-      "errors:  71\n",
-      "PSK8 Symbol error rate (SER):  0.71\n",
-      "errors:  61\n",
-      "PSK8 Symbol error rate (SER):  0.61\n",
-      "errors:  67\n",
-      "PSK8 Symbol error rate (SER):  0.67\n",
-      "errors:  65\n",
-      "PSK8 Symbol error rate (SER):  0.65\n",
-      "errors:  62\n",
-      "PSK8 Symbol error rate (SER):  0.62\n",
-      "errors:  58\n",
-      "PSK8 Symbol error rate (SER):  0.58\n",
-      "errors:  57\n",
-      "PSK8 Symbol error rate (SER):  0.57\n",
-      "errors:  62\n",
-      "PSK8 Symbol error rate (SER):  0.62\n",
-      "errors:  53\n",
-      "PSK8 Symbol error rate (SER):  0.53\n",
-      "errors:  58\n",
-      "PSK8 Symbol error rate (SER):  0.58\n",
-      "errors:  58\n",
-      "PSK8 Symbol error rate (SER):  0.58\n",
-      "errors:  55\n",
-      "PSK8 Symbol error rate (SER):  0.55\n",
-      "errors:  55\n",
-      "PSK8 Symbol error rate (SER):  0.55\n",
-      "errors:  49\n",
-      "PSK8 Symbol error rate (SER):  0.49\n",
-      "errors:  44\n",
-      "PSK8 Symbol error rate (SER):  0.44\n",
-      "errors:  48\n",
-      "PSK8 Symbol error rate (SER):  0.48\n",
-      "errors:  43\n",
-      "PSK8 Symbol error rate (SER):  0.43\n",
-      "errors:  43\n",
-      "PSK8 Symbol error rate (SER):  0.43\n",
-      "errors:  36\n",
-      "PSK8 Symbol error rate (SER):  0.36\n",
-      "errors:  39\n",
-      "PSK8 Symbol error rate (SER):  0.39\n",
-      "errors:  35\n",
-      "PSK8 Symbol error rate (SER):  0.35\n",
-      "errors:  26\n",
-      "PSK8 Symbol error rate (SER):  0.26\n",
-      "errors:  30\n",
-      "PSK8 Symbol error rate (SER):  0.3\n",
-      "errors:  30\n",
-      "PSK8 Symbol error rate (SER):  0.3\n",
-      "errors:  31\n",
-      "PSK8 Symbol error rate (SER):  0.31\n",
-      "errors:  16\n",
-      "PSK8 Symbol error rate (SER):  0.16\n",
-      "errors:  21\n",
-      "PSK8 Symbol error rate (SER):  0.21\n",
-      "errors:  22\n",
-      "PSK8 Symbol error rate (SER):  0.22\n",
-      "errors:  19\n",
-      "PSK8 Symbol error rate (SER):  0.19\n",
-      "errors:  18\n",
-      "PSK8 Symbol error rate (SER):  0.18\n",
-      "errors:  12\n",
-      "PSK8 Symbol error rate (SER):  0.12\n",
-      "errors:  13\n",
-      "PSK8 Symbol error rate (SER):  0.13\n",
-      "errors:  18\n",
-      "PSK8 Symbol error rate (SER):  0.18\n",
-      "errors:  12\n",
-      "PSK8 Symbol error rate (SER):  0.12\n",
-      "errors:  5\n",
-      "PSK8 Symbol error rate (SER):  0.05\n",
-      "errors:  7\n",
-      "PSK8 Symbol error rate (SER):  0.07\n",
-      "errors:  4\n",
-      "PSK8 Symbol error rate (SER):  0.04\n",
-      "errors:  4\n",
-      "PSK8 Symbol error rate (SER):  0.04\n",
-      "errors:  1\n",
-      "PSK8 Symbol error rate (SER):  0.01\n",
-      "errors:  2\n",
-      "PSK8 Symbol error rate (SER):  0.02\n",
-      "errors:  2\n",
-      "PSK8 Symbol error rate (SER):  0.02\n",
-      "errors:  2\n",
-      "PSK8 Symbol error rate (SER):  0.02\n",
-      "errors:  1\n",
-      "PSK8 Symbol error rate (SER):  0.01\n",
-      "errors:  1\n",
-      "PSK8 Symbol error rate (SER):  0.01\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n",
-      "errors:  2\n",
-      "PSK8 Symbol error rate (SER):  0.02\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n",
-      "errors:  1\n",
-      "PSK8 Symbol error rate (SER):  0.01\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n",
-      "errors:  0\n",
-      "PSK8 Symbol error rate (SER):  0.0\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7fc1dc47e140>]"
+       "Text(0, 0.5, 'Error rate')"
       ]
      },
-     "execution_count": 633,
+     "execution_count": 70,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 400x400 with 1 Axes>"
       ]
@@ -799,7 +440,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 400x400 with 1 Axes>"
       ]
@@ -810,18 +451,14 @@
    ],
    "source": [
     "# PSK8\n",
-    "\n",
-    "SNR_list = np.linspace(-10, 10, 100)\n",
     "symbol_error_rate = []\n",
+    "bit_error_rate = []\n",
     "\n",
-    "symbols = np.zeros(10**2)\n",
-    "for i in range(10**2):\n",
-    "    symbols[i] = np.random.randint(0, 8)\n",
-    "    \n",
-    "PSK8_symbols = []\n",
-    "for i in symbols:\n",
-    "    PSK8_symbols.append(PSK8[int(i)])\n",
-    "    \n",
+    "symbols = np.random.randint(0, len(PSK8), size=(num_symbols))\n",
+    "\n",
+    "PSK8_symbols = np.zeros((num_symbols, 2), dtype=float)\n",
+    "for i, s in enumerate(symbols):\n",
+    "    PSK8_symbols[i] = PSK8[s]\n",
     "\n",
     "for SNR_dB in SNR_list:\n",
     "\n",
@@ -829,282 +466,93 @@
     "\n",
     "    signal_power = np.mean(np.abs(PSK8_symbols)**2)\n",
     "    noise_power = signal_power / SNR_linear\n",
-    "    num_symbols = len(PSK8_symbols)\n",
     "\n",
-    "    noise_x = noise_power * np.random.normal(0, 1, len(PSK8_symbols))\n",
-    "    noise_y = noise_power * np.random.normal(0, 1, len(PSK8_symbols))\n",
-    "    PSK8_x = [x for x, y in PSK8_symbols]\n",
-    "    PSK8_y = [y for x, y in PSK8_symbols]\n",
-    "    rx_signal = list(zip(PSK8_x + noise_x, PSK8_y + noise_y))\n",
+    "    noise = noise_power * np.random.normal(0, 1, size=(num_symbols, 2))\n",
+    "    rx_signal = PSK8_symbols + noise\n",
     "\n",
-    "    detected_idx = np.zeros(num_symbols, dtype=int)\n",
+    "    distances = np.zeros(len(PSK8), dtype=float)\n",
+    "    detected_symbols = np.zeros((num_symbols, 2), dtype=float)\n",
     "    for i, r in enumerate(rx_signal):\n",
-    "        distances = [np.linalg.norm(np.array(r) - s) for s in PSK8]\n",
-    "        detected_idx[i] = np.argmin(distances)\n",
-    "\n",
-    "    detected_symbols = []\n",
-    "    for i in detected_idx:\n",
-    "        detected_symbols.append(PSK8[int(i)])\n",
-    "\n",
+    "        for j, s in enumerate(PSK8):\n",
+    "            distances[j] = np.linalg.norm(r - s)\n",
+    "            \n",
+    "        detected_symbols[i] = PSK8[np.argmin(distances)]\n",
+    "    \n",
     "    errors = 0\n",
-    "    for i in range(len(PSK8_symbols)):\n",
-    "        if PSK8_symbols[i] != detected_symbols[i]:\n",
+    "    bit_errors = 0\n",
+    "    for i in range(num_symbols):\n",
+    "        if PSK8_symbols[i][0] != detected_symbols[i][0] or PSK8_symbols[i][1] != detected_symbols[i][1]:\n",
     "            errors += 1\n",
-    "            \n",
+    "            code = \"\"\n",
+    "            expected_code = \"\"\n",
+    "            for k, v in g_PSK8.items():\n",
+    "                if v[0] == PSK8_symbols[i][0] and v[1] == PSK8_symbols[i][1]:\n",
+    "                    expected_code = k\n",
+    "                elif v[0] == detected_symbols[i][0] and v[1] == detected_symbols[i][1]:\n",
+    "                    code = k\n",
+    "                \n",
+    "                if code != \"\" and expected_code != \"\":\n",
+    "                    break\n",
+    "                    \n",
+    "            bit_errors += diff_letters(code, expected_code)\n",
+    "        \n",
     "    SER = errors / num_symbols\n",
-    "\n",
-    "    print(\"errors: \", errors)\n",
-    "    print(\"PSK8 Symbol error rate (SER): \", SER)\n",
-    "\n",
+    "    \n",
+    "    BER = bit_errors / num_symbols\n",
+    "    \n",
+    "    # print(\"errors: \", errors)\n",
+    "    # print(\"PSK8 Symbol error rate (SER): \", SER)\n",
+    "    \n",
+    "    # Make the plot for specific SNR_dB\n",
+    "    if SNR_dB == 10:\n",
+    "        r_x = [x for x, y in rx_signal]\n",
+    "        r_y = [y for x, y in rx_signal]\n",
+    "\n",
+    "        x = [x for x, y in PSK8]\n",
+    "        y = [y for x, y in PSK8]\n",
+    "\n",
+    "        plt.figure(figsize=(4, 4))\n",
+    "        plt.title(\"Recieved symbols, PSK-8 modulation (SNR_dB = 10)\")\n",
+    "        plt.plot(np.cos(circle_x), np.sin(circle_x), color=\"orange\")\n",
+    "        plt.plot(r_x, r_y, 'o', color=\"red\")\n",
+    "        plt.plot(x,y,'o', color=\"blue\")\n",
+    "        plt.xticks(x, rotation=45)\n",
+    "        plt.yticks(y)\n",
+    "        plt.grid(True)\n",
+    "        for (k, s) in g_PSK8.items():\n",
+    "            plt.text(*s, k)\n",
+    "        \n",
     "    symbol_error_rate.append(SER)\n",
+    "    bit_error_rate.append(BER)\n",
     "\n",
-    "x = [x for x, y in PSK8]\n",
-    "y = [y for x, y in PSK8]\n",
-    "\n",
-    "r_x = [x for x, y in rx_signal]\n",
-    "r_y = [y for x, y in rx_signal]\n",
-    "\n",
+    "# Final curve plot\n",
     "plt.figure(figsize=(4, 4))\n",
-    "plt.title(\"PSK8\")\n",
-    "plt.plot(x,y,'o', color=\"blue\")\n",
-    "plt.plot(r_x,r_y,'o', color=\"red\")\n",
-    "\n",
-    "plt.figure(figsize=(4, 4))\n",
-    "plt.title(\"PSK8 symbol error rate\")\n",
-    "plt.plot(SNR_list, symbol_error_rate, 'o', color=\"blue\")"
+    "plt.title(\"PSK-8 modulation error rate\")\n",
+    "plt.plot(SNR_list, symbol_error_rate, 'o-', color=\"blue\")\n",
+    "plt.plot(SNR_list, bit_error_rate, 'o-', color=\"red\")\n",
+    "plt.legend([\"Symbol error rate\", \"Bit error rate\"])\n",
+    "plt.xlabel(\"SNR (dB)\")\n",
+    "plt.ylabel(\"Error rate\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 71,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "errors:  95\n",
-      "QAM16 Symbol error rate (SER):  0.95\n",
-      "errors:  96\n",
-      "QAM16 Symbol error rate (SER):  0.96\n",
-      "errors:  95\n",
-      "QAM16 Symbol error rate (SER):  0.95\n",
-      "errors:  93\n",
-      "QAM16 Symbol error rate (SER):  0.93\n",
-      "errors:  90\n",
-      "QAM16 Symbol error rate (SER):  0.9\n",
-      "errors:  98\n",
-      "QAM16 Symbol error rate (SER):  0.98\n",
-      "errors:  93\n",
-      "QAM16 Symbol error rate (SER):  0.93\n",
-      "errors:  93\n",
-      "QAM16 Symbol error rate (SER):  0.93\n",
-      "errors:  94\n",
-      "QAM16 Symbol error rate (SER):  0.94\n",
-      "errors:  93\n",
-      "QAM16 Symbol error rate (SER):  0.93\n",
-      "errors:  94\n",
-      "QAM16 Symbol error rate (SER):  0.94\n",
-      "errors:  90\n",
-      "QAM16 Symbol error rate (SER):  0.9\n",
-      "errors:  97\n",
-      "QAM16 Symbol error rate (SER):  0.97\n",
-      "errors:  92\n",
-      "QAM16 Symbol error rate (SER):  0.92\n",
-      "errors:  93\n",
-      "QAM16 Symbol error rate (SER):  0.93\n",
-      "errors:  96\n",
-      "QAM16 Symbol error rate (SER):  0.96\n",
-      "errors:  92\n",
-      "QAM16 Symbol error rate (SER):  0.92\n",
-      "errors:  92\n",
-      "QAM16 Symbol error rate (SER):  0.92\n",
-      "errors:  92\n",
-      "QAM16 Symbol error rate (SER):  0.92\n",
-      "errors:  93\n",
-      "QAM16 Symbol error rate (SER):  0.93\n",
-      "errors:  90\n",
-      "QAM16 Symbol error rate (SER):  0.9\n",
-      "errors:  94\n",
-      "QAM16 Symbol error rate (SER):  0.94\n",
-      "errors:  93\n",
-      "QAM16 Symbol error rate (SER):  0.93\n",
-      "errors:  92\n",
-      "QAM16 Symbol error rate (SER):  0.92\n",
-      "errors:  92\n",
-      "QAM16 Symbol error rate (SER):  0.92\n",
-      "errors:  93\n",
-      "QAM16 Symbol error rate (SER):  0.93\n",
-      "errors:  94\n",
-      "QAM16 Symbol error rate (SER):  0.94\n",
-      "errors:  95\n",
-      "QAM16 Symbol error rate (SER):  0.95\n",
-      "errors:  91\n",
-      "QAM16 Symbol error rate (SER):  0.91\n",
-      "errors:  90\n",
-      "QAM16 Symbol error rate (SER):  0.9\n",
-      "errors:  93\n",
-      "QAM16 Symbol error rate (SER):  0.93\n",
-      "errors:  93\n",
-      "QAM16 Symbol error rate (SER):  0.93\n",
-      "errors:  90\n",
-      "QAM16 Symbol error rate (SER):  0.9\n",
-      "errors:  86\n",
-      "QAM16 Symbol error rate (SER):  0.86\n",
-      "errors:  92\n",
-      "QAM16 Symbol error rate (SER):  0.92\n",
-      "errors:  91\n",
-      "QAM16 Symbol error rate (SER):  0.91\n",
-      "errors:  90\n",
-      "QAM16 Symbol error rate (SER):  0.9\n",
-      "errors:  93\n",
-      "QAM16 Symbol error rate (SER):  0.93\n",
-      "errors:  90\n",
-      "QAM16 Symbol error rate (SER):  0.9\n",
-      "errors:  92\n",
-      "QAM16 Symbol error rate (SER):  0.92\n",
-      "errors:  93\n",
-      "QAM16 Symbol error rate (SER):  0.93\n",
-      "errors:  90\n",
-      "QAM16 Symbol error rate (SER):  0.9\n",
-      "errors:  93\n",
-      "QAM16 Symbol error rate (SER):  0.93\n",
-      "errors:  85\n",
-      "QAM16 Symbol error rate (SER):  0.85\n",
-      "errors:  91\n",
-      "QAM16 Symbol error rate (SER):  0.91\n",
-      "errors:  87\n",
-      "QAM16 Symbol error rate (SER):  0.87\n",
-      "errors:  88\n",
-      "QAM16 Symbol error rate (SER):  0.88\n",
-      "errors:  86\n",
-      "QAM16 Symbol error rate (SER):  0.86\n",
-      "errors:  84\n",
-      "QAM16 Symbol error rate (SER):  0.84\n",
-      "errors:  89\n",
-      "QAM16 Symbol error rate (SER):  0.89\n",
-      "errors:  82\n",
-      "QAM16 Symbol error rate (SER):  0.82\n",
-      "errors:  88\n",
-      "QAM16 Symbol error rate (SER):  0.88\n",
-      "errors:  84\n",
-      "QAM16 Symbol error rate (SER):  0.84\n",
-      "errors:  84\n",
-      "QAM16 Symbol error rate (SER):  0.84\n",
-      "errors:  82\n",
-      "QAM16 Symbol error rate (SER):  0.82\n",
-      "errors:  84\n",
-      "QAM16 Symbol error rate (SER):  0.84\n",
-      "errors:  87\n",
-      "QAM16 Symbol error rate (SER):  0.87\n",
-      "errors:  84\n",
-      "QAM16 Symbol error rate (SER):  0.84\n",
-      "errors:  87\n",
-      "QAM16 Symbol error rate (SER):  0.87\n",
-      "errors:  81\n",
-      "QAM16 Symbol error rate (SER):  0.81\n",
-      "errors:  82\n",
-      "QAM16 Symbol error rate (SER):  0.82\n",
-      "errors:  78\n",
-      "QAM16 Symbol error rate (SER):  0.78\n",
-      "errors:  79\n",
-      "QAM16 Symbol error rate (SER):  0.79\n",
-      "errors:  85\n",
-      "QAM16 Symbol error rate (SER):  0.85\n",
-      "errors:  74\n",
-      "QAM16 Symbol error rate (SER):  0.74\n",
-      "errors:  76\n",
-      "QAM16 Symbol error rate (SER):  0.76\n",
-      "errors:  75\n",
-      "QAM16 Symbol error rate (SER):  0.75\n",
-      "errors:  68\n",
-      "QAM16 Symbol error rate (SER):  0.68\n",
-      "errors:  77\n",
-      "QAM16 Symbol error rate (SER):  0.77\n",
-      "errors:  65\n",
-      "QAM16 Symbol error rate (SER):  0.65\n",
-      "errors:  69\n",
-      "QAM16 Symbol error rate (SER):  0.69\n",
-      "errors:  64\n",
-      "QAM16 Symbol error rate (SER):  0.64\n",
-      "errors:  69\n",
-      "QAM16 Symbol error rate (SER):  0.69\n",
-      "errors:  64\n",
-      "QAM16 Symbol error rate (SER):  0.64\n",
-      "errors:  70\n",
-      "QAM16 Symbol error rate (SER):  0.7\n",
-      "errors:  63\n",
-      "QAM16 Symbol error rate (SER):  0.63\n",
-      "errors:  61\n",
-      "QAM16 Symbol error rate (SER):  0.61\n",
-      "errors:  58\n",
-      "QAM16 Symbol error rate (SER):  0.58\n",
-      "errors:  53\n",
-      "QAM16 Symbol error rate (SER):  0.53\n",
-      "errors:  67\n",
-      "QAM16 Symbol error rate (SER):  0.67\n",
-      "errors:  55\n",
-      "QAM16 Symbol error rate (SER):  0.55\n",
-      "errors:  47\n",
-      "QAM16 Symbol error rate (SER):  0.47\n",
-      "errors:  39\n",
-      "QAM16 Symbol error rate (SER):  0.39\n",
-      "errors:  43\n",
-      "QAM16 Symbol error rate (SER):  0.43\n",
-      "errors:  42\n",
-      "QAM16 Symbol error rate (SER):  0.42\n",
-      "errors:  49\n",
-      "QAM16 Symbol error rate (SER):  0.49\n",
-      "errors:  42\n",
-      "QAM16 Symbol error rate (SER):  0.42\n",
-      "errors:  26\n",
-      "QAM16 Symbol error rate (SER):  0.26\n",
-      "errors:  41\n",
-      "QAM16 Symbol error rate (SER):  0.41\n",
-      "errors:  27\n",
-      "QAM16 Symbol error rate (SER):  0.27\n",
-      "errors:  39\n",
-      "QAM16 Symbol error rate (SER):  0.39\n",
-      "errors:  24\n",
-      "QAM16 Symbol error rate (SER):  0.24\n",
-      "errors:  18\n",
-      "QAM16 Symbol error rate (SER):  0.18\n",
-      "errors:  17\n",
-      "QAM16 Symbol error rate (SER):  0.17\n",
-      "errors:  14\n",
-      "QAM16 Symbol error rate (SER):  0.14\n",
-      "errors:  18\n",
-      "QAM16 Symbol error rate (SER):  0.18\n",
-      "errors:  15\n",
-      "QAM16 Symbol error rate (SER):  0.15\n",
-      "errors:  8\n",
-      "QAM16 Symbol error rate (SER):  0.08\n",
-      "errors:  9\n",
-      "QAM16 Symbol error rate (SER):  0.09\n",
-      "errors:  7\n",
-      "QAM16 Symbol error rate (SER):  0.07\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7fc1dc6b6e60>]"
+       "Text(0, 0.5, 'Error rate')"
       ]
      },
-     "execution_count": 631,
+     "execution_count": 71,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 400x400 with 1 Axes>"
       ]
@@ -1114,7 +562,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 400x400 with 1 Axes>"
       ]
@@ -1125,16 +573,14 @@
    ],
    "source": [
     "# QAM16\n",
-    "SNR_list = np.linspace(-10, 10, 100)\n",
     "symbol_error_rate = []\n",
+    "bit_error_rate = []\n",
     "\n",
-    "symbols = np.zeros(10**2)\n",
-    "for i in range(10**2):\n",
-    "    symbols[i] = np.random.randint(0, 16)\n",
-    "    \n",
-    "QAM16_symbols = []\n",
-    "for i in symbols:\n",
-    "    QAM16_symbols.append(QAM16[int(i)])\n",
+    "symbols = np.random.randint(0, len(QAM16), size=(num_symbols))\n",
+    "\n",
+    "QAM16_symbols = np.zeros((num_symbols, 2), dtype=float)\n",
+    "for i, s in enumerate(symbols):\n",
+    "    QAM16_symbols[i] = QAM16[s]\n",
     "\n",
     "for SNR_dB in SNR_list:\n",
     "\n",
@@ -1142,81 +588,84 @@
     "\n",
     "    signal_power = np.mean(np.abs(QAM16_symbols)**2)\n",
     "    noise_power = signal_power / SNR_linear\n",
-    "    num_symbols = len(QAM16_symbols)\n",
     "\n",
-    "    noise_x = noise_power * np.random.normal(0, 1, len(QAM16_symbols))\n",
-    "    noise_y = noise_power * np.random.normal(0, 1, len(QAM16_symbols))\n",
-    "    QAM16_x = [x for x, y in QAM16_symbols]\n",
-    "    QAM16_y = [y for x, y in QAM16_symbols]\n",
-    "    rx_signal = list(zip(QAM16_x + noise_x, QAM16_y + noise_y))\n",
+    "    noise = noise_power * np.random.normal(0, 1, size=(num_symbols, 2))\n",
+    "    rx_signal = QAM16_symbols + noise\n",
     "\n",
-    "    detected_idx = np.zeros(num_symbols, dtype=int)\n",
+    "    distances = np.zeros(len(QAM16), dtype=float)\n",
+    "    detected_symbols = np.zeros((num_symbols, 2), dtype=float)\n",
     "    for i, r in enumerate(rx_signal):\n",
-    "        distances = [np.linalg.norm(np.array(r) - s) for s in QAM16]\n",
-    "        detected_idx[i] = np.argmin(distances)\n",
-    "\n",
-    "    detected_symbols = []\n",
-    "    for i in detected_idx:\n",
-    "        detected_symbols.append(QAM16[int(i)])\n",
-    "\n",
+    "        for j, s in enumerate(QAM16):\n",
+    "            distances[j] = np.linalg.norm(r - s)\n",
+    "            \n",
+    "        detected_symbols[i] = QAM16[np.argmin(distances)]\n",
+    "    \n",
     "    errors = 0\n",
-    "    for i in range(len(QAM16_symbols)):\n",
-    "        if QAM16_symbols[i] != detected_symbols[i]:\n",
+    "    bit_errors = 0\n",
+    "    for i in range(num_symbols):\n",
+    "        if QAM16_symbols[i][0] != detected_symbols[i][0] or QAM16_symbols[i][1] != detected_symbols[i][1]:\n",
     "            errors += 1\n",
-    "            \n",
+    "            code = \"\"\n",
+    "            expected_code = \"\"\n",
+    "            for k, v in g_QAM16.items():\n",
+    "                if v[0] == QAM16_symbols[i][0] and v[1] == QAM16_symbols[i][1]:\n",
+    "                    expected_code = k\n",
+    "                elif v[0] == detected_symbols[i][0] and v[1] == detected_symbols[i][1]:\n",
+    "                    code = k\n",
+    "                \n",
+    "                if code != \"\" and expected_code != \"\":\n",
+    "                    break\n",
+    "                    \n",
+    "            bit_errors += diff_letters(code, expected_code)\n",
+    "        \n",
     "    SER = errors / num_symbols\n",
-    "\n",
-    "    print(\"errors: \", errors)\n",
-    "    print(\"QAM16 Symbol error rate (SER): \", SER)\n",
     "    \n",
+    "    BER = bit_errors / num_symbols\n",
+    "    \n",
+    "    # print(\"errors: \", errors)\n",
+    "    # print(\"QAM16 Symbol error rate (SER): \", SER)\n",
+    "    \n",
+    "    # Make the plot for specific SNR_dB\n",
+    "    if SNR_dB == 20:\n",
+    "        r_x = [x for x, y in rx_signal]\n",
+    "        r_y = [y for x, y in rx_signal]\n",
+    "\n",
+    "        x = [x for x, y in QAM16]\n",
+    "        y = [y for x, y in QAM16]\n",
+    "\n",
+    "        plt.figure(figsize=(4, 4))\n",
+    "        plt.title(\"Recieved symbols, QAM-16 modulation (SNR_dB = 20)\")\n",
+    "        plt.plot(r_x, r_y, 'o', color=\"red\")\n",
+    "        plt.plot(x,y,'o', color=\"blue\")\n",
+    "        plt.xticks(x)\n",
+    "        plt.yticks(y)\n",
+    "        plt.grid(True)\n",
+    "        for (k, s) in g_QAM16.items():\n",
+    "            plt.text(*s, k)\n",
+    "        \n",
     "    symbol_error_rate.append(SER)\n",
+    "    bit_error_rate.append(BER)\n",
     "\n",
-    "x = [x for x, y in QAM16_symbols]\n",
-    "y = [y for x, y in QAM16_symbols]\n",
-    "\n",
-    "r_x = [x for x, y in rx_signal]\n",
-    "r_y = [y for x, y in rx_signal]\n",
-    "\n",
+    "# Final curve plot\n",
     "plt.figure(figsize=(4, 4))\n",
-    "plt.title(\"QAM16\")\n",
-    "plt.plot(x,y,'o', color=\"blue\")\n",
-    "plt.plot(r_x,r_y,'o', color=\"red\")\n",
-    "\n",
-    "plt.figure(figsize=(4, 4))\n",
-    "plt.title(\"QAM16 symbol error rate\")\n",
-    "plt.plot(SNR_list, symbol_error_rate, 'o', color=\"blue\")\n",
-    "\n"
+    "plt.title(\"QAM-16 modulation error rate\")\n",
+    "plt.plot(SNR_list, symbol_error_rate, 'o-', color=\"blue\")\n",
+    "plt.plot(SNR_list, bit_error_rate, 'o-', color=\"red\")\n",
+    "plt.legend([\"Symbol error rate\", \"Bit error rate\"])\n",
+    "plt.xlabel(\"SNR (dB)\")\n",
+    "plt.ylabel(\"Error rate\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 77,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "4000000\n",
-      "7000000\n",
-      "4000000\n"
-     ]
-    },
-    {
-     "ename": "NameError",
-     "evalue": "name 'snr_dbs' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[547], line 56\u001b[0m\n\u001b[1;32m     52\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mlen\u001b[39m(decoded))\n\u001b[1;32m     55\u001b[0m plt\u001b[38;5;241m.\u001b[39mfigure(\u001b[38;5;241m2\u001b[39m)\n\u001b[0;32m---> 56\u001b[0m plt\u001b[38;5;241m.\u001b[39msemilogy(\u001b[43msnr_dbs\u001b[49m, ber_encoded, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mo-\u001b[39m\u001b[38;5;124m'\u001b[39m, label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mWith hamming\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m     57\u001b[0m plt\u001b[38;5;241m.\u001b[39msemilogy(snr_dbs, ber_plain, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124ms-\u001b[39m\u001b[38;5;124m'\u001b[39m, label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mWithout encoding\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m     58\u001b[0m plt\u001b[38;5;241m.\u001b[39mtitle(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mber communication with and without encoding\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
-      "\u001b[0;31mNameError\u001b[0m: name 'snr_dbs' is not defined"
-     ]
-    },
     {
      "data": {
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 640x480 with 0 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -1267,23 +716,103 @@
     "        decoded_data.extend([block[0], block[1], block[2], block[4]])\n",
     "    return decoded_data\n",
     "\n",
-    "data = np.zeros(4 * (10 ** 2))\n",
-    "for i in range(4 * (10 ** 2)):\n",
+    "num_data_bits_by_4 = 10**6\n",
+    "\n",
+    "data = np.zeros(4 * num_data_bits_by_4)\n",
+    "for i in range(4 * num_data_bits_by_4):\n",
     "    data[i] = np.random.randint(0, 2)\n",
     "\n",
-    "encoded = hamming_encode(data)\n",
-    "print(len(data))\n",
-    "print(len(encoded))\n",
-    "decoded = hamming_decode(encoded)\n",
-    "print(len(decoded))\n",
+    "encoded = np.array(hamming_encode(data))\n",
+    "\n",
+    "ber_encoded = []\n",
+    "ber_plain = []\n",
+    "\n",
+    "QPSK_symbols_encoded = np.array([g_QPSK[str(int(block[0])) + str(int(block[1]))] for block in encoded.reshape(int(len(encoded) / 2), 2)])\n",
+    "QPSK_symbols_plain = np.array([g_QPSK[str(int(block[0])) + str(int(block[1]))] for block in data.reshape(int(len(data) / 2), 2)])\n",
+    "\n",
+    "num_symbols_encoded = len(QPSK_symbols_encoded)\n",
+    "num_symbols_plain = len(QPSK_symbols_plain)\n",
+    "\n",
+    "SNR_list = np.linspace(-20, 10, 16)\n",
+    "\n",
+    "# Encoded QPSK\n",
+    "for SNR_dB in SNR_list:\n",
+    "\n",
+    "    SNR_linear = 10**(SNR_dB / 10)\n",
+    "\n",
+    "    signal_power = np.mean(np.abs(QPSK_symbols_encoded)**2)\n",
+    "    noise_power = signal_power / SNR_linear\n",
     "\n",
+    "    noise = noise_power * np.random.normal(0, 1, size=(num_symbols_encoded, 2))\n",
+    "    rx_signal = QPSK_symbols_encoded + noise\n",
     "\n",
-    "plt.figure(2)\n",
-    "plt.semilogy(snr_dbs, ber_encoded, 'o-', label=\"With hamming\")\n",
-    "plt.semilogy(snr_dbs, ber_plain, 's-', label=\"Without encoding\")\n",
-    "plt.title(\"ber communication with and without encoding\")\n",
-    "plt.xlabel(\"SNR (db)\")\n",
-    "plt.ylabel(\"bit error rate\")\n",
+    "    distances = np.zeros(len(QPSK), dtype=float)\n",
+    "    detected_symbols = np.zeros((num_symbols_encoded, 2), dtype=float)\n",
+    "    for i, r in enumerate(rx_signal):\n",
+    "        for j, s in enumerate(QPSK):\n",
+    "            distances[j] = np.linalg.norm(r - s)\n",
+    "            \n",
+    "        detected_symbols[i] = QPSK[np.argmin(distances)]\n",
+    "    \n",
+    "    recv = []\n",
+    "    for i in range(num_symbols_encoded):\n",
+    "        code = \"\"\n",
+    "        for k, v in g_QPSK.items():\n",
+    "            if v[0] == detected_symbols[i][0] and v[1] == detected_symbols[i][1]:\n",
+    "                code = k\n",
+    "                break\n",
+    "        \n",
+    "        for char in code:\n",
+    "            recv.append(int(char))\n",
+    "                \n",
+    "    decoded = np.array(hamming_decode(recv))\n",
+    "    \n",
+    "    bit_errors = np.sum(data != decoded)\n",
+    "    BER = bit_errors / num_symbols_encoded\n",
+    "        \n",
+    "    ber_encoded.append(BER)\n",
+    "\n",
+    "# Plain QPSK\n",
+    "for SNR_dB in SNR_list:\n",
+    "\n",
+    "    SNR_linear = 10**(SNR_dB / 10)\n",
+    "\n",
+    "    signal_power = np.mean(np.abs(QPSK_symbols_plain)**2)\n",
+    "    noise_power = signal_power / SNR_linear\n",
+    "\n",
+    "    noise = noise_power * np.random.normal(0, 1, size=(num_symbols_plain, 2))\n",
+    "    rx_signal = QPSK_symbols_plain + noise\n",
+    "\n",
+    "    distances = np.zeros(len(QPSK), dtype=float)\n",
+    "    detected_symbols = np.zeros((num_symbols_plain, 2), dtype=float)\n",
+    "    for i, r in enumerate(rx_signal):\n",
+    "        for j, s in enumerate(QPSK):\n",
+    "            distances[j] = np.linalg.norm(r - s)\n",
+    "            \n",
+    "        detected_symbols[i] = QPSK[np.argmin(distances)]\n",
+    "    \n",
+    "    recv = []\n",
+    "    for i in range(num_symbols_plain):\n",
+    "        code = \"\"\n",
+    "        for k, v in g_QPSK.items():\n",
+    "            if v[0] == detected_symbols[i][0] and v[1] == detected_symbols[i][1]:\n",
+    "                code = k\n",
+    "                break\n",
+    "        \n",
+    "        for char in code:\n",
+    "            recv.append(int(char))\n",
+    "                \n",
+    "    bit_errors = np.sum(data != np.array(recv))\n",
+    "    BER = bit_errors / num_symbols_plain\n",
+    "        \n",
+    "    ber_plain.append(BER)\n",
+    "\n",
+    "plt.figure(3)\n",
+    "plt.semilogy(SNR_list, ber_encoded, 'o-', label=\"With hamming\")\n",
+    "plt.semilogy(SNR_list, ber_plain, 's-', label=\"Without encoding\")\n",
+    "plt.title(\"Bit error rate for QPSK communication with and without encoding\")\n",
+    "plt.xlabel(\"SNR (dB)\")\n",
+    "plt.ylabel(\"Bit error rate\")\n",
     "plt.legend()\n",
     "plt.grid(True)\n",
     "plt.show()\n",