diff --git a/evaluation/Aggregation.py b/evaluation/Aggregation.py index 8642ece0..c00e914c 100644 --- a/evaluation/Aggregation.py +++ b/evaluation/Aggregation.py @@ -4,36 +4,37 @@ import numpy as np class Aggregation: - def __init__(self, epsilon=1.0, t = 1): + def __init__(self, epsilon=1.0, t=1, repeat_count=10000): self.epsilon = epsilon self.t = t + self.repeat_count = repeat_count # Taking df as a parameter it shall be passed both d1 and d2 that differ by 1 record def exact_count(self, df, colname): - return df[colname].count() + return np.zeros(self.repeat_count) + df[colname].count() def buggy_count(self, df, colname): - return df[colname].count() + (random.random()*10) + return df[colname].count() + np.random.random_sample((self.repeat_count,))*10 def dp_count(self, df, colname): delta = 1/(len(df) * math.sqrt(len(df))) sigmacnt = math.sqrt(self.t)*((math.sqrt(math.log(1/delta)) + math.sqrt(math.log((1/delta)) + self.epsilon)) / (math.sqrt(2)*self.epsilon)) - dp_noise = np.random.normal(0, sigmacnt, 1)[0] + dp_noise = np.random.normal(0, sigmacnt, self.repeat_count) return df[colname].count() + dp_noise def dp_sum(self, df, colname): delta = 1/(len(df) * math.sqrt(len(df))) M = abs(max(df[colname]) - min(df[colname])) sigmasum = math.sqrt(self.t)*M*((math.sqrt(math.log(1/delta)) + math.sqrt(math.log((1/delta)) + self.epsilon)) / (math.sqrt(2)*self.epsilon)) - dp_noise = np.random.normal(0, sigmasum, 1)[0] + dp_noise = np.random.normal(0, sigmasum, self.repeat_count) return df[colname].sum() + dp_noise def dp_mean(self, df, colname): - return self.dp_sum(df, colname) / self.dp_count(df, colname) + return np.divide(self.dp_sum(df, colname), self.dp_count(df, colname)) def dp_var(self, df, colname): cnt = self.dp_count(df, colname) sum = self.dp_sum(df, colname) df[colname + "squared"] = df[colname] ** 2 sumsq = self.dp_sum(df, colname + "squared") - return (sumsq/cnt) - ((sum/cnt)**2) \ No newline at end of file + return np.subtract(np.divide(sumsq, cnt), np.power(np.divide(sum, cnt), 2)) \ No newline at end of file diff --git a/evaluation/DPVerification.py b/evaluation/DPVerification.py index 262dc70d..e8c2937f 100644 --- a/evaluation/DPVerification.py +++ b/evaluation/DPVerification.py @@ -10,13 +10,13 @@ import math import matplotlib.pyplot as plt import Aggregation as agg -import statistics as st from scipy import stats class DPVerification: # Set the epsilon parameter of differential privacy - def __init__(self, epsilon=1.0): + def __init__(self, epsilon=1.0, dataset_size=10000): self.epsilon = epsilon + self.dataset_size = dataset_size self.df = self.create_simulated_dataset() print("Loaded " + str(len(self.df)) + " records") self.N = len(self.df) @@ -24,9 +24,9 @@ def __init__(self, epsilon=1.0): def create_simulated_dataset(self): np.random.seed(1) - userids = list(range(1, 10001)) + userids = list(range(1, self.dataset_size+1)) userids = ["A" + str(user) for user in userids] - usage = np.random.geometric(p=0.5, size=10000).tolist() + usage = np.random.geometric(p=0.5, size=self.dataset_size).tolist() df = pd.DataFrame(list(zip(userids, usage)), columns=['UserId', 'Usage']) return df @@ -36,10 +36,6 @@ def generate_neighbors(self): print("No records in dataframe to run the test") return None, None - if(self.N > 10000): - self.df = self.df.sample(n=10000, random_state=1) - self.N = 10000 - d1 = self.df drop_idx = np.random.choice(self.df.index, 1, replace=False) d2 = self.df.drop(drop_idx) @@ -49,25 +45,23 @@ def generate_neighbors(self): # If there is an aggregation function that we need to test, we need to apply it on neighboring datasets # This function applies the aggregation repeatedly to log results in two vectors that are then used for generating histogram # The histogram is then passed through the DP test - def apply_aggregation_neighbors(self, f, args1, args2, repeatcount=10000): - fD1, fD2 = [], [] - for i in range(repeatcount): - fD1.append(f(*args1)) - fD2.append(f(*args2)) + def apply_aggregation_neighbors(self, f, args1, args2): + fD1 = f(*args1) + fD2 = f(*args2) - print("Mean fD1: ", st.mean(fD1), " Stdev fD1: ", st.stdev(fD1), " Mean fD2: ", st.mean(fD2), " Stdev fD2: ", st.stdev(fD2)) + print("Mean fD1: ", np.mean(fD1), " Stdev fD1: ", np.std(fD1), " Mean fD2: ", np.mean(fD2), " Stdev fD2: ", np.std(fD2)) return fD1, fD2 # Instead of applying function to dataframe, this'll pass a query through PrivSQL and get response # This way we can test actual SQLDP implementation - def apply_query(self, d1, d2, agg_query, repeatcount=100): + def apply_query(self, d1, d2, agg_query): # To do return None # Generate histograms given the vectors of repeated aggregation results applied on neighboring datasets - def generate_histogram_neighbors(self, fD1, fD2, numbins = 0, binsize = "auto", alpha = 0.05, exact = False): - d1 = np.array(fD1) - d2 = np.array(fD2) + def generate_histogram_neighbors(self, fD1, fD2, numbins=0, binsize="auto", exact=False): + d1 = fD1 + d2 = fD2 d = np.concatenate((d1, d2), axis=None) n = d.size binlist = [] @@ -89,25 +83,15 @@ def generate_histogram_neighbors(self, fD1, fD2, numbins = 0, binsize = "auto", binlist = np.arange(np.floor(minval),np.ceil(maxval)) # Calculating histograms of fD1 and fD2 - d1hist, bin_edges = np.histogram(d1, bins = binlist, density = True) - #print("Sum of probabilities in D1 Histogram: ", np.sum(d1hist)) - d2hist, bin_edges = np.histogram(d2, bins = binlist, density = True) - #print("Sum of probabilities in D2 Histogram: ", np.sum(d2hist)) + d1hist, bin_edges = np.histogram(d1, bins = binlist, density = False) + print("Sum of frequencies in D1 Histogram: ", np.sum(d1hist)) + d2hist, bin_edges = np.histogram(d2, bins = binlist, density = False) + print("Sum of frequencies in D2 Histogram: ", np.sum(d2hist)) - # Lower and Upper bound - if(not exact): - num_buckets = binlist.size - 1 - critical_value = stats.norm.ppf(1-(alpha/2/num_buckets), loc=0.0, scale=1.0) - d1_error_interval = critical_value * math.sqrt(num_buckets / d1.size) / 2 - d2_error_interval = critical_value * math.sqrt(num_buckets / d2.size) / 2 - else: - d1_error_interval = 0.0 - d2_error_interval = 0.0 - - return d1hist, d2hist, bin_edges, d1_error_interval, d2_error_interval + return d1hist, d2hist, bin_edges # Plot histograms given the vectors of repeated aggregation results applied on neighboring datasets - def plot_histogram_neighbors(self, fD1, fD2, d1hist, d2hist, binlist, d1error, d2error, bound = True, exact = False): + def plot_histogram_neighbors(self, fD1, fD2, d1hist, d2hist, binlist, d1size, d2size, bound=True, exact=False): plt.figure(figsize=(15,6)) if(exact): ax = plt.subplot(1, 1, 1) @@ -119,19 +103,16 @@ def plot_histogram_neighbors(self, fD1, fD2, d1hist, d2hist, binlist, d1error, d ax.legend(['D1', 'D2'], loc="upper right") return - d1histbound, d2histbound, d1upper, d2upper, d1lower, d2lower = \ - self.get_bounded_histogram(d1hist, d2hist, binlist, d1error, d2error) + px, py, d1histupperbound, d2histupperbound, d1histbound, d2histbound, d1lower, d2lower = \ + self.get_bounded_histogram(d1hist, d2hist, binlist, d1size, d2size, exact = exact) - if(bound): - d1histbound = d1upper * math.exp(self.epsilon) + self.delta - d2histbound = d2upper * math.exp(self.epsilon) + self.delta ax = plt.subplot(1, 2, 1) ax.ticklabel_format(useOffset=False) plt.xlabel('Bin') - plt.ylabel('Probability') + plt.ylabel('Frequency') if(bound): - plt.bar(binlist[:-1], d1histbound, alpha=0.5, width=np.diff(binlist), ec="k", align="edge") - plt.bar(binlist[:-1], d2lower, alpha=0.5, width=np.diff(binlist), ec="k", align="edge") + plt.bar(binlist[:-1], d2histupperbound, alpha=0.5, width=np.diff(binlist), ec="k", align="edge") + plt.bar(binlist[:-1], d1lower, alpha=0.5, width=np.diff(binlist), ec="k", align="edge") plt.legend(['D1', 'D2'], loc="upper right") else: plt.bar(binlist[:-1], d1hist, alpha=0.5, width=np.diff(binlist), ec="k", align="edge") @@ -141,10 +122,10 @@ def plot_histogram_neighbors(self, fD1, fD2, d1hist, d2hist, binlist, d1error, d ax = plt.subplot(1, 2, 2) ax.ticklabel_format(useOffset=False) plt.xlabel('Bin') - plt.ylabel('Probability') + plt.ylabel('Frequency') if(bound): - plt.bar(binlist[:-1], d2histbound, alpha=0.5, width=np.diff(binlist), ec="k", align="edge") - plt.bar(binlist[:-1], d1lower, alpha=0.5, width=np.diff(binlist), ec="k", align="edge") + plt.bar(binlist[:-1], d1histupperbound, alpha=0.5, width=np.diff(binlist), ec="k", align="edge") + plt.bar(binlist[:-1], d2lower, alpha=0.5, width=np.diff(binlist), ec="k", align="edge") plt.legend(['D2', 'D1'], loc="upper right") else: plt.bar(binlist[:-1], d2hist, alpha=0.5, width=np.diff(binlist), ec="k", align="edge") @@ -152,39 +133,63 @@ def plot_histogram_neighbors(self, fD1, fD2, d1hist, d2hist, binlist, d1error, d plt.legend(['D2', 'D1'], loc="upper right") plt.show() - def get_bounded_histogram(self, d1hist, d2hist, binlist, d1error, d2error): + # Check if histogram of fD1 values multiplied by e^epsilon and summed by delta is bounding fD2 and vice versa + # Use the histogram results and create bounded histograms to compare in DP test + def get_bounded_histogram(self, d1hist, d2hist, binlist, d1size, d2size, exact, alpha=0.05): + d1_error_interval = 0.0 + d2_error_interval = 0.0 + # Lower and Upper bound + if(not exact): + num_buckets = binlist.size - 1 + critical_value = stats.norm.ppf(1-(alpha / 2 / num_buckets), loc=0.0, scale=1.0) + d1_error_interval = critical_value * math.sqrt(num_buckets / d1size) / 2 + d2_error_interval = critical_value * math.sqrt(num_buckets / d2size) / 2 + num_buckets = binlist.size - 1 - d1upper = np.power(np.sqrt(d1hist * num_buckets) + d1error, 2) / num_buckets - d2upper = np.power(np.sqrt(d2hist * num_buckets) + d2error, 2) / num_buckets - d1lower = np.power(np.sqrt(d1hist * num_buckets) - d1error, 2) / num_buckets - d2lower = np.power(np.sqrt(d2hist * num_buckets) - d2error, 2) / num_buckets + px = np.divide(d1hist, d1size) + py = np.divide(d2hist, d2size) + + d1histbound = px * math.exp(self.epsilon) + self.delta + d2histbound = py * math.exp(self.epsilon) + self.delta + + d1upper = np.power(np.sqrt(px * num_buckets) + d1_error_interval, 2) / num_buckets + d2upper = np.power(np.sqrt(py * num_buckets) + d2_error_interval, 2) / num_buckets + d1lower = np.power(np.sqrt(px * num_buckets) - d1_error_interval, 2) / num_buckets + d2lower = np.power(np.sqrt(py * num_buckets) - d2_error_interval, 2) / num_buckets + np.maximum(d1lower, 0.0, d1lower) np.maximum(d2lower, 0.0, d1lower) - d1histbound = d1upper * math.exp(self.epsilon) + self.delta - d2histbound = d2upper * math.exp(self.epsilon) + self.delta - return d1histbound, d2histbound, d1upper, d2upper, d1lower, d2lower - # Check if histogram of fD1 values multiplied by e^epsilon and summed by delta is bounding fD2 and vice versa - def dp_test(self, d1hist, d2hist, binlist, d1error, d2error, debug = False): - d1histbound, d2histbound, d1upper, d2upper, d1lower, d2lower = \ - self.get_bounded_histogram(d1hist, d2hist, binlist, d1error, d2error) + d1histupperbound = d1upper * math.exp(self.epsilon) + self.delta + d2histupperbound = d2upper * math.exp(self.epsilon) + self.delta + + return px, py, d1histupperbound, d2histupperbound, d1histbound, d2histbound, d1lower, d2lower + + # Differentially Private Predicate Test + def dp_test(self, d1hist, d2hist, binlist, d1size, d2size, debug=False, exact=False): + px, py, d1histupperbound, d2histupperbound, d1histbound, d2histbound, d1lower, d2lower = \ + self.get_bounded_histogram(d1hist, d2hist, binlist, d1size, d2size, exact) if(debug): print("Parameters") print("epsilon: ", self.epsilon, " delta: ", self.delta) print("Bins\n", binlist) - print("D1Error\n", d1error) - print("D2Error\n", d2error) print("Original D1 Histogram\n", d1hist) + print("Probability of D1 Histogram\n", px) print("D1 Lower\n", d1lower) - print("D1 Upper\n", d1upper) + print("D1 Upper\n", d1histupperbound) print("D1 Histogram to bound D2\n", d1histbound) print("Original D2 Histogram\n", d2hist) + print("Probability of D2 Histogram\n", py) print("D2 Lower\n", d2lower) - print("D2 Upper\n", d2upper) + print("D2 Upper\n", d2histupperbound) print("D2 Histogram to bound D1\n", d2histbound) - print("Comparison - D1 bound to D2\n", np.greater(d1histbound, d2lower)) - print("Comparison - D2 bound to D1\n", np.greater(d2histbound, d1lower)) - return np.all(np.greater(d1histbound, d2lower)) and np.all(np.greater(d2histbound, d1lower)) + print("Comparison - D2 bound to D1\n", np.greater(d1hist, np.zeros(d1hist.size)), np.logical_and(np.greater(d1hist, np.zeros(d1hist.size)), np.greater(d1lower, d2histupperbound))) + print("Comparison - D1 bound to D2\n", np.greater(d2hist, np.zeros(d2hist.size)), np.logical_and(np.greater(d2hist, np.zeros(d2hist.size)), np.greater(d2lower, d1histupperbound))) + + # Check if any of the bounds across the bins violate the relaxed DP condition + bound_exceeded = np.any(np.logical_and(np.greater(d1hist, np.zeros(d1hist.size)), np.greater(d1lower, d2histupperbound))) or \ + np.any(np.logical_and(np.greater(d2hist, np.zeros(d2hist.size)), np.greater(d2lower, d1histupperbound))) + return not bound_exceeded # K-S Two sample test between the repeated query results on neighboring datasets def ks_test(self, fD1, fD2): @@ -202,19 +207,20 @@ def kl_divergence(self, p, q): def wasserstein_distance(self, d1hist, d2hist): return stats.wasserstein_distance(d1hist, d2hist) - def aggtest(self, f, colname, repeatcount, numbins = 0, binsize = "auto", debug = False, plot = True, bound = True, exact = False): + def aggtest(self, f, colname, numbins=0, binsize="auto", debug=False, plot=True, bound=True, exact=False): d1, d2 = self.generate_neighbors() - fD1, fD2 = self.apply_aggregation_neighbors(f, (d1, colname), (d2, colname), repeatcount) - + fD1, fD2 = self.apply_aggregation_neighbors(f, (d1, colname), (d2, colname)) + d1size, d2size = fD1.size, fD2.size + ks_res = self.ks_test(fD1, fD2) print("\nKS 2-sample Test Result: ", ks_res, "\n") #andderson_res = self.anderson_ksamp(fD1, fD2) #print("Anderson 2-sample Test Result: ", andderson_res, "\n") - d1hist, d2hist, bin_edges, d1error, d2error = \ - self.generate_histogram_neighbors(fD1, fD2, numbins, binsize, exact = exact) + d1hist, d2hist, bin_edges = \ + self.generate_histogram_neighbors(fD1, fD2, numbins, binsize, exact=exact) #kl_res = self.kl_divergence(d1hist, d2hist) #print("\nKL-Divergence Test: ", kl_res, "\n") @@ -227,11 +233,11 @@ def aggtest(self, f, colname, repeatcount, numbins = 0, binsize = "auto", debug dp_res = False if(not exact): - dp_res = self.dp_test(d1hist, d2hist, bin_edges, d1error, d2error, debug) + dp_res = self.dp_test(d1hist, d2hist, bin_edges, d1size, d2size, debug, exact=exact) print("DP Predicate Test:", dp_res, "\n") if(plot): - self.plot_histogram_neighbors(fD1, fD2, d1hist, d2hist, bin_edges, d1error, d2error, bound, exact) + self.plot_histogram_neighbors(fD1, fD2, d1hist, d2hist, bin_edges, d1size, d2size, bound, exact) return dp_res, ks_res, ws_res # Main method listing all the DP verification steps diff --git a/evaluation/Differential Privacy Verification.ipynb b/evaluation/Differential Privacy Verification.ipynb index 7195fc26..ea3bcda5 100644 --- a/evaluation/Differential Privacy Verification.ipynb +++ b/evaluation/Differential Privacy Verification.ipynb @@ -47,8 +47,8 @@ } ], "source": [ - "dv = dp.DPVerification()\n", - "ag = agg.Aggregation(t=1)" + "dv = dp.DPVerification(dataset_size=10000)\n", + "ag = agg.Aggregation(t=1, repeat_count=10000)" ] }, { @@ -64,7 +64,6 @@ "metadata": {}, "outputs": [], "source": [ - "repeatcount = 10000 # Repeating the aggregation these many times\n", "# Using the auto method of np.histogram to decide bin size\n", "# Maximum of the ‘sturges’ and ‘fd’ estimators. Provides good all around performance.\n", "numbins = 0" @@ -87,10 +86,12 @@ "output_type": "stream", "text": [ "Length of D1: 10000 Length of D2: 9999\n", - "Mean fD1: 10000 Stdev fD1: 0.0 Mean fD2: 9999 Stdev fD2: 0.0\n", + "Mean fD1: 10000.0 Stdev fD1: 0.0 Mean fD2: 9999.0 Stdev fD2: 0.0\n", "\n", "KS 2-sample Test Result: Ks_2sampResult(statistic=1.0, pvalue=0.0) \n", "\n", + "Sum of frequencies in D1 Histogram: 10000\n", + "Sum of frequencies in D2 Histogram: 10000\n", "Wasserstein Distance Test: 0.0 \n", "\n", "DP Predicate Test: False \n", @@ -101,7 +102,7 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -109,7 +110,7 @@ } ], "source": [ - "dp_exact, ks_exact, ws_exact = dv.aggtest(ag.exact_count, 'UserId', repeatcount, binsize = \"unity\", bound = False, exact = True)" + "dp_exact, ks_exact, ws_exact = dv.aggtest(ag.exact_count, 'UserId', binsize = \"unity\", bound = False, exact = True)" ] }, { @@ -143,11 +144,13 @@ "output_type": "stream", "text": [ "Length of D1: 10000 Length of D2: 9999\n", - "Mean fD1: 10004.967750403664 Stdev fD1: 2.891237927091873 Mean fD2: 10003.996722922044 Stdev fD2: 2.875257858728964\n", + "Mean fD1: 10004.967394600022 Stdev fD1: 2.9038229236537214 Mean fD2: 10003.979349547073 Stdev fD2: 2.901616465809466\n", "\n", - "KS 2-sample Test Result: Ks_2sampResult(statistic=0.10459999999999992, pvalue=4.175102550739557e-48) \n", + "KS 2-sample Test Result: Ks_2sampResult(statistic=0.10719999999999999, pvalue=1.6628946276700017e-50) \n", "\n", - "Wasserstein Distance Test: 0.019360000000000002 \n", + "Sum of frequencies in D1 Histogram: 10000\n", + "Sum of frequencies in D2 Histogram: 10000\n", + "Wasserstein Distance Test: 3.0 \n", "\n", "DP Predicate Test: False \n", "\n" @@ -155,9 +158,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -165,7 +168,7 @@ } ], "source": [ - "dp_buggy, ks_buggy, ws_buggy = dv.aggtest(ag.buggy_count, 'UserId', repeatcount, binsize = \"unity\", bound = True)" + "dp_buggy, ks_buggy, ws_buggy = dv.aggtest(ag.buggy_count, 'UserId', binsize=\"auto\", debug=False,bound = True)" ] }, { @@ -199,11 +202,13 @@ "output_type": "stream", "text": [ "Length of D1: 10000 Length of D2: 9999\n", - "Mean fD1: 9999.896594800253 Stdev fD1: 5.400244176245732 Mean fD2: 9998.949408799317 Stdev fD2: 5.331361579318794\n", + "Mean fD1: 9999.871385730805 Stdev fD1: 5.368257295621045 Mean fD2: 9998.97123189085 Stdev fD2: 5.387870582753535\n", "\n", - "KS 2-sample Test Result: Ks_2sampResult(statistic=0.07390000000000008, pvalue=3.174548694732298e-24) \n", + "KS 2-sample Test Result: Ks_2sampResult(statistic=0.06379999999999997, pvalue=3.651771010208054e-18) \n", "\n", - "Wasserstein Distance Test: 0.001165674707005585 \n", + "Sum of frequencies in D1 Histogram: 10000\n", + "Sum of frequencies in D2 Histogram: 10000\n", + "Wasserstein Distance Test: 3.5681818181818192 \n", "\n", "DP Predicate Test: True \n", "\n" @@ -211,9 +216,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -221,7 +226,7 @@ } ], "source": [ - "dp_count, ks_count, ws_count = dv.aggtest(ag.dp_count, 'UserId', repeatcount, binsize=\"unity\", debug = False)" + "dp_count, ks_count, ws_count = dv.aggtest(ag.dp_count, 'UserId', binsize=\"auto\", debug = False)" ] }, { @@ -250,11 +255,13 @@ "output_type": "stream", "text": [ "Length of D1: 10000 Length of D2: 9999\n", - "Mean fD1: 19876.663182078424 Stdev fD1: 63.57239713786615 Mean fD2: 19875.270303101748 Stdev fD2: 64.30344694293686\n", + "Mean fD1: 19876.949562811995 Stdev fD1: 63.776429519417434 Mean fD2: 19875.616764257546 Stdev fD2: 64.04152171207586\n", "\n", - "KS 2-sample Test Result: Ks_2sampResult(statistic=0.014900000000000024, pvalue=0.21527374193503254) \n", + "KS 2-sample Test Result: Ks_2sampResult(statistic=0.014599999999999946, pvalue=0.23517556311047363) \n", "\n", - "Wasserstein Distance Test: 8.082168621340842e-05 \n", + "Sum of frequencies in D1 Histogram: 10000\n", + "Sum of frequencies in D2 Histogram: 10000\n", + "Wasserstein Distance Test: 6.888888888888886 \n", "\n", "DP Predicate Test: True \n", "\n" @@ -262,9 +269,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4IAAAF3CAYAAADwyfXiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzt3X+4XXV94Pv3hwQIgj8TECGkCYrtA6hgAnZGa7UdhOqDjM/IGKkWCw7DtblM621RuQiBjKg8HYsdeO4YESt4O1SxdZKnaQnKjLcXqAQlygkWiZErB6SQICAlIST53D/2PsnOyj7n7H2y19577fV+Pc95stbaa63z3d+csz/n813fH5GZSJIkSZLq44BBF0CSJEmS1F8mgpIkSZJUMyaCkiRJklQzJoKSJEmSVDMmgpIkSZJUMyaCkiRJklQzJoKSJEmSVDMmgpIk9VlEnBERD0TExoj4eJvX3xoR34+IHRHx3javvyQiHomIa/tTYknSqDERlCSpjyJiFnAd8DvA8cD7I+L4wmk/Az4E/OUkt1kBfKesMkqSRp+JoCRJ/XUqsDEzN2XmduBm4KzWEzLzocz8IbCreHFELAZeCaztR2ElSaNp9qAL0Cvz5s3LhQsXDroYkqQ++N73vrc5Mw8fdDlm6Gjg4Zb9ceBNnVwYEQcA/wX4IPDbnX5DY6Qk1UM38bHURDAizgA+D8wCrs/MzxRefytwDfB6YGlm3lJ4/SXAj4C/ycxlU32vhQsXcs899/Sy+JKkIRUR/9+gy7Afos2x7PDajwBrMvPhiHa3afkmERcAFwAsWLDAGClJNdBNfCwtEWwZA3EajdbOdRGxKjPvbzltYgzEH09yG8dASJJGzThwTMv+fODRDq/9V8BvRMRHgMOAgyLi2czcZ8KZzFwJrARYsmRJp4mmJKkmynwiuHsMBEBETIyB2J0IZuZDzdemGgPx98CSEsspSVI/rQOOi4hFwCPAUuCcTi7MzN+d2I6IDwFL2iWBkiRNp8zJYtqNgTi6kwtbxkD8SQnlkiRpYDJzB7AMuJXG8IevZeaGiLgyIt4NEBGnRMQ4cDbwhYjYMLgSS5JGUZlPBEsfA1Ec/yBJ2uOFF15gfHycbdu2DbooMzZnzhzmz5/PgQceOOii9FRmrgHWFI5d1rK9jkaX0anu8RfAX5RQPEkaacbHhjITwdLHQDj+QZImNz4+zotf/GIWLlzIdBOLDKPMZMuWLYyPj7No0aJBF0eSNCKMjw1ldg3dPQYiIg6iMQZiVScXZubvZuaCzFxIYyKZGx0DIUnd2bZtG3Pnzq1kkAOICObOnVvpFltJ0vAxPjaUlgg6BkKSBq+qQW5C1csvSRpOVY8vvSh/mU8Eycw1mfnazHx1Zn6qeeyyzFzV3F6XmfMz89DMnJuZJ7S5x19Mt4agJGk4zZo1i5NOOokTTjiBN7zhDXzuc59j167GRNFbtmzh7W9/O4cddhjLlvkxL0mqj6ni42233cbixYt53etex+LFi7n99ttLKUOpC8pLkobH5Vddzfhjm3t2v/lHzuOKSy6e8pxDDjmE9evXA/D4449zzjnn8PTTT3PFFVcwZ84cVqxYwdjYGGNjYz0rlyRJ3Ri2+Dhv3jxWr17NUUcdxdjYGKeffjqPPPJIz8o3wURQkmpi/LHNnHjmh3t2v7HV13d1/hFHHMHKlSs55ZRTWL58OYceeihvectb2LhxY8/KJElSt4YtPp588sm7XzvhhBPYtm0bzz//PAcffHDPyggldw2VJKnVsccey65du3j88ccHXRRJkobGZPHxG9/4BieffHLPk0DwiaAkqc8yXe1HkqSiYnzcsGEDH/vYx1i7dm0p388ngpKkvtm0aROzZs3iiCOOGHRRJEkaGsX4OD4+znve8x5uvPFGXv3qV5fyPX0iKGm34mDpTgY7S5164oknuPDCC1m2bFnlp+2WNFqMfxqkYnx86qmneNe73sWnP/1p3vzmN5f2fU0EJe1WHCzd7WBnqWjr1q2cdNJJvPDCC8yePZsPfvCDfPSjH939+sKFC3nmmWfYvn073/zmN1m7di3HH3/8AEssqY6Mf+q3qeLjtddey8aNG1mxYgUrVqwAYO3atT3vTWMiKEk1Mf/IeT3942b+kfOmPWfnzp1Tvv7QQw/1qDSSJM3MsMXHSy+9lEsvvbRn5ZmMiaAk1YTdnCRJ2ldd46OTxUiSJElSzZgISpIkSVLNmAhKkiRJUs2YCEqSJElSzThZjFQTxTWSwHWSJEmS6songlJNTKyR1PpVTAylXps1axYnnXQSJ5xwAm94wxv43Oc+x65duwC47bbbWLx4Ma973etYvHgxt99++4BLK0lSf0wVH7ds2cLb3/52DjvsMJYtW1ZaGXwiKEk1cc1Vl/HUPz/cs/u97JXH8IeXXDnlOYcccgjr168H4PHHH+ecc87h6aef5oorrmDevHmsXr2ao446irGxMU4//XQeeeSRnpVPkqRODFt8nDNnDitWrGBsbIyxsbGelavIRFCSauKpf36Y5f/2tT273/Jv/rir84844ghWrlzJKaecwvLlyzn55JN3v3bCCSewbds2nn/+eQ4++OCelVGSpOkMW3w89NBDectb3sLGjRt7VqZ27BoqSeqbY489ll27dvH444/vdfwb3/gGJ598skmgJKmWJouPZfKJoCSprzJzr/0NGzbwsY99jLVr1w6oRJIkDV4xPpbNJ4KSpL7ZtGkTs2bN4ogjjgBgfHyc97znPdx44428+tWvHnDpJEkajGJ87AefCEojqrhcxPr7xjjxzAEWSLX3xBNPcOGFF7Js2TIigqeeeop3vetdfPrTn+bNb37zoIsnaUS5fJKGXTE+9ouJoDSiJpaLmHDn3RcOsDSqq61bt3LSSSfxwgsvMHv2bD74wQ/y0Y9+FIBrr72WjRs3smLFClasWAHA2rVr+9oaKmn0FeMhwE0rltlYqoGaKj4CLFy4kGeeeYbt27fzzW9+k7Vr13L88cf3tAwmgpJUEy975TFdz2Q23f2ms3Pnzklfu/TSS7n00kt7Vh5J6tTW7TtsLNVuwxYfAR566KEelWZyJoJSRRW7usykm8u969dz/kV7rrFFdLRNt6aRJEl1VNf4aCIoVVSxq8vY6uu7voctopIkSfXkrKGSJEmSVDMmgpI0wvq9JlGvVb38kqThVPX40ovy2zVUUsecgrta5syZw5YtW5g7d25fp6Pulcxky5YtzJkzZ9BFkSSNEONjg4mgpI61m4J7JmMT1R/z589nfHycJ554YtBFmbE5c+Ywf/78QRdDkjRCjI8NJoKSNKIOPPBAFi1aNOhiSJI0VIyPDSaCkibl8hKSJEmjyURQ0qRcXkKSJGk0OWuoJEmSJNWMTwQlSeqziDgD+DwwC7g+Mz9TeP2twDXA64GlmXlL8/hJwP8FvATYCXwqM/+qn2WX1FCcSdtZtFU1JoKSJPVRRMwCrgNOA8aBdRGxKjPvbzntZ8CHgD8uXP4c8HuZ+WBEHAV8LyJuzcyn+lB0aSgNKiErzqTtLNqqGhNBSZL661RgY2ZuAoiIm4GzgN2JYGY+1HxtV+uFmfnjlu1HI+Jx4HDARFC1ZUImzYxjBCVJ6q+jgYdb9sebx7oSEacCBwE/6VG5JEk1UuoTQcdASP3jUg9SZUSbY9nVDSJeBdwEnJuZuyY55wLgAoAFCxZ0W0ZJ0ogrLRF0DITUXy71IFXGOHBMy/584NFOL46IlwB/C1yamf842XmZuRJYCbBkyZKuEk1J0ugr84mgYyAkSdrXOuC4iFgEPAIsBc7p5MKIOAj4G+DGzPx6eUWUqsseMlJnykwE242BeFO3N3EMhCRplGTmjohYBtxKY+jEDZm5ISKuBO7JzFURcQqNhO/lwJkRcUVmngD8e+CtwNyI+FDzlh/KzPX9fyfScCqjh0xxZlLYN8EsJqAuJ6FhV2YiWPoYCMc/SJKqKDPXAGsKxy5r2V5Ho8to8bqvAl8tvYCS9lKcmRT2TTCLCaizl2rYlZkIlj4GwvEPGlUuUitJUrUVnxCC8VzDpcxE0DEQ0gwVWx5vWrFs2i4pkiRpeBSfEIJPCTVcSksEHQMh9U67YOKsoJIkSZqpUtcRdAyEJEmSJA2fUhNBSZIkqWpcgkJ1YCIoSZIktShjCQpp2JgISpIkaSi1W7/PmTel3jARlCRJ0lAoJn7r7xvjA5dcs9c5zrwp9YaJoCRJkoZCcfkku2RK5Tlg0AWQJEmSJPWXiaAkSZIk1YxdQyVJklQZLu0g9YaJoCRJkirDpR2k3rBrqCRJkiTVjImgJEmSJNWMXUMl9VRxDSgX/pUkSRo+JoKSeqq4BpQL/0qSJA0fE0Gpz4pPzMCnZpIkSeovE0Gpz4pPzMCnZpIkSeovE0FJ+8X1nCRJkqrHRFDSfnE9J0mSpOpx+QhJkiRJqhkTQUmSJEmqGRNBSZIkSaoZE0FJkiRJqhkTQUmSJEmqGRNBSZIkSaoZE0FJkiRJqhnXEZRKdvlVVzP+2Obd++0WXHdRdkmSJPWTiaBUsvHHNk+74LqLskuSJKmf7BoqSZIkSTVjIihJkiRJNWMiKEmSJEk14xhBSZIkaQCKE8rNP3IeV1xy8RRXSL1jIihJkqSB6GRm7VFWnFBubPX1AyyN6sZEUJIkSQPRyczaksrhGEFJkiRJqhmfCEqSJEl9cO/69Zx/0Z4xgHXrCqvh4hNBSZL6LCLOiIgHImJjRHy8zetvjYjvR8SOiHhv4bVzI+LB5te5/Su1pP21dfsOTjzzw7u/ntu6bdBFUo2ZCEqS1EcRMQu4Dvgd4Hjg/RFxfOG0nwEfAv6ycO0rgMuBNwGnApdHxMvLLrMkafSYCEqS1F+nAhszc1NmbgduBs5qPSEzH8rMHwK7CteeDtyWmU9m5i+A24Az+lFoSdJoKTURtOuLJEn7OBp4uGV/vHms7GslSdqttETQri+SJLUVbY5lr6+NiAsi4p6IuOeJJ57ouHCSpHoo84mgXV8kSdrXOHBMy/584NFeX5uZKzNzSWYuOfzww2dUUEnS6CozEbTriyRJ+1oHHBcRiyLiIGApsKrDa28F3hERL2/2lHlH85gkSV0pMxEsveuL3V4kSVWTmTuAZTQSuB8BX8vMDRFxZUS8GyAiTomIceBs4AsRsaF57ZPAChrJ5DrgyuYxSZK6UuaC8vvb9eVthWv/V/GkzFwJrARYsmRJp0mmJEkDlZlrgDWFY5e1bK+jEfvaXXsDcEOpBZQkjbwynwja9UWSJEmShlBpiaBdXyRJkiRpOJXZNdSuL5IkSZI0hEpdUF6SJEmSNHxMBCVJkiSpZkwEJUmSJKlmTAQlSZIkqWZKnSxGkiRJUmfuXb+e8y+6ePf+/CPnccUlF09xhTRzJoKSJEnSENi6fQcnnvnh3ftjq68fYGk06uwaKkmSJEk1YyIoSZIkSTVjIihJkiRJNWMiKEmSJEk142QxkiRJ6rnLr7qa8cc27953BkxpuJgISpIkqefGH9vsDJjSELNrqCRJkiTVjImgJEmSJNWMiaAkSZIk1YyJoCRJkiTVjImgJEmSJNWMs4ZKKtW969dz/kV7TxfuFOKSJEmDZSIoqVRbt+/Ya/pwcApxSaqjdg2D6+8b48QzB1QgqeZMBCVJklS6dg2Dd9594YBKI8kxgpIkSZJUMyaCkiRJklQzJoKSJEmSVDOOEZTUd8UJA5xFVJIkqb9MBCX1XXHCAGcRlSRJ6i+7hkqSJElSzZgISpIkSVLNmAhKkiRJUs04RlCSJEkaQsXJ1cAJ1tQ7JoKSJEnSECpOrgZOsKbesWuoJEmSJNWMiaAkSZIk1YyJoCRJkiTVjImgJEmSJNWMiaAkSQMQEWdExAMRsTEiPt7m9YMj4q+ar383IhY2jx8YEV+JiPsi4kcR8Yl+l12SVH3OGir12OVXXc34Y5t376+/b4wTzxxggSQNnYiYBVwHnAaMA+siYlVm3t9y2vnALzLzNRGxFPgs8D7gbODgzHxdRLwIuD8i/ntmPtTfdyFJqrKOnghGxIkzubmtnaqj8cc2c+KZH9799dzWbYMukqQSzTBGngpszMxNmbkduBk4q3DOWcBXmtu3AL8dEQEkcGhEzAYOAbYDz8yo8JKk2ur0ieB/i4iDgL8A/jIzn5ruAls7VRc+AZRqr+sYCRwNPNyyPw68abJzMnNHRDwNzKWRFJ4F/Bx4EfBHmfnkfr0DSVLtdJQIZuZbIuI44Dzgnoi4G/hyZt42xWW7WzsBImKitbM1ETwLWN7cvgW41tZOVc3EE8AJd9594QBLU033rl/P+RddvHt//pHzuOKSi6e4QhoeM4yR0e5WHZ5zKrATOAp4OfAPEfGtiXi7++KIC4ALABYsWNDRe5Ek1UfHYwQz88GIuBS4B/hz4ORm0nZJZv51m0ts7ZTUka3bd+yVTI+tvn6ApZG6N4MYOQ4c07I/H3h0knPGmw2jLwWeBM4B/j4zXwAej4g7gCXAXolgZq4EVgIsWbKkmGRKkmquo0QwIl4P/D7wLuA24MzM/H5EHAXcBbQLcrZ2SpJG3gxj5DrguIhYBDwCLKWR4LVaBZzbvMd7gdszMyPiZ8BvRcRXaTSW/jpwTe/fmdQdh0pI1dLpE8FrgS/SaNncOnEwMx9ttoC2Y2unJKkOuo6RzV4wy4BbgVnADZm5ISKuBO7JzFXAl4CbImIjjdi4tHn5dcCXgTEaDapfzswflvTepI45VEKqlk4TwXcCWzNzJ0BEHADMycznMvOmSa6xtVOSVAcziZFk5hpgTeHYZS3b22hMnla87tl2xyVJ6kanieC3gH8DPNvcfxGwFvjXk11ga6dGUbHbC9j1RVL3MVKSpEHrNBGc02yBBBqtkc1lHaZka6dGTbHbC9j1RdLMYqQkSYPU0YLywL9ExBsndiJiMbB1ivMlSaoLY6QkqXI6fSL4h8DXI2JispdX0Vj4XZKkujNGSuob195Vr3S6oPy6iPg14FdpjNn7p+aMnpIk1ZoxUlI/ufaueqXjBeWBU4CFzWtOjggy88ZSSiVJUrUYIyVJldLpgvI3Aa8G1tNY6B0aC78b5CRJtWaMlCRVUadPBJcAx2emi7ZLkrQ3Y6QkqXI6nTV0DDiyzIJIklRRxkhJUuV0+kRwHnB/RNwNPD9xMDPfXUqpJEmqDmOkJKlyOk0El5dZCEmSKmz5oAsgSVK3Ol0+4jsR8SvAcZn5rYh4ETCr3KJJkjT8jJGSpCrqaIxgRPwH4BbgC81DRwPfLKtQkiRVhTFSklRFnU4W8wfAm4FnADLzQeCIsgolSVKFGCMlSZXTaSL4fGZun9iJiNk01kiSJKnujJGSpMrpNBH8TkRcAhwSEacBXwdWl1csSZIqwxgpSaqcThPBjwNPAPcB/xFYA1xaVqEkSaoQY6QkqXI6nTV0F/DF5pckSWoyRkqSqqijRDAifkqb8Q6ZeWzPSyRJUoUYIyVJVdTpgvJLWrbnAGcDr+h9cSRpX5dfdTXjj23e69j8I+dxxSUXD6hE0l6MkZKkyum0a+iWwqFrIuL/BS7rfZEk1d2969dz/kV7krz1943xgUuu2eucsdXX97tYUlvGSElSFXXaNfSNLbsH0Gj9fHEpJZJUe1u37+DEMz+8e//Ouy8cYGmkqRkjJUlV1GnX0P/Ssr0DeAj49z0vjSRJ1WOMlCRVTqddQ99edkEkSaoiY6QkqYo67Rr60alez8zP9aY4kiRVizFSklRF3cwaegqwqrl/JvD/AA+XUShJkirEGClJqpxOE8F5wBsz85cAEbEc+HpmfnjKqyRJGn3GSNVScWmf9feNceKZAyxQTRVn2nZ5JXWq00RwAbC9ZX87sLDnpZEkqXqMkaql8cc2O8PzECjOtO3ySupUp4ngTcDdEfE3QALvAW4srVSSJFWHMVKSVDmdzhr6qYj4O+A3mod+PzPvLa9YkiRVgzFSklRFB3Rx7ouAZzLz88B4RCwqqUySJFWNMVKSVCmdLh9xOY1Z0X4V+DJwIPBV4M3lFU2SJufgeA0LY6QkqYo6HSP4HuBk4PsAmfloRLy4tFJJ0jQcHK8hYoyUJFVOp4ng9szMiEiAiDi0xDJJQ8OpsSV1wBgpaWjYY0ad6jQR/FpEfAF4WUT8B+A84IvlFUsaDk6NLakDxkhJQ8MeM+pUp7OG/mlEnAY8Q2MMxGWZeVupJZMkqQKMkZKkKpo2EYyIWcCtmflvAAObJElNxkhJUlVNu3xEZu4EnouIl/ahPJIkVYYxUpJUVZ2OEdwG3BcRtwH/MnEwMy8qpVSSJFVH1zEyIs4APg/MAq7PzM8UXj8YuBFYDGwB3peZDzVfez3wBeAlwC7glMzc1ss3JEkafZ0mgn/b/OqKgU6SVANdxchmd9LrgNOAcWBdRKzKzPtbTjsf+EVmviYilgKfBd4XEbNprFH4wcz8QUTMBV7o1RuRJNXHlIlgRCzIzJ9l5le6vbGBTlVQXB7CKZYldWo/YuSpwMbM3NS8z83AWUBrfDwLWN7cvgW4NiICeAfww8z8AUBmbtmPtyBJqrHpngh+E3gjQER8IzP/XRf3NtBp6BWXh3CKZUldmGmMPBp4uGV/HHjTZOdk5o6IeBqYC7wWyIi4FTgcuDkzr273TSLiAuACgAULFnRYNKnBhlJp9E2XCEbL9rFd3rsvgU7qpeIirC4gL2kKM42R0eZYdnjObOAtwCnAc8C3I+J7mfntfU7OXAmsBFiyZEnx/tKUbCiVRt90iWBOst2J0gOdrZ3qteIirC4gL2kKM42R48AxLfvzgUcnOWe8OVzipcCTzePfyczNABGxhsZTyX0SQUmSpjLd8hFviIhnIuKXwOub289ExC8j4plpru0m0DFZoMvM54CJQLeXzFyZmUsyc8nhhx8+TXEkSeqpmcbIdcBxEbEoIg4ClgKrCuesAs5tbr8XuD0zE7i1+b1e1Iybv8neQy4kSerIlE8EM3PWftx7d6ADHqER6M4pnDMR6O6iJdA1u4ReHBEvArbTCHR/th9lkSSpp2YaI5tDIZbRSOpmATdk5oaIuBK4JzNXAV8CboqIjTQaSJc2r/1FRHyORoxNYE1mdj2rt6T6KA57Acd8qqHT5SO6ZqCTJKm9zFxDo7dL67HLWra3AWdPcu1XacysLUnTKg57Acd8qqG0RBAMdJIkSZI0jKYbIyhJkiRJGjEmgpIkSZJUM6V2DZUkSVL1tZtwxLV2pWozEZQkSdKU2k044lq7UrXZNVSSJEmSasZEUJIkSZJqxkRQkiRJkmrGMYKSJElSjRQn/5l/5DyuuOTiKa7QKDIRlCRJkmqkOPnP2OrrB1gaDYqJoKSRYOumJElS50wEJY0EWzclSZI652QxkiRJklQzJoKSJEmSVDMmgpIkSZJUMyaCkiRJklQzJoKSJEmSVDPOGipJklRzl191NeOPbd69v/6+MU48c4AFklQ6E0FJkqSaG39s815L8Nx594UDLI2kfrBrqCRJkiTVjImgJEmSJNWMiaAkSZIk1YyJoCRJkiTVjImgJEmSJNWMiaAkSZIk1YzLR6g2imskgeskSZIkqZ5MBFUbxTWSwHWSJEmSVE92DZUkSZKkmjERlCRJkqSaMRGUJEmSpJpxjKCkkXTv+vWcf9HFu/fnHzmPKy65eIorJEmS6sNEUNJI2rp9x16TA42tvn6ApZEkSRoudg2VJEmSpJoxEZQkSZKkmrFrqCRJklRjjquvJxNBSZIkqcYcV19Pdg2VJEmSpJrxiaAkSQMQEWcAnwdmAddn5mcKrx8M3AgsBrYA78vMh1peXwDcDyzPzD/tV7kljT67itZDqU8EI+KMiHggIjZGxMfbvH5wRPxV8/XvRsTCwusLIuLZiPjjMsspSVI/RcQs4Drgd4DjgfdHxPGF084HfpGZrwH+DPhs4fU/A/6u7LJKqp+JrqITX+OPbR50kVSC0hJBg5wkSZM6FdiYmZsycztwM3BW4ZyzgK80t28BfjsiAiAi/i2wCdjQp/JKkkZMmU8EDXKSJLV3NPBwy/5481jbczJzB/A0MDciDgU+BlzRh3JKkkZUmYmgQU6SpPaizbHs8JwrgD/LzGen/AYRF0TEPRFxzxNPPDHDYkqSRlWZk8X0JMg1HxC2/wYRFwAXACxYsGCGxZQkqe/GgWNa9ucDj05yznhEzAZeCjwJvAl4b0RcDbwM2BUR2zLz2taLM3MlsBJgyZIlxfgrSaq5MhNBg5wkSe2tA46LiEXAI8BS4JzCOauAc4G7gPcCt2dmAr8xcUJELAeeLcZHSZKmU2YiaJCTNDSKU2GD02FrcDJzR0QsA26lsXzEDZm5ISKuBO7JzFXAl4CbImIjjUbSpYMrsUbN5VddvddMkOvvG+PEMwdYIEl9V1oiaJCTNEwmpsJuNbb6+gGVRoLMXAOsKRy7rGV7G3D2NPdYXkrhNPLGH9u812finXdfOMDSSBqEUheUN8hJkiRJ0vApdUF5SZIkSdLwKfWJoCQNs+K4QccMSpKkujARlFRbxXGDjhmUNIqKE8OAk8OoO064NppMBCVJkkZYcWIYcHIYdccJ10aTiaBGllNjS5KkXti5+afc+cVP7HNMqjITQVVSu24uxS4KTo3dvWKgM8hJkgSHxPN89PRFex278N67BlQaqTdMBFVJ7bq52EVh/xUDnUFOklQHNoSqjkwEpZqwW8v0nEVUkurJhlDVkYmgVBN2a5mes4hKUj0UG0dz27MDLI00GCaCkiRJGhmddPMsNo5+5K6dfSmbNExMBKWKmi7Q2dopSaqjXnTz3P7cL42hGnkmglJFTRfoOmntNNBJkrSvOQfs6vqJoRPOqGpMBDUyihN9uG7g9LoNdE44I0lSQ7Exdc7zW5xwRpViIqiRUZzow3UD9990QQ4MdJKkeprJU0NpmJgISpqUQU6SVHXFRk1wKIQEJoLSyHC8nySpDrodi1ds1AQbNiUwEZSG0kwGnPv0TpJUB8XJ0M67Y60NodIMmAhKQ2i6IAcGOkmSwIZQaaZMBKUKsFuLJEmSeslEUJIkaYRcftXVjD+2efe+yympDMVlu+YfOY8rLrl4iis0bEwEJUmSRsj4Y5tdTmlIjdKi88Vlu8ZWXz9CiLFcAAAT3ElEQVTA0mgmTAQl9dQoBTlJUn+NUgxpt2yFi85rmJgIqhJGqZtLMchNHKuq6RadN8hJkjpVnCytyjHE8f0adiaCqoRR6uZSDHIwWoHOICdJkjT8TAQlSZI0EMVeMsWlkdp1r3T5JKk3TASlkk0X5GDfQGeQG07FLsrgLGmStD+KvWSKvUrsXimVx0RQKtl0QQ7sXjmsilNjr79vjA9ccs1e5zhLmqR+skFKUq+YCErSJIpTY1d5bKqk0VAcMw9w04plIzOhmqrLdQWrx0RQkiSpwmy00jBwXcHqOWDQBZAkSZIk9ZeJoCRJkiTVjImgJEmSJNWMYwQlaT84OF6SJFWRiaAk7QcHx0uSpCqya6gkSZIk1YyJoCRJkiTVjF1DNZQuv+pqF8eVNLIi4gzg88As4PrM/Ezh9YOBG4HFwBbgfZn5UEScBnwGOAjYDvxJZt7e18JL6pntz/2SO7/4id37Ozf/dIClUd2Umgga6DRT449tdnHcEVEMcmCgU71FxCzgOuA0YBxYFxGrMvP+ltPOB36Rma+JiKXAZ4H3AZuBMzPz0Yg4EbgVOLq/70BSr8w5YBcfPX3R7v0L771rgKVR3ZSWCBroJMG+QQ7gvDvW2gKqOjsV2JiZmwAi4mbgLKA1Pp4FLG9u3wJcGxGRmfe2nLMBmBMRB2fm8+UXW1LZfEKofirziaCBTlJbtoCq5o4GHm7ZHwfeNNk5mbkjIp4G5tJoKJ3w74B7jY3S6DA+qp/KnCymXaArPtXbK9ABE4GulYFOkjRKos2x7OaciDiBRi+a/zjpN4m4ICLuiYh7nnjiiRkVVJI0usp8ItjLQPeOtt8g4gLgAoAFCxbMrJSSJPXXOHBMy/584NFJzhmPiNnAS4EnASJiPvA3wO9l5k8m+yaZuRJYCbBkyZJi/JX6bufmn+4zZjy3PTug0kgqMxEsPdAZ5KqpOCMowKaNP+bY17x2936VZgktBrYXfnbvXvsGOUkF64DjImIR8AiwFDincM4q4FzgLuC9wO2ZmRHxMuBvgU9k5h19LLPUtWJ8nPP8ln3GjH/krp39LlalOOGaylRmImigU1vFGUEB7vzkhby7orOEHhLP7xXYPnLX9sK+QW46Do5XnTTH/C2jMRHaLOCGzNwQEVcC92TmKuBLwE0RsZFGA+nS5uXLgNcAn4yITzaPvSMzH+/vu5Cmt298NB52q92Ea44bVK+Ulgga6DSK7NZSDgfHq24ycw2wpnDsspbtbcDZba77z8B/Lr2A0gwUY6TxURpupa4jaKDTqCm2boItnJKk3ikOn5h/5DyuuOTiAZaocz4BlKql1ERQkiRJnSsOnxhbff0ASyNplJW5fIQkSZIkaQj5RFCSJElST927fj3nX7R3t+YqdXWuAxNBSeqhYuAz6EmSylScpGdYZt7eun3HPrPE29V5uJgISho6xeUkimszwvAEuqJi4DPoSZJ6qRgji+szOvO2OmUiKGnoFJeTKK7NCAY6SfVQ7GWw/r4xTjxzgAXSwO0bI52dVTNjIihJfVbl6eEl9Vexl8Gdd184wNJIGiUmgipd8Y9eWzPVC8WuMcPaVbQdp4eXNApcQH44VTk+qr9MBFW64h+9VWrNNMgNr2LXGLuKSlJ/uYD8cKpSfLSHzGCZCEpTMMhJkiSVwx4yg2UiqFob1imXJUkapGJ8bDd7s71k1C0nPxouJoKqteITv/PuWGtXUElS7e3bI2bf2ZvtJaNuOfnRcDERlFo4JbMkSZLqwERQ+82BvpIkSVK1mAhqvznQV5pccTwEOCZCktQ/xeUkYHjnRCjGzE0bf8yxr3ntXuf4wKF3TAQljYRhXTepOB4CHBMh1VWxBw3s+4euDUXqteKwFxjeJSX2GUP4yQt5dyGG+sChd0wEJY2EKq2bJKmeij1oYN8/dG0oktQvJoKSJEklKD4B9GmfpGFiIihJklSC4hNAn/ZJGiYmguq5YV0stLg4LrhOoCRJsG+MND5Ko89EUF1pN9C9mOgN62KhxcVxwXUCR9mwTh7TTrHxxBnRJPXbvgvIGx9HWZVipMpjIqiutB3oPiSJntSqSpPHFBtPnBFNklSmKsXIIhtPe8dEUFNyoLvUfwY5SZLas/G0d0wENSUHukv9Z5CTJKk32g1rsoG1wURQe/EJoEZVcTwEOCZCkiQY7TGD7YY12cDaYCKovfgEUKOqOB4C4Lw71o5s4JPUf1VqTHWWULUqxsgqxUeHU8yciWCNjNKj8XZLQRQ/pAxymk6VB8tLGrx2id8HLrlm9/6gGlOL8a/dH/HOEqqpTJcYwvAkhw6nmDkTwRpp92j8phXLKtN62ardUhDFP+INcupWlbrGFP8ArWqjjlRlw9qLphj/bOTS/mrXq2ZYf656sZ71KD08mYqJYM0N65p/M1H8I94ngOrWsD4hLAY12PfJQ7FRpxiw6hLUJO2r3RhpY6RGVS/+tq3LuEITQY2M4h/xPgHUqCgGNdg3sBXPafe0vzVxhNEMalJZ2jWmVKUXTbunOcZI1ZnjChtMBEfIKHcVc7yf1J1RetovDcJ04/9geH6vjJFSdxxX2GAiOEKKj7FH6Yfa8X4ahGJ3qhd+du/QDpaXtH+GdeKXThgjNQjTxUjj4/AzEZSkSezb3Xh7ZQbLS+rOsE78Ig2r6WJkleJjLyaYqSITwYqq8lgFaZRUaaZRqa5GabKkdssn2RVUw6jdJEXDGiPrOpzCRLCi2s1mNEo/tI53UFUM60yjkvYYpRkA2y2fZFdQDaMqLTlRVyaCQ6oXE78M62Pudq2ZxX7lc57f4ngHqc9GecIpqagqMbIYH20YlUbHoOOuiWAPdPuf2K6LyqaNP+bY17x2935xkPpMWi6H9TF3+9bM7SZ+GglV6ira7g/h6T53pvu8G3RQU3lm0r2yFz8PxXsU42W7Y518n6rESOOjRkmVYmRRMWYWP3dm8jk06IkeS00EI+IM4PPALOD6zPxM4fWDgRuBxcAW4H2Z+VDztU8A5wM7gYsy89Yyy7o/uv1PbNut85MX8u4hDEi9YDdP1UknXUWLvxODCoQz+UN4us+7QQe1KqlajJxJ98pe/DzsM4lLIV62O1alnztjpOpkuhg5LPGxnX1iZvFv9wp+DpWWCEbELOA64DRgHFgXEasy8/6W084HfpGZr4mIpcBngfdFxPHAUuAE4CjgWxHx2sy0GWwITfdL67TWqrN2g+WLXZ8dM1E/xsh66OSPWmOk6qwYI42P/VXmE8FTgY2ZuQkgIm4GzgJag9xZwPLm9i3AtRERzeM3Z+bzwE8jYmPzfqX/NEzXBaVdl5TiuILpHh3PZBzCsI5lgH2D2Hl3rLV1U2pqN1i++IfesHaVKX7uwPSfd9O9DnYXbapkjCzqNt61+3mYLs5WOWZOFx/BGKl623cJiqnjIwxPjJxOJ593g/57vsxE8Gjg4Zb9ceBNk52TmTsi4mlgbvP4PxauPbq8ou7xD7f+D+a+8sjd+w+v/w7zDps16T7ALx/+0V77zz76IM8c+eJJryme34niPWdyj04mael2H/YNYtP9UkvaW/F3pvjHYrug14/uM8XPHZj+82661wH+4Qd3gIlg5WLkT39wB8889pO9jj2zcV1X8a7dz0Pxmkd+/APe/UdX797vpMty8ffh2Ucf5MRPXrtf9+gk/k13znTxEYyR0lTa/c5MFyP71b10uu/T7vOu+Pn2D2tO3+seW/75sVLKOpnIzHJuHHE2cHpmfri5/0Hg1Mz831vO2dA8Z7y5/xMarZpXAndl5lebx78ErMnMbxS+xwXABc3dXwUe6EHR5wGbpz2rHqyLBuuhwXrYw7poGGQ9/EpmHj6g773fjJGVZz3sYV00WA8N1sMeg6qLjuNjmU8Ex4FjWvbnA49Ocs54RMwGXgo82eG1ZOZKYGUPy0xE3JOZS3p5z6qyLhqshwbrYQ/rosF62C/GyAqzHvawLhqshwbrYY8q1MUBJd57HXBcRCyKiINoDGxfVThnFXBuc/u9wO3ZeES5ClgaEQdHxCLgOODuEssqSVI/GSMlSQNV2hPB5niGZcCtNKbGviEzN0TElcA9mbkK+BJwU3Og+5M0AiHN875GY9D8DuAPnA1NkjQqjJGSpEErdR3BzFwDrCkcu6xlextw9iTXfgr4VJnlm0RPu9FUnHXRYD00WA97WBcN1sN+MEZWmvWwh3XRYD00WA97DH1dlDZZjCRJkiRpOJU5RlCSJEmSNIRGNhGMiBsi4vGIGGs59oaIuCsi7ouI1RHxkpbXXt98bUPz9TnN44ub+xsj4s+bi/kSEa+IiNsi4sHmvy/v/7ucXjf1EBG/GxHrW752RcRJzdfqVA8HRsRXmsd/FBGfaLnmjIh4oFkPH285vigivtush79qTv4wlLqsi4Mi4svN4z+IiLe1XFP1n4ljIuJ/Nv+PN0TEf2oeb1v+aPjz5vv9YUS8seVe5zbPfzAizm053raOhskM6uHXmj8rz0fEHxfuVfnfjzro5jOg+dpIxkcwRk7osh5GNkZ2WQ/GxxGPj1CDGJmZI/kFvBV4IzDWcmwd8JvN7fOAFc3t2cAPgTc09+cCs5rbdwP/Cgjg74DfaR6/Gvh4c/vjwGcH/Z73tx4K170O2NSyX5t6AM4Bbm5uvwh4CFhIY0KHnwDHAgcBPwCOb573NWBpc/u/Af/boN9zj+riD4AvN7ePAL4HHDAiPxOvAt7Y3H4x8GPg+MnKD7yz+T4D+HXgu83jrwA2Nf99eXP75VPV0TB9zaAejgBOoTE+7Y9b7jMSvx91+OryM2Bk42O3dVG4zhiZoxcju6wH4+OIx8cZ1kWlYuTAK7jk/7yFhV/mZ9gzLvIY4P7m9juBr07yn/9PLfvvB77Q3H4AeFXLeQ8M+v3ubz0UrrkK+FQd66H5/lbT+ANobvOX/hXND6xbW67/RPMraCwYOrt5fK/zhvGri7q4DvhAy3nfprGg9Uj8TBTq5H8Ap01WfuALwPtbzn+g+fru99563lR1NMxf09VDy3nL2TvIjczvRx2+uvgMGOn42E1dFK4xRo5ojOyiHoyPNYuPndRFy3nLqUCMHNmuoZMYA97d3D6bPQvyvhbIiLg1Ir4fERc3jx9NY+HeCePNYwCvzMyfAzT/PaLUkvfWZPXQ6n3Af29u160ebgH+Bfg58DPgTzPzSRrv+eGW6yfqYS7wVGbuKByvksnq4gfAWRExOxrrlS1uvjZSPxMRsRA4Gfguk5d/sv//qY5PVkdDqcN6mMwo/37UgfFxD2NkgzGywfhofARGM0bWLRE8D/iDiPgejce725vHZwNvAX63+e97IuK3aWTpRdmPgpZssnoAICLeBDyXmRN95OtWD6cCO4GjgEXA/xERxzJ5PYxC/UxWFzfQ+FC6B7gGuJPGumWj8J4BiIjDgG8Af5iZz0x1aptjU/3/V6qOuqiHSW/R5ljl6qHGjI97GCMbjJENxseax0cY3RhZ6jqCwyYz/wl4B0BEvBZ4V/OlceA7mbm5+doaGn3EvwrMb7nFfODR5vY/R8SrMvPnEfEq4PE+vIWemKIeJixlT0snNOqnTvVwDvD3mfkC8HhE3AEsodGS09oyPFEPm4GXRcTsZotOa/1UwmR10Xw/fzRxXkTcCTwI/IIR+JmIiANpfLD/35n5183Dk5V/nPb//+PA2wrH/xdT/94MlS7rYTKT1U/lfz/qwPi4hzGywRjZYHysd3yE0Y6RtXoiGBFHNP89ALiUxoBMgFuB10fEiyJiNvCbNPqA/xz4ZUT8enM2o9+j0TcYYBVwbnP73JbjQ2+Kepg4djZw88SxGtbDz4DfioZDaQx8/icaA8aPa87udBCNPwZWZaNT9/8E3tu8vlL1AJPXRfN34tDm9mnAjswcid+NZrm/BPwoMz/X8tJk5V8F/F7z5+LXgaeb9XAr8I6IeHlz1rB30OjfP1UdDY0Z1MNkRvb3ow6Mj3sYIxuMkQ3Gx/rGR6hBjOzXYMR+f9Forfs58AKNLPx84D/RGNT8Y+AzNAf/Ns//ALCBRl/wq1uOL2ke+wlw7cQ1NPr0fptG68+3gVcM+j33qB7eBvxjm/vUph6Aw4CvN38e7gf+pOU+72ye/xPg/2w5fiyNGbA2Nq89eNDvuUd1sZDGgOgfAd8CfmWEfibeQqP7xQ+B9c2vd05WfhrdN65rvt/7gCUt9zqv+X+/Efj96epomL5mUA9HNn9ungGeam6/ZFR+P+rw1c1nQPP8kYyPM6yLt2GMHNkY2WU9LMT4ONLxcYZ1UakYOfGDKUmSJEmqiVp1DZUkSZIkmQhKkiRJUu2YCEqSJElSzZgISpIkSVLNmAhKkiRJUs2YCEoVEBE7I2J9RPwgIr4fEf+6efyoiLhl0OWTJGkQjI/SzLl8hFQBEfFsZh7W3D4duCQzf3PAxZIkaaCMj9LM+URQqp6XAL8AiIiFETHW3P5QRPx1RPx9RDwYEVcPtJSSJPWX8VHqwuxBF0BSRw6JiPXAHOBVwG9Nct5JwMnA88ADEfFfM/PhPpVRkqR+Mz5KM+QTQakatmbmSZn5a8AZwI0REW3O+3ZmPp2Z24D7gV/payklSeov46M0QyaCUsVk5l3APODwNi8/37K9E5/6S5JqwvgodcdEUKqYiPg1YBawZdBlkSRpWBgfpe7YGiJVw8QYCIAAzs3Mne17v0iSVBvGR2mGXD5CkiRJkmrGrqGSJEmSVDMmgpIkSZJUMyaCkiRJklQzJoKSJEmSVDMmgpIkSZJUMyaCkiRJklQzJoKSJEmSVDMmgpIkSZJUM/8/LGcqIqe2SX4AAAAASUVORK5CYII=\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -272,7 +279,7 @@ } ], "source": [ - "dp_sum, ks_sum, ws_sum = dv.aggtest(ag.dp_sum, 'Usage', repeatcount, binsize=\"auto\")" + "dp_sum, ks_sum, ws_sum = dv.aggtest(ag.dp_sum, 'Usage', binsize=\"auto\")" ] }, { @@ -299,29 +306,21 @@ "output_type": "stream", "text": [ "Length of D1: 10000 Length of D2: 9999\n", - "Mean fD1: 1.9876636265683394 Stdev fD1: 0.006520874642442035 Mean fD2: 1.9872102890029528 Stdev fD2: 0.006452524276889024\n", + "Mean fD1: 1.9876735133710504 Stdev fD1: 0.006452983347738146 Mean fD2: 1.9877543708924357 Stdev fD2: 0.0065395613019355375\n", "\n", - "KS 2-sample Test Result: Ks_2sampResult(statistic=0.03270000000000006, pvalue=4.37706169191868e-05) \n", + "KS 2-sample Test Result: Ks_2sampResult(statistic=0.011900000000000022, pvalue=0.4761629208139672) \n", "\n", - "Wasserstein Distance Test: 1.0879407703325743 \n", + "Sum of frequencies in D1 Histogram: 10000\n", + "Sum of frequencies in D2 Histogram: 10000\n", + "Wasserstein Distance Test: 0.11146700832799494 \n", "\n", "DP Predicate Test: True \n", "\n" ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA34AAAF3CAYAAAD6uZn1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzt3X24nlV9J/rvj6AGRQdLgqiRBh2qA7GCRI+nejpap8WWRnSmncvaWtrCRXMUseXMAWXoQYb6UqdjX8Yz7UF0hLYjdaq10lobqrbODAhFE8tGa03B6lYxCcqLCoSEdf7YT+xOsvO67+ft3p/Pde1rP8+6772e314k+fG777XWXa21AAAA0F9HjDsAAAAAhkvhBwAA0HMKPwAAgJ5T+AEAAPScwg8AAKDnFH4AAAA9p/ADAADoOYUfAABAzyn8AAAAek7hBwAA0HNHjjuAxVixYkVbvXr1uMMAYAQ+9alPbWutrRx3HNNCjgRYGg42P0514bd69erccsst4w4DgBGoqn8cdwzTRI4EWBoONj+a6gkAANBzCj8AAICeU/gBAAD03FSv8QNgdw899FBmZ2fzwAMPjDuUw7Z8+fKsWrUqj3jEI8YdCgA9IT8q/AB6ZXZ2No997GOzevXqVNW4wzlkrbXcddddmZ2dzYknnjjucADoCfnRVE+AXnnggQdy7LHHTmVSS5KqyrHHHjvVV2QBmDzyo8IPoHemNantMu3xAzCZpj2/LDZ+hR8AnVq2bFlOPfXUnHLKKXnWs56Vt7/97Xn44YeTJHfddVde9KIX5eijj875558/5kgBYHT2lx+vv/76nH766XnmM5+Z008/PR/72Mc6/3xr/AB67LI3vy2zd27rrL9Vx6/I5ZdctN9zjjrqqGzatClJsmXLlrzyla/MPffck8svvzzLly/PFVdckZmZmczMzHQWFwAciknLjytWrMh1112XJz3pSZmZmckZZ5yRr3zlK53Flyj8AHpt9s5tWbPu3M76m7nuqkM6/7jjjsuVV16Z5zznOXnjG9+YxzzmMXnBC16QzZs3dxYTAByqScuPp5122nePnXLKKXnggQfy4IMP5lGPelRnMZrqCcBQPfWpT83DDz+cLVu2jDsUAJgY+8qP73//+3Paaad1WvQl7vgBMAKttXGHAAATZ8/8eNttt+Xiiy/Ohg0bOv8sd/wAGKrbb789y5Yty3HHHTfuUABgYuyZH2dnZ/Pyl78811xzTZ72tKd1/nnu+EFPdbVo+WAWK8O+bN26NevXr8/5558/9dtoA+Mlr9Ene+bHu+++O2eeeWbe8pa35PnPf/5QPlPhBz3V1aLlQ12sDPfff39OPfXUPPTQQznyyCPzqle9KhdeeOF3j69evTr33ntvtm/fng9+8IPZsGFDTj755DFGDEwDeY1pt7/8+I53vCObN2/OFVdckSuuuCJJsmHDhk5nywyt8Kuqdyf58SRbWmtr5rW/Nsn5SXYk+bPW2kWD9jckOSfJziQXtNb+YlixASwVq45f0en/5Kw6fsUBz9m5c+d+j3/xi1/sKBoAODyTlh8vvfTSXHrppZ3Fs5Bh3vF7T5J3JLlmV0NVvSjJWUm+v7X2YFUdN2g/OckrkpyS5ElJ/rKqvq+1tv//e4Ce6fKZMptuncmadZ10xRQznQkA9rYU8+PQCr/W2ieqavUezf9nkre21h4cnLNr79Kzklw7aL+jqjYneW6SG4cVH0yiLp8pc8PN6zvpBwCA6TfqXT2/L8n/UVU3VdVfV9VzBu1PTvLleefNDtoAAABYpFFv7nJkkscneV6S5yR5X1U9NclCW70t+NCnqjovyXlJcsIJJwwpTAAAgP4Y9R2/2SQfaHNuTvJwkhWD9qfMO29Vkq8u1EFr7crW2trW2tqVK1cOPWAAAIBpN+rC74NJfihJqur7kjwyybYkH0ryiqp6VFWdmOSkJDePODYAGImqendVbamqmT3aX1tVn6+q26rqbfPa31BVmwfHzhh9xABMu6EVflX13sxtzvL0qpqtqnOSvDvJUweJ7tokZw/u/t2W5H1JPpvkI0leY0dPgOm0bNmynHrqqTnllFPyrGc9K29/+9vz8MMPJ0muv/76nH766XnmM5+Z008/PR/72MfGHO3YvCfJS+Y37LHz9SlJfn3QPn/n65ck+S9VtWyk0QKwaPvLj3fddVde9KIX5eijj875558/lM8f5q6eP7WPQz+zj/PflORNw4oHYCn6zTf/P7n7618+8IkH6ZgnPCW/dMl/2O85Rx11VDZt2pQk2bJlS175ylfmnnvuyeWXX54VK1bkuuuuy5Oe9KTMzMzkjDPOyFe+8pXO4psWdr4GGK9Jy4/Lly/PFVdckZmZmczMzOy3n8M16s1dABihu7/+5bzxZd/XWX9v/ODfH9L5xx13XK688so85znPyRvf+Macdtpp3z12yimn5IEHHsiDDz6YRz3qUZ3FOMV27Xz9piQPJPl3rbW/ydwu15+cd56drwEWadLy42Me85i84AUvyObNmzuLaU+jXuMHwBLz1Kc+NQ8//HC2bNmyW/v73//+nHbaaYq+fzJ/5+v/O3M7X1cOcefrqrqlqm7ZunXr8CIFYNH2lR+HxR0/AIautd3rlNtuuy0XX3xxNmzYMKaIJtJ3d75OcnNVHdbO10muTJK1a9cuWBwCMDn2zI/D5I4fAEN1++23Z9myZTnuuOOSJLOzs3n5y1+ea665Jk972tPGHN1EsfM1wBKyZ34cNnf8ABiarVu3Zv369Tn//PNTVbn77rtz5pln5i1veUue//znjzu8sRnsfP3CJCuqajbJZZnb+frdg52vt2ew83WS26pq187XO2Lna1iUjZs25ZwLLlp0P6uOX5HLL1l8PyxNe+bHUVD4AdCp+++/P6eeemoeeuihHHnkkXnVq16VCy+8MEnyjne8I5s3b84VV1yRK664IkmyYcOGkV3tnBR2vobxuX/7jqxZd+6i+5m57qoOomEp2V9+TJLVq1fn3nvvzfbt2/PBD34wGzZsyMknn9zZ5yv8AHrsmCc85ZB3GjtQfweyc+e+b0ZdeumlufTSSzuLBwAOx6TlxyT54he/2FE0C1P4AfTYgZ4pBABL0VLMjzZ3AQAA6DmFHwAAQM8p/AB6ZpTPBBqGaY8fgMk07fllsfEr/AB6ZPny5bnrrrumNrm11nLXXXdl+fLl4w4FgB6RH23uAtArq1atyuzsbLZu3TruUA7b8uXLs2rVqnGHAUCPyI8KP4BeecQjHpETTzxx3GEAwESRH031BAAA6D2FHwAAQM8p/AAAAHpO4QcAANBzCj8AAICeU/gBAAD0nMIPAACg5xR+AAAAPecB7gAADM1lb35bZu/ctuh+Nt06kzXrOggIliiFH3RAUgOAhc3euS1r1p276H5uuHl9B9HA0qXwgw5IagAATDJr/AAAAHpO4QcAANBzCj8AAICeU/gBAAD03NAKv6p6d1VtqaqZBY79u6pqVbVi8L6q6reranNV/W1VPXtYcQEAACw1w7zj954kL9mzsaqekuSHk3xpXvOPJjlp8HVekt8ZYlwAAABLytAKv9baJ5J8Y4FDv5HkoiRtXttZSa5pcz6Z5JiqeuKwYgMAAFhKRrrGr6pemuQrrbXP7HHoyUm+PO/97KANAACARRrZA9yr6tFJ/n2SH1no8AJtbYG2VNV5mZsOmhNOOKGz+AAAAPpqlHf8npbkxCSfqaovJlmV5NNVdXzm7vA9Zd65q5J8daFOWmtXttbWttbWrly5csghA0D3bIAGwKiNrPBrrd3aWjuutba6tbY6c8Xes1trdyb5UJKfHSS35yW5p7X2tVHFBgAj9p7YAA2AERrm4xzem+TGJE+vqtmqOmc/p384ye1JNid5Z5JXDysuABg3G6ABMGpDW+PXWvupAxxfPe91S/KaYcUCAJNu/gZoVbstfd/XBmhmxgBw0Ea2uQsAsDAboAEwbCN9nAMAsCAboAEwVAo/ABgzG6ABMGwKPwAYMRugATBq1vgBwIjZAA2AUVP4Afu1cdOmnHPBRYvuZ9XxK3L5JYvvBwCAQ6fwA/br/u07smbduYvuZ+a6qzqIBgCAw2GNHwAAQM8p/AAAAHpO4QcAANBzCj8AAICeU/gBAAD0nMIPAACg5xR+AAAAPafwAwAA6DkPcAcAgEO0cdOmnHPBRYvuZ9XxK3L5JYvvBw5E4QcAAIfo/u07smbduYvuZ+a6qzqIBg7MVE8AAICeU/gBAAD0nMIPAACg5xR+AAAAPafwAwAA6DmFHwAAQM8p/AAAAHpO4QcAANBzCj8AAICeU/gBAAD0nMIPAACg5xR+AAAAPTe0wq+q3l1VW6pqZl7bf6yqv6uqv62qP66qY+Yde0NVba6qz1fVGcOKCwAAYKkZ5h2/9yR5yR5t1ydZ01r7/iR/n+QNSVJVJyd5RZJTBj/zX6pq2RBjAwAAWDKGVvi11j6R5Bt7tG1ore0YvP1kklWD12cluba19mBr7Y4km5M8d1ixAQAALCXjXOP3C0n+fPD6yUm+PO/Y7KANAACARRpL4VdV/z7JjiR/sKtpgdPaPn72vKq6papu2bp167BCBIChsQ4egFEbeeFXVWcn+fEkP91a21XczSZ5yrzTViX56kI/31q7srW2trW2duXKlcMNFgCG4z2xDh6AERpp4VdVL0lycZKXtta+M+/Qh5K8oqoeVVUnJjkpyc2jjA0ARsU6eABGbZiPc3hvkhuTPL2qZqvqnCTvSPLYJNdX1aaq+t0kaa3dluR9ST6b5CNJXtNa2zms2ABgwlkHD0CnjhxWx621n1qg+V37Of9NSd40rHgAYBosdh18kvOS5IQTThhKfABMp3Hu6gkAzGMdPADDovADgAlgHTwAwzS0qZ4AwMIG6+BfmGRFVc0muSxzu3g+KnPr4JPkk6219a2126pq1zr4HbEOHoDDoPADgBGzDh6AUTPVEwAAoOcUfgAAAD2n8AMAAOg5hR8AAEDPKfwAAAB6TuEHAADQcwo/AACAnlP4AQAA9JzCDwAAoOcUfgAAAD135LgDAABgslz25rdl9s5tnfS16daZrFnXSVfAIij8AADYzeyd27Jm3bmd9HXDzes76QdYHFM9AQAAek7hBwAA0HMKPwAAgJ5T+AEAAPScwg8AAKDnFH4AAAA9p/ADAADoOYUfAABAzyn8AAAAeu7IcQcA43TZm9+W2Tu3LbqfTbfOZM26DgICAIAhUPixpM3euS1r1p276H5uuHl9B9EAAMBwmOoJAADQcwo/AACAnhta4VdV766qLVU1M6/te6rq+qr6wuD74wftVVW/XVWbq+pvq+rZw4oLAABgqRnmHb/3JHnJHm2vT/LR1tpJST46eJ8kP5rkpMHXeUl+Z4hxAQAALClDK/xaa59I8o09ms9KcvXg9dVJXjav/Zo255NJjqmqJw4rNgAAgKVk1Gv8ntBa+1qSDL4fN2h/cpIvzztvdtAGAADAIk3K5i61QFtb8MSq86rqlqq6ZevWrUMOCwC6Zx08AKM26sLv67umcA6+bxm0zyZ5yrzzViX56kIdtNaubK2tba2tXbly5VCDBYAheU+sgwdghEZd+H0oydmD12cn+ZN57T87uKr5vCT37JoSCgB9Yx08AKN2UIVfVb2/qs6sqoMuFKvqvUluTPL0qpqtqnOSvDXJD1fVF5L88OB9knw4ye1JNid5Z5JXH8LvAABjczg5ch+sgwdgaI48yPN+J8nPJ/ntqvrvSd7TWvu7/f1Aa+2n9nHoxQuc25K85iBjAYBJcsg58hAd0jr4zE0HzQknnNBhCABMu4O6Otla+8vW2k8neXaSLya5vqpuqKqfr6pHDDNAAJhkHeZI6+ABGJpDmbp5bJKfS3Juko1JfitzSe76oUQGAFOioxxpHTwAQ3NQUz2r6gNJnpHk95Ksm5dw/rCqbhlWcAAw6Q4nRw7Wwb8wyYqqmk1yWebWvb9vsCb+S0l+cnD6h5P8WObWwX8nc9NKAeCQHOwav6taax+e31BVj2qtPdhaWzuEuABgWhxyjrQOHoBRO9ipnr+6QNuNXQYCAFNKjgRg4u33jl9VHZ+5LaOPqqrT8k87iz0uyaOHHBsATCw5EoBpcqCpnmdkbrH6qiRvn9d+X5JLhhQTAEwDORKAqbHfwq+1dnWSq6vq37TW3j+imABg4smRAEyTA031/JnW2u8nWV1VF+55vLX29gV+DAB6T44EYJocaKrnYwbfjx52IAAwZeRIAKbGgaZ6/n+D75ePJhwAmA5yJADT5EBTPX97f8dbaxd0Gw4ATAc5EoBpcqCpnp8aSRRA723ctCnnXHDRovtZdfyKXH7J4vuBDsiRAEyNg9nVE2DR7t++I2vWnbvofmauu6qDaGDx5EgApsmBpnr+Zmvtl6rquiRtz+OttZcOLTIAmGByJADT5EBTPX9v8P3Xhx0IAEwZORKAqXGgqZ6fGnz/66p6ZJJnZO6q5udba9tHEB8ATCQ5EoBpcqA7fkmSqjozye8m+YckleTEqvrF1tqfDzM4AJh0ciQA0+CgCr8k/ynJi1prm5Okqp6W5M+SSGoALHVyJAAT74iDPG/LroQ2cHuSLUOIBwCmjRwJwMQ70K6e/3rw8raq+nCS92Vu/cJPJvmbIccGABNLjgRgmhxoque6ea+/nuRfDl5vTfL4oUQEANNBjgQWbeOmTTnngos66WvV8Sty+SXd9EX/HGhXz58fVSAAME3kSKAL92/fkTXrzu2kr5nrruqkH/rpYHf1XJ7knCSnJFm+q7219gtDigsApoIcCcA0ONjNXX4vyfFJzkjy10lWJblvWEEBwBSRIwGYeAdb+P3z1tqvJPl2a+3qJGcmeebwwgKAqSFHAjDxDrbwe2jw/e6qWpPknyVZPZSIAGC6yJEATLyDfYD7lVX1+CS/kuRDSY4evAaApU6OBGDiHVTh11rbtUXQXyd56vDCAYDpIkcCMA0OaqpnVR1bVf+5qj5dVZ+qqt+sqmMP90Or6per6raqmqmq91bV8qo6sapuqqovVNUfVtUjD7d/ABiVrnMkAAzDwa7xuzbJliT/JslPJNmW5A8P5wOr6slJLkiytrW2JsmyJK9I8mtJfqO1dlKSb2Zua2wAmHSd5UgAGJaDLfy+p7V2RWvtjsHXryY5ZhGfe2SSo6rqyCSPTvK1JD+U5I8Gx69O8rJF9A8Ao9J1jgSAzh1s4ffxqnpFVR0x+Pq3Sf7scD6wtfaVJL+e5EuZK/juSfKpJHe31nYMTptN8uTD6R8ARqyzHJlYDgHAcOy38Kuq+6rq3iS/mOS/Jdk++Lo2yS8fzgcOdj47K8mJSZ6U5DFJfnSBU9s+fv68qrqlqm7ZunXr4YQAAIs2pBxpOQQAQ7Hfwq+19tjW2uMG349orR05+Dqitfa4w/zMf5Xkjtba1tbaQ0k+kOQHkhwzmPqZJKuSfHUfMV3ZWlvbWlu7cuXKwwwBABZnSDkysRwCgCE42Of4papemuQHB2//qrX2p4f5mV9K8ryqenSS+5O8OMktST6euUXx1yY5O8mfHGb/ADBSXeXI1tpXqmrXcoj7k2yI5RAAdOBgH+fw1iSvS/LZwdfrBm2HrLV2U+auWn46ya2DGK5McnGSC6tqc5Jjk7zrcPoHgFHqMkdaDgHAsBzsHb8fS3Jqa+3hJKmqq5NsTPL6w/nQ1tplSS7bo/n2JM89nP4AYIy6zJHfXQ4x6Gu35RCDu377XQ6RuYupWbt27YLFIQBL08Hu6pnsvjX1P+s6EACYYl3lyO8uh6iqytxyiM/mn5ZDJJZDAHAYDvaO31uSbKyqjyepzK1jeMPQogKA6dFZjmyt3VRVu5ZD7MjcncMrM/d4iGur6lcHbZZDAHBIDlj4Da44/s8kz0vynMwltYtba3cOOTYAmGjDyJGWQwAwDAcs/Fprrao+2Fo7PcmHRhATAEwFORKAaXGwa/w+WVXPGWokADCd5EgAJt7BrvF7UZL1VfXFJN/O3FSW1lr7/mEFBgBTQo4EYOIdbOG30DOEAAA5EoApsN/Cr6qWJ1mf5J9n7mHr7xo8QwgAljQ5EoBpcqA1flcnWZu5hPajSf7T0CMCgOkgRwIwNQ401fPk1tozk6Sq3pXk5uGHBABTQY4EYGoc6I7fQ7temL4CALuRIwGYGge64/esqrp38LqSHDV4v2vHsscNNToAmFxyJABTY7+FX2tt2agCAYBpIkcCME0O9gHuAAAATCmFHwAAQM8p/AAAAHpO4QcAANBzCj8AAICeU/gBAAD03IGe4wcAwJS47M1vy+yd2xbdz6ZbZ7JmXQcBARND4QcA0BOzd27LmnXnLrqfG25e30E0wCQx1RMAAKDnFH4AAAA9p/ADAADoOYUfAABAzyn8AAAAek7hBwAA0HMKPwAAgJ7zHD+mkgfUAgDAwRtL4VdVxyS5KsmaJC3JLyT5fJI/TLI6yReT/NvW2jfHER+TzwNqAQDg4I1rqudvJflIa+0ZSZ6V5HNJXp/ko621k5J8dPAeAACARRp54VdVj0vyg0nelSStte2ttbuTnJXk6sFpVyd52ahjAwAA6KNxTPV8apKtSf5rVT0ryaeSvC7JE1prX0uS1trXquq4McQGY7Vz2x254Z1v6KwvYPpYDgHAMIyj8DsyybOTvLa1dlNV/VYOYVpnVZ2X5LwkOeGEE4YTIYzJUfVgLjzjxE76Wr/xxk76AUZu13KIn6iqRyZ5dJJLMrcc4q1V9frM5c2LxxkkANNlHIXfbJLZ1tpNg/d/lLkE9vWqeuLgbt8Tk2xZ6Idba1cmuTJJ1q5d20YRMACMwrzlED+XzC2HSLK9qs5K8sLBaVcn+aso/FhiupoVY0YMS9XIC7/W2p1V9eWqenpr7fNJXpzks4Ovs5O8dfD9T0YdGwCMmeUQsA9dzYoxI4alalzP8Xttkj8YTGG5PcnPZ26jmfdV1TlJvpTkJ8cUGzDBNm7alHMuuGjR/aw6fkUuv2Tx/UDHLIcAYCjGUvi11jYlWbvAoRePOhZguty/fUcnz3Ccue6qDqKBzlkOAcBQjOuOHzBk279zn7UQMGUshwBgWBR+0FPLj3jYWgiYTpZDANA5hR8ATBDLIWC4zIhhqVL4AQCwZJgRw1J1xLgDAAAAYLgUfgAAAD2n8AMAAOg5a/ygAzu33dHJQvH2wLc6iAYAAHan8IMOHFUPdrJQ/NU37uwgGgAA2J3CDwCAoTErBiaDwg8AgKExKwYmg81dAAAAek7hBwAA0HMKPwAAgJ5T+AEAAPScwg8AAKDnFH4AAAA9p/ADAADoOc/xA/Zr+3fu6+TBuzu33dFBNAAAHA6FH7Bfy494uJMH767feGMH0QAA+7Jx06acc8FFi+5n1fErcvkli++HyaLwAwCAQzSJM2Lu374ja9adu+h+Zq67qoNomDQKPwAAOERmxDBtbO4CAADQcwo/AACAnlP4AQAA9JzCDwAAoOcUfgAAAD2n8AMAAOg5hR8AAEDPKfwAAAB6bmyFX1Utq6qNVfWng/cnVtVNVfWFqvrDqnrkuGIDAADok3He8Xtdks/Ne/9rSX6jtXZSkm8mOWcsUQHAmLk4CkDXjhzHh1bVqiRnJnlTkgurqpL8UJJXDk65Oskbk/zOOOJj6di57Y7c8M43LLqf9sC3OogG4Lt2XRx93OD9rouj11bV72bu4qgcCcBBG0vhl+Q3k1yU5LGD98cmubu1tmPwfjbJk8cRGEvLUfVgLjzjxEX38+obd3YQDYCLo0yGri6MJi6OwqQYeeFXVT+eZEtr7VNV9cJdzQuc2vbx8+clOS9JTjjhhKHECABj5OIoY9fVhdHExVGYFONY4/f8JC+tqi8muTZzVzF/M8kxVbWrEF2V5KsL/XBr7crW2trW2tqVK1eOIl4AGIn5F0fnNy9w6j4vjlbVLVV1y9atW4cSIwDTaeSFX2vtDa21Va211UlekeRjrbWfTvLxJD8xOO3sJH8y6tgAYMxcHAVgKCbpOX4XZ24tw+bMTWt515jjAYCRcnEUgGEZ1+YuSZLW2l8l+avB69uTPHec8QDAhLo4ybVV9atJNsbFUQAO0VgLPwBgYS6OAtAlhR8AwJhd9ua3ZfbObYvuZ9OtM1mzroOAgN5R+AEAjNnsnduyZt25i+7nhpvXdxAN0EeTtLkLAAAAQ+COHyNlKgsAAIyewo+RMpUFAABGz1RPAACAnlP4AQAA9JzCDwAAoOcUfgAAAD1ncxdgJLZ/577c8M43LLqfndvu6CAaAIClReEHjMTyIx7OhWecuOh+1m+8sYNoAGAydHVhNHFxlP1T+AFL0sZNm3LOBRd10teq41fk8ku66QuApaWrC6OJi6Psn8IPWJLu376jk2dKJsnMdVd10g8AwLDY3AUAAKDnFH4AAAA9p/ADAADoOYUfAABAzyn8AAAAek7hBwAA0HMKPwAAgJ5T+AEAAPScwg8AAKDnjhx3AHA4dm67Ize88w2L7qc98K0OogEAgMmm8GMqHVUP5sIzTlx0P6++cWcH0QDAZHBhlC5s3LQp51xw0aL7WXX8ilx+yeL7oRsKPwCAnnBhlC7cv31H1qw7d9H9zFx3VQfR0BVr/AAAAHpO4QcAANBzCj8AAICeG3nhV1VPqaqPV9Xnquq2qnrdoP17qur6qvrC4PvjRx0bAIyTHAnAsIzjjt+OJP9Xa+1fJHlektdU1clJXp/ko621k5J8dPAeAJYSORKAoRh54dda+1pr7dOD1/cl+VySJyc5K8nVg9OuTvKyUccGAOMkRwIwLGNd41dVq5OcluSmJE9orX0tmUt8SY4bX2QAMF5yJABdGlvhV1VHJ3l/kl9qrd17CD93XlXdUlW3bN26dXgBAsCYyJEAdG0shV9VPSJzCe0PWmsfGDR/vaqeODj+xCRbFvrZ1tqVrbW1rbW1K1euHE3AADAiciQAw3DkqD+wqirJu5J8rrX29nmHPpTk7CRvHXz/k1HHBgDjJEdOn8ve/LbM3rlt0f1sunUma9Z1EBDAPoy88Evy/CSvSnJrVW0atF2SuWT2vqo6J8mXkvzkGGIDgHGSI6fM7J3bsmbduYvu54ab13cQDcC+jbzwa639zyS1j8MvHmUswPR6PN7wAAAK70lEQVTZ/p37csM737DofnZuu6ODaKBbciQAwzKOO34Ah235EQ/nwjNOXHQ/6zfe2EE0ADA5XBxlfxR+AADQAy6Osj9jfY4fAAAAw6fwAwAA6DlTPTmgrraqTmxXDQAA46Dw44C62qo6sV01AACMg6meAAAAPeeOHyO1c9sdnWwz3B74VgfRAADA0qDwY6SOqgc72Wb41Tfu7CAaAJgMLowCw6bwAwAYMxdGgWGzxg8AAKDn3PEDWKSNmzblnAsuWnQ/q45fkcsvWXw/AAB7UvgBLNL923d08siTmeuu6iAaAIC9meoJAADQcwo/AACAnjPVE1iStn/nvk62Tk/mtmEHAHZnDfxkUfgBS9LyIx7uZOv0JFm/8cZO+gGASdDVxdFvffULWfMr71h0P9bAd0PhBwAAfFdXF0ddGJ0sCr8eu+zNb8vsndsW3c+mW2eyZl0HAQEAAGOh8Oux2Tu3dbLF/A03r+8gGgCYHC6OAkuNwo8D2rntjs42wWgPfKuTfgBgMbq6OPo/PnxGJzlSfgSGTeHHAR1VD3a2Ccarb9zZST8AMAm6ypHyIzBsnuMHAADQc+74AUwIzzsCAIZF4QcwIe7fvqOTNUeedwRAn7gw2g2FHwAAMLFcGO2Gwg9gkbZ/575OdvXbue2ODqIBgMkgP04WhR/AIi0/4uFOdvVbv/HGDqIBgMkgP04WhV+P3fGZ/5V77/yHRffj2UIATIKuHrqeJJ/c8MdyJLCkTFzhV1UvSfJbSZYluaq19tYxhzS1lm2/Lxee8b8vuh/PFgIYP/mxu4euJ8ktf/77nr8HLCkTVfhV1bIk/2+SH04ym+RvqupDrbXPjjey0erqiuY3vvnNDqIBRqWrtRC3fWZTzrlg8fEs9d3PJon8CCxlk5Yfk+nMkRNV+CV5bpLNrbXbk6Sqrk1yVpKpSGxdFWyf3PDHOfn7v3/R/Tz07XsW3QcwOl2uhbD7We9MdX7sSldLGBJTNGGaTFp+TKYzR05a4ffkJF+e9342yf82zA/ser1AFwXbsm9/3fQT4LBN2pXRabwqOoFGnh+79LIz/1W+/Y0ti+7nG1/9x7zpZxe/hCGRI2Ep6io/JtOZI6u1NpIPOhhV9ZNJzmitnTt4/6okz22tvXbeOeclOW/w9ulJPr+P7lYk6aai6w9jsjdjsjvjsTdjsrdxjcn3ttZWjuFzx+5g8uOgXY48fMZkd8Zjb8Zkb8ZkdxOdHyftjt9skqfMe78qyVfnn9BauzLJlQfqqKpuaa2t7Ta86WZM9mZMdmc89mZM9mZMxuKA+TGRIxfDmOzOeOzNmOzNmOxu0sfjiHEHsIe/SXJSVZ1YVY9M8ookHxpzTAAwbvIjAIsyUXf8Wms7qur8JH+Rue2q391au23MYQHAWMmPACzWRBV+SdJa+3CSD3fQ1QGnuixBxmRvxmR3xmNvxmRvxmQMOsyPif+GCzEmuzMeezMmezMmu5vo8ZiozV0AAADo3qSt8QMAAKBjU1f4VdW7q2pLVc3s4/jjq+qPq+pvq+rmqloz79gxVfVHVfV3VfW5qurmYUBjdrhjUlVPr6pN877urapfGm30w7HIPye/XFW3VdVMVb23qpaPLvLhWOR4vG4wFrf15c9HklTVU6rq44N/C26rqtctcE5V1W9X1ebB2Dx73rGzq+oLg6+zRxt99zoYj49U1d1V9aejjZz55Mi9yZG7kx/3JkfuTn7cW29yZGttqr6S/GCSZyeZ2cfx/5jkssHrZyT56LxjVyc5d/D6kUmOGffvM+4xmXfOsiR3Zu45IGP/ncY1Jpl7SPIdSY4avH9fkp8b9+8zxvFYk2QmyaMztyb4L5OcNO7fp6MxeWKSZw9ePzbJ3yc5eY9zfizJnyepJM9LctOg/XuS3D74/vjB68eP+3ca13gMjr04ybokfzru32Upf8mR3Y7JvHN6kyPlx07HpJc5Un7sdkwGxyYiR07dHb/W2ieSfGM/p5yc5KODc/8uyeqqekJVPS5zf7HfNTi2vbV297DjHYXDHZM9znlxkn9orf3jcKIcrUWOyZFJjqqqIzP3j/lez8qaNosYj3+R5JOtte+01nYk+eskLx92vKPQWvtaa+3Tg9f3Jflc5v7HZr6zklzT5nwyyTFV9cQkZyS5vrX2jdbaN5Ncn+QlIwy/c4scj7TWPprkvlHGzN7kyL3JkbuTH/cmR+5OftxbX3Lk1BV+B+EzSf51klTVc5N8b+YedPvUJFuT/Neq2lhVV1XVY8YX5kjta0zme0WS9444rnFacExaa19J8utJvpTka0nuaa1tGFuUo7OvPyMzSX6wqo6tqkdn7mrWU/bZy5SqqtVJTkty0x6Hnpzky/Pezw7a9tXeC4cxHkwPOXJvcuTu5Me9LdkcKT/ubZpzZB8Lv7cmeXxVbUry2iQbk+zI3FWqZyf5ndbaaUm+neT1Y4tytPY1JkmSmnsY8EuT/PfxhDcWC45JVT0+c1dsTkzypCSPqaqfGV+YI7PgeLTWPpfk1zJ3xe4jmUt+O/bZyxSqqqOTvD/JL7XW7t3z8AI/0vbTPvUOczyYHnLk3uTI3cmPe1uSOVJ+3Nu058iJe47fYg3+I/x8MrfIMnPz0e/I3JSE2dbarur8j7JEktp+xmSXH03y6dba18cQ3ljsZ0zOSHJHa23r4NgHkvxAkt8fU6gjsb8/I621d2Uw/auq3py5K1i9UFWPyNw/4H/QWvvAAqfMZvert6syN7VpNskL92j/q+FEOTqLGA+mhBy5Nzlyd/Lj3pZijpQf99aHHNm7O341tyvZIwdvz03yidbava21O5N8uaqePjj24iSfHUuQI7avMZl3yk9l6UxhSbLfMflSkudV1aMH/7i/OHPzuHttf39Gquq4wfcTMjfVpRd/Vgb/fd+V5HOttbfv47QPJfnZwU5dz8vc1KavJfmLJD9Sczu9PT7JjwzaptYix4MpIUfuTY7cnfy4t6WWI+XHvfUlR07dHb+qem/mriSsqKrZJJcleUSStNZ+N3MLba+pqp2ZS1rnzPvx1yb5g8Ff3tszuHoz7RYzJoM56T+c5BdHHPZQHe6YtNZuqqo/SvLpzE3X2JjkypH/Ah1b5N+b91fVsUkeSvKawWLtPnh+klcluXUwfSdJLklyQvLdcflw5tZsbE7ynQz+zWitfaOqrkjyN4Of+w+ttf1tDDANDns8kqSq/kfmdrs7evBn7JzW2tQn+2kjR+5Njtyd/Lg3OXIv8uPeepEjq7WJmnoKAABAx3o31RMAAIDdKfwAAAB6TuEHAADQcwo/AACAnlP4AQAA9JzCDyZQVe2sqk1V9Zmq+nRV/cCg/UmD7bQBYEmSI+HweJwDTKCq+lZr7ejB6zOSXNJa+5djDgsAxk6OhMPjjh9Mvscl+WaSVNXqqpoZvP65qvpAVX2kqr5QVW8ba5QAMHpyJBykI8cdALCgo6pqU5LlSZ6Y5If2cd6pSU5L8mCSz1fVf26tfXlEMQLAOMiRcBjc8YPJdH9r7dTW2jOSvCTJNVVVC5z30dbaPa21B5J8Nsn3jjRKABg9ORIOg8IPJlxr7cYkK5KsXODwg/Ne74y7+AAsIXIkHDyFH0y4qnpGkmVJ7hp3LAAwSeRIOHiufMBk2rV+IUkqydmttZ0Lz2QBgCVFjoTD4HEOAAAAPWeqJwAAQM8p/AAAAHpO4QcAANBzCj8AAICeU/gBAAD0nMIPAACg5xR+AAAAPafwAwAA6Ln/H0j1V09F64SIAAAAAElFTkSuQmCC\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "dp_mean, ks_mean, ws_mean = dv.aggtest(ag.dp_mean, 'Usage', repeatcount, numbins=20, debug=False)" + "dp_mean, ks_mean, ws_mean = dv.aggtest(ag.dp_mean, 'Usage', binsize=\"auto\", debug=False, plot=False)" ] }, { @@ -348,11 +347,13 @@ "output_type": "stream", "text": [ "Length of D1: 10000 Length of D2: 9999\n", - "Mean fD1: 1.9218929089727805 Stdev fD1: 0.09343698293973973 Mean fD2: 1.923278714473025 Stdev fD2: 0.09223470961719851\n", + "Mean fD1: 1.9214863441107908 Stdev fD1: 0.09351969187972314 Mean fD2: 1.9207301039248574 Stdev fD2: 0.09290377895922441\n", "\n", - "KS 2-sample Test Result: Ks_2sampResult(statistic=0.013399999999999967, pvalue=0.32852783417368236) \n", + "KS 2-sample Test Result: Ks_2sampResult(statistic=0.016100000000000003, pvalue=0.14833515907692768) \n", "\n", - "Wasserstein Distance Test: 0.03455225330940635 \n", + "Sum of frequencies in D1 Histogram: 10000\n", + "Sum of frequencies in D2 Histogram: 10000\n", + "Wasserstein Distance Test: 2.792452830188679 \n", "\n", "DP Predicate Test: True \n", "\n" @@ -360,9 +361,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -370,7 +371,14 @@ } ], "source": [ - "dp_var, ks_var, ws_var = dv.aggtest(ag.dp_var, 'Usage', repeatcount, numbins=20, debug=False)" + "dp_var, ks_var, ws_var = dv.aggtest(ag.dp_var, 'Usage', binsize=\"auto\", debug=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Noisy variance passes the DP Predicate test" ] }, { @@ -390,11 +398,13 @@ "output_type": "stream", "text": [ "Length of D1: 10000 Length of D2: 9999\n", - "Mean fD1: 10000.045819315685 Stdev fD1: 5.280400266597634 Mean fD2: 9998.913416666743 Stdev fD2: 5.381320406660306\n", + "Mean fD1: 10000.066658725324 Stdev fD1: 5.302403755821169 Mean fD2: 9998.910497724642 Stdev fD2: 5.393025835237107\n", "\n", - "KS 2-sample Test Result: Ks_2sampResult(statistic=0.09160000000000001, pvalue=5.443764204731642e-37) \n", + "KS 2-sample Test Result: Ks_2sampResult(statistic=0.09420000000000006, pvalue=4.2725799439035885e-39) \n", "\n", - "Wasserstein Distance Test: 0.0012453653001820832 \n", + "Sum of frequencies in D1 Histogram: 10000\n", + "Sum of frequencies in D2 Histogram: 10000\n", + "Wasserstein Distance Test: 5.064935064935066 \n", "\n", "DP Predicate Test: True \n", "\n" @@ -402,9 +412,9 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4MAAAF3CAYAAAAfC57cAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzt3X+cFfWd5/v3R1Cb6EQSfuhGcMAoM1dJgkpMcpONk2QTzORBwB3dECfGNXhdxrDq5e4S5RpsYJZEH7OJM6OPnSg61x/zGM3oDsKECCZmkywQEKeb6YaM2IIJremGbhoEgXPo7s/94xSHU9XddDecOlXn1Ov5ePSD861TdfrTZcPHT9W3Pl9zdwEAAAAAsuWMpAMAAAAAAFQexSAAAAAAZBDFIAAAAABkEMUgAAAAAGQQxSAAAAAAZBDFIAAAAABkEMUgAAAAAGQQxSAAAAAAZBDFIAAAAABkEMUgAAAAAGTQyKQDKJexY8f6pEmTkg4DAFABr776aoe7j0s6jmpBjgSAbBhufqyZYnDSpEnasmVL0mEAACrAzH6TdAzVhBwJANkw3PzINFEAAAAAyCCKQQAAAADIIIpBAAAAAMigmnlmEAAQduzYMbW2turo0aNJh3LK6urqNGHCBJ155plJhwIAqBHkxxMoBgGgRrW2tur3fu/3NGnSJJlZ0uEMm7urs7NTra2tmjx5ctLhAABqBPnxBKaJAkCNOnr0qMaMGVOViU6SzExjxoyp6iu3AID0IT+eQDEIADWsWhPdcdUePwAgnao9v5QrfopBAEBsRowYoWnTpunyyy/XRz7yEX3ve99Tb2+vJKmzs1Of+cxndO6552r+/PkJRwoAQOWcLD++9NJLuuqqq/ShD31IV111lV5++eXY4uCZQQDIiPuWP6DWto6yfd6EC8ZqyaKFJ91n1KhRamxslCTt2bNHN954ow4cOKAlS5aorq5Oy5YtU3Nzs5qbm8sWFwAAw5G2/Dh27FitXr1aH/jAB9Tc3KwZM2borbfeKlt8pWItBs3sWkl/KWmEpBXu/t3I+2dLelLSVZI6JX3F3d80szMlrZB0ZRDjk+7+nThjBYBa19rWoakzby3b5zWvXjGs/cePH69HHnlEH/3oR1VfX69zzjlHn/rUp9TS0lK2mKoF+REA0iNt+fGKK64ovnf55Zfr6NGjyuVyOvvss8sW43GxTRM1sxGSHpb0RUmXSfqqmV0W2W2upC53v0TS9yXdH2y/QdLZ7v4hFRLhfzKzSXHFCgCojIsvvli9vb3as2dP0qEkhvwIAIgaKD8+//zzuuKKK2IpBKV4nxm8WlKLu+9097ykZyTNiuwzS9ITwevnJH3OCk9DuqRzzGykpFGS8pLeiTFWAECFuHvSISSN/AgA6COaH7dt26Zvfetb+sEPfhDb94yzGLxQ0u6ScWuwrd993L1b0gFJY1RIfO9K+p2k30r6C3ffF2OsAIAK2Llzp0aMGKHx48cnHUqSyI8AgJBofmxtbdV1112nJ598Uh/84Adj+75xPjPYX7/T6OXggfa5WlKPpA9Iep+kX5rZT9x9Z+hgs9sk3SZJF1100WkHDNSyB5cv1v723aFto8+fqLsWLU0oImTN3r17NW/ePM2fP7/qW3qfptjzo0SOBIYj2kBkKA1AgHKJ5sf9+/frS1/6kr7zne/ok5/8ZKzfO85isFXSxJLxBElvD7BPazDl5TxJ+yTdKOlFdz8maY+ZrZc0XVIo2bn7I5IekaTp06dnft4RcDL723erfvaU0Lb6lTsSigZZceTIEU2bNk3Hjh3TyJEjddNNN2nBggXF9ydNmqR33nlH+XxeK1eu1Lp163TZZdHH52pO7PlRIkcCwxFtIDLcBiDAcJ0sPz700ENqaWnRsmXLtGzZMknSunXrYplVE2cx+IqkS81ssqS3JM1RIYmVWiXpZkkbJV0v6WV3dzP7raTPmtnTkt4j6eOSHowxVgCoeRMuGFvW/8GZcMHYQffp6ek56ftvvvlmmaKpKuRHAEiRtOXHe++9V/fee2/Z4jmZ2IpBd+82s/mS1qrQOvtxd99mZkslbXH3VZIek/SUmbWocMVzTnD4w5L+VlKzClNl/tbd/yWuWAEgC5jylA7kRwBIlyznx1jXGXT3NZLWRLYtLnl9VIU22dHjDvW3HQCAWkB+BACkQZzdRAEAAAAAKUUxCAAAAAAZRDEIAAAAABlEMQgAAAAAGUQxCACIzYgRIzRt2jRdfvnl+shHPqLvfe976u3tlSS99NJLuuqqq/ShD31IV111lV5++eWEowUAoDJOlh87Ozv1mc98Rueee67mz58faxyxdhMFkB4NTc16oe43kW0HE4oGSXhw+WLtb99dts8bff5E3bVo6Un3GTVqlBobGyVJe/bs0Y033qgDBw5oyZIlGjt2rFavXq0PfOADam5u1owZM/TWW2+VLT4AGKpdW9frnbY3iuPO9rYEo0GlpS0/1tXVadmyZWpublZzc3PZ4uoPxSCQEYeP5DR+yjXhbb9Yl1A0SML+9t2qnz2lbJ9Xv3LHsPYfP368HnnkEX30ox9VfX29rrjiiuJ7l19+uY4ePapcLqezzz67bDECwFCMyB/UghmfKI4Xr3g9wWhQaWnLj+ecc44+9alPqaWlpWwxDYRpogCAirn44ovV29urPXv2hLY///zzuuKKKygEAQCZNFB+jBt3BgEAFeXuofG2bdv0rW99S+vWcacaAJBd0fxYCdwZBABUzM6dOzVixAiNHz9ektTa2qrrrrtOTz75pD74wQ8mHB0AAMmI5sdKoRgEAFTE3r17NW/ePM2fP19mpv379+tLX/qSvvOd7+iTn/xk0uEBAJCIaH6sJKaJAgBic+TIEU2bNk3Hjh3TyJEjddNNN2nBggWSpIceekgtLS1atmyZli1bJklat25dxa+KAgBQaSfLj5I0adIkvfPOO8rn81q5cqXWrVunyy67rOxxUAwCQEaMPn/isDucDfZ5g+np6RnwvXvvvVf33ntv2eIBAOBUpC0/StKbb75ZpmhOjmIQqALR9W+Gsn4NEMXvDIBadN/yB9Ta1lEcT7hgrJYsWphgRKg2Wc6PFINAFYiuf1POq1cAAFSz1rYOTZ15a3HcvHpFgtEA1YViEMBJccUVAIC+orN2JGbuoPpQDAI4Ka64Vjd3r3hnsnJKYs0lABiK6KwdiZk71YT8WMDSEgBQo+rq6tTZ2Vm1BZW7q7OzU3V1dUmHAgCoIeTHE7gzCNSo6PTOfV1dCUaDJEyYMEGtra3au3dv0qGcsrq6Ok2YMCHpMADUmOgUz4P72hOMBpVGfjyBYhCoUdHpnVt+/HSC0SAJZ555piZPnpx0GACQOtEpnmvXrEowGlQa+fEEikEghaJXLLc3NUqR5xIGO2bX1h2hYhAAgGoXnfUiSY1NzZo6c3jHdDQ3D5pXgSygGARSKHrFcvbm9cM+5vObXx329z2VJAsAQKVEZ71I0obN84Z9zJpXXhz29z6VC7VA2lEMAig6lSQLAEAWnMqFWiDt6CYKAAAAABlEMQgAAAAAGUQxCAAAAAAZxDODQI3q2rtHGx69pzj2o4fK8rkNjY2ae8fC4njCBWO1ZNHCkxwBAEC6dO7bpxdefKk4zudzZfncrY0Nqr/zluJ49PkTddeipWX5bCAOFINAjTrTjmnBjBNr6Ny+sacsn3sk3x1qMtO8ekVZPhcAgErp6e3V+ClXFse9vZvK8rmePxxqMlO/ckdZPheIC9NEAQAAACCDuDMIZFjnvn2hKZ+sKQgAQOFRi9LpnhLrCqI2xVoMmtm1kv5S0ghJK9z9u5H3z5b0pKSrJHVK+oq7v2lmfyrpv5bs+mFJV7p7Y5zxAlnT09sbmvLJmoJAZZAfgXQ7046FpntKrCuI2hTbNFEzGyHpYUlflHSZpK+a2WWR3eZK6nL3SyR9X9L9kuTuf+fu09x9mqSbJL1JogMA1ALyIwAgLeJ8ZvBqSS3uvtPd85KekTQrss8sSU8Er5+T9Dkzs8g+X5X09zHGCQBAJZEfAQCpEGcxeKGk3SXj1mBbv/u4e7ekA5LGRPb5ikh2AIDaQX4EAKRCnMVg9AqmJPlw9jGzj0k67O7N/X4Ds9vMbIuZbdm7d++pRwoAQOXEnh+DfciRAICTirMYbJU0sWQ8QdLbA+1jZiMlnSdpX8n7c3SSq57u/oi7T3f36ePGjStL0AAAxCz2/CiRIwEAg4uzGHxF0qVmNtnMzlIhca2K7LNK0s3B6+slvezuLklmdoakG1R4lgIAgFpBfgQApEJsS0u4e7eZzZe0VoXW2Y+7+zYzWyppi7uvkvSYpKfMrEWFK55zSj7i05Ja3X1nXDEC1aKzq0svvPhScdzQdDDBaACcDvIjUF49Hbu04dF7iuPO9rYEowGqS6zrDLr7GklrItsWl7w+qsLVzf6O/V+SPh5nfEC16O7p1fgpVxbHh3+xrmLfO5pkezp2Vex7A7WK/AiUzyjLacGMycXx4hWvV+T7Ri/UHt8GVJNYi0EA1S+aZOc1bAy939DYqLl3LAxtm3DBWC1ZFN4GAEAtiV6oLWzbGhpvbWxQ/Z23FMejz5+ouxYtrUh8wFBQDAJVqGvvnlBykaTtTY3S7CkVj+VIvltTZ94a2ta8ekXF4wAAQJI69+0LXaRsbGrW1JnJxOL5w6ovyc31K3ckEwgwAIpBoAqdacdCyUWSZm9en1A0AACkR09vb+gi5YbN8xKMBki3OLuJAgAAAABSijuDQAo1NDXrhbrfFMf5fC7BaAAASIddW9frnbY3Qtv86KGEogGqH8UgkEKHj+Q0fso1xXFv76ZYvk/+8EE6hQIAqsaI/EEtmPGJ0LbbN/aU/fvkcjk6hSITKAaBhD24fLH2t+8ObTu4r70i37vujN6TdgoFACBJ9y1/QK1tHcXxvgoVZO4+aKdQoBZQDAIJ29++u08zmLVrViUUDQAA6dHa1hFqBrPlx08nGA1QeygGgRoRXfyW5wwBACg8AlH6SITEc4bAcRSDQI2ILn4b13OGAABUk1GWCz0SIcXznCFQjVhaAgAAAAAyiGIQAAAAADKIaaIAyq6hsVFz71hYHE+4YKyWLFp4kiMAAKh9WxsbVH/nLaFto8+fqLsWLU0oImQdxSCAsjuS7w51f2tevSLBaAAASAfPH+7TQbx+5Y6EogGYJgoAAAAAmUQxCAAAAAAZxDRRoArlcrnQmoJSedYVzB8+yFpMAICqFs1l5cpj0dzLer6oBRSDQIweXL5Y+9t3h7aV40Fxdw+tKSiVZ13BujN6WYsJAFAR9y1/QK1tHcVxuZqNRXNZufJYNPeyni9qAcUgEKP97bt5UBwAgH60tnXQbAxIGM8MAgAAAEAGcWcQqLDoGkPbmxqlyN1DAACyJrpGrSQ1NjVr6syEAgIygGIQqLDoGkOzN69PMBoAANIhukatJG3YPC+haIBsYJooAAAAAGQQxSAAAAAAZBDFIAAAAABkEMUgAAAAAGQQxSAAAAAAZBDdRAEMS/7wQW149J7iuKdjV4LRAACQHrlcTi+8+FJx3NnVlWA0wOAoBgEMS90ZvVowY3JxPK9hY4LRAACQHu6u8VOuLI67e7YmGA0wOKaJAgAAAEAGxVoMmtm1ZvaambWY2d39vH+2mT0bvL/JzCaVvPdhM9toZtvMrMnM6uKMFQCASiE/AgDSILZi0MxGSHpY0hclXSbpq2Z2WWS3uZK63P0SSd+XdH9w7EhJT0ua5+6XS/ojScfiihUAgEohPwIA0iLOO4NXS2px953unpf0jKRZkX1mSXoieP2cpM+ZmUn6gqR/cfetkuTune7eE2OsAABUCvkRAJAKcTaQuVDS7pJxq6SPDbSPu3eb2QFJYyRNkeRmtlbSOEnPuPsDMcYKoIx6OnaFOo52trclGA2QOuRHIKM6u7pC3UYlqaHpYELRAPEWg9bPNh/iPiMlfUrSRyUdlvRTM3vV3X8aOtjsNkm3SdJFF1102gEDKI9Rlgt1HF284vUEowFSJ/b8KJEjgTTq7ukNdRuVpMO/WJdQNEC800RbJU0sGU+Q9PZA+wTPQZwnaV+w/efu3uHuhyWtkXRl5Fi5+yPuPt3dp48bNy6GHwEAgLKLPT9K5EgAwODiLAZfkXSpmU02s7MkzZG0KrLPKkk3B6+vl/Syu7uktZI+bGbvCZLgNZK2xxgrAACVQn4EAKRCbNNEg2cc5quQuEZIetzdt5nZUklb3H2VpMckPWVmLSpc8ZwTHNtlZt9TIWG6pDXu/qO4YgUAoFLIjwCAtIjzmUG5+xoVprCUbltc8vqopBsGOPZpFdpnA1XjweWLtb/9RF+I7U2N0uwpCUYUv/zhg6FmMZLkRw8lFA1QHciPyKL7lj+g1raO4rixqVlTZyYYUAXkcrlQw5h8PpdgNEBfsRaDQNbsb9+t+pLib/bm9QlGUxl1Z/SGmsVI0u0b6XQPAAhrbevQ1Jm3FscbNs9LMJrKcPdQw5je3k0JRgP0RTEIIHad+/Zp7h0LQ9smXDBWSxYtHOAIAACyoWvvHtXfeUtxPPr8ibpr0dIEI0KWUAwCiF1Pb2/oarAkNa9ekVA0AACkx5l2LDSrqH7ljgSjQdbE2U0UAAAAAJBS3BkEEtbZ1RV6uFziAXMAACSpp2NXqEkZDcqA8qIYBBLW3dMberhc4gFzAAAkaZTlQk3KaFAGlBfTRAEAAAAggygGAQAAACCDKAYBAAAAIIMoBgEAAAAggygGAQAAACCDKAYBAAAAIIMoBgEAAAAggygGAQAAACCDWHQeqLDOri698OJLxXE+n0swGgAA0qGnY5c2PHpPaJsfPZRQNEA2UAwCFdbd06vxU64sjnt7NyUYTWXkDx/sk+A729sSigYAkEajLKcFMyaHtt2+sSehaConl8uFLhI3NB1MMBpkDcUgcBoeXL5Y+9t3F8fbmxql2VMSjCid6s7o7ZPgv/nAJs29Y2FxvLNlhy6+5MS5m3DBWC1ZtFAAgOpz3/IH1NrWEdrW2NSsqTMTCijF3D10kfit559W/Z23FMevtezUH1xyceiY0edP1F2LllYsRtQuikHgNOxv3636kuJv9ub1ofejU0IlpoUe19Pbq6kzby2ON3x7nr5cMm5evSKJsAAAZdDa1hH6N16SNmyeFxpHp4UyJbTgTDsW/n+LRetVP/va0D71K3dUOizUKIpBIEbRKaFSNqaFAgAwmOi00CxMCQXShm6iAAAAAJBBFIMAAAAAkEEUgwAAAACQQRSDAAAAAJBBFIMAAAAAkEEUgwAAAACQQRSDAAAAAJBBFIMAAAAAkEEUgwAAAACQQRSDAAAAAJBBFIMAAAAAkEGxFoNmdq2ZvWZmLWZ2dz/vn21mzwbvbzKzScH2SWZ2xMwag6+/iTNOAAAqifwIAEiDkXF9sJmNkPSwpM9LapX0ipmtcvftJbvNldTl7peY2RxJ90v6SvDeG+4+La74gDh0dnXphRdfKo7z+VyC0QBII/IjsqqnY5c2PHpPcexHDyUYDQApxmJQ0tWSWtx9pySZ2TOSZkkqTXazJNUHr5+T9JCZWYwxAbHq7unV+ClXFse9vZsSjAZASpEfkUmjLKcFMyYXx7dv7EkwGgBSvMXghZJ2l4xbJX1soH3cvdvMDkgaE7w32cwaJL0j6V53/2WMsQKDenD5Yu1v3x3atr2pUZo9JaGIAFQp8iNqzn3LH1BrW0dx3NjUrKkzEwwIwJDEWQz2dwXTh7jP7yRd5O6dZnaVpJVmdrm7vxM62Ow2SbdJ0kUXXVSGkIGB7W/frfpI4Td78/qEogFQxWLPjxI5EpXV2tahqTNvLY43bJ6XYDQAhirOBjKtkiaWjCdIenugfcxspKTzJO1z95y7d0qSu78q6Q1JfW6/uPsj7j7d3aePGzcuhh8BAICyiz0/Bu+TIwEAJxVnMfiKpEvNbLKZnSVpjqRVkX1WSbo5eH29pJfd3c1sXPCAvczsYkmXStoZY6wAAFQK+REAkAqxTRMNnnGYL2mtpBGSHnf3bWa2VNIWd18l6TFJT5lZi6R9KiRESfq0pKVm1i2pR9I8d98XV6wAAFQK+REAkBZxPjMod18jaU1k2+KS10cl3dDPcc9Lej7O2AAASAr5EQCQBrEuOg8AAAAASKchFYNm9ryZfcnMKB4BAChBjgQAVKuhThP9H5JukfRXZvYPkv4/d//X+MICgL6i61hNuGCslixamGBEgCRyJICE9bcW8ujzJ+quRUsTigjVYkjFoLv/RNJPzOw8SV+V9JKZ7Zb0qKSn3f1YjDECyKCGxkbNvSNc6DU2Netrix4sjptXr6h0WEAf5EgAlba1sUH1d95SHG9vatQPv/0fQvvUr9xR6bBQhYbcQMbMxkj6mqSbJDVI+jtJn1Kh9fUfxREcgOw6ku8OLWAssYgx0oscCaCSPH9Y9bNPLDE6e/P6BKNBNRtSMWhm/1PSH0p6StJMd/9d8NazZrYlruAAAEg7ciQAoFoN9c7giqANdpGZne3uOXefHkNcAABUC3IkAKAqDbXz2Z/3s21jOQMBAKBKkSMBAFXppHcGzewCSRdKGmVmV0iy4K33SnpPzLEBAJBa5EgAQLUbbJroDEn/UdIESd8r2X5Q0qKYYgIAoBqQIwEAVe2kxaC7PyHpCTP7E3d/vkIxAQCQeuRIAEC1G2ya6Nfc/WlJk8xsQfR9d/9eP4cBAFDzyJEAgGo32DTRc4I/z407EAAAqgw5EgBQ1QabJvqD4M8llQkHAIDqQI4EAFS7waaJ/tXJ3nf3O8obDgAA1YEcCQCodoNNE321IlEAAFB9yJEAgKo2lG6iAAAgghwJAKh2g00TfdDd7zKz1ZI8+r67fzm2yAAASDFyJACg2g02TfSp4M+/iDsQoBp1dnXphRdfKo7z+VyC0QCoMHIkMICejl3a8Og9oW1+9FBC0QAYyGDTRF8N/vy5mZ0l6Q9VuPr5mrvnKxAfkGrdPb0aP+XK4ri3d1OC0QCoJHIkMLBRltOCGZND227f2JNQNAAGMtidQUmSmX1J0t9IekOSSZpsZv/J3X8cZ3AAAKQdORIAUK2GVAxK+u+SPuPuLZJkZh+U9CNJJDoAQNaRIwEAVWmoxeCe40kusFPSnhjiAZAR+cMHQ8+T9HTsSjAa4LSQIwGUTS6XC/Uj6OzqSjAa1LrBuon+++DlNjNbI+mHKjwPcYOkV2KODUANqzujN/Q8ybyGjQlGAwwfORJAHNw91I+gu2drgtGg1g12Z3Bmyet2SdcEr/dKel8sEQEAUB3IkQCAqjZYN9FbKhUIAADVhBwJAKh2Q+0mWidprqTLJdUd3+7u34gpLgAAqgI5EgBQrc4Y4n5PSbpA0gxJP5c0QdLBuIICAKCKkCMBAFVpqMXgJe7+bUnvuvsTkr4k6UPxhQUAQNUgRwIAqtJQi8FjwZ/7zWyqpPMkTYolIgAAqgs5EgBQlYZaDD5iZu+T9G1JqyRtl3T/YAeZ2bVm9pqZtZjZ3f28f7aZPRu8v8nMJkXev8jMDpnZfxlinAAAVNqwcyT5EQCQBkNqIOPuK4KXP5d08VCOMbMRkh6W9HlJrZJeMbNV7r69ZLe5krrc/RIzm6NC8vxKyfvfl/TjoXw/AACSMNwcSX4EAKTFkO4MmtkYM/trM/tnM3vVzB40szGDHHa1pBZ33+nueUnPSJoV2WeWpCeC189J+pyZWfA9Z0vaKWnbUH8YAAAq7RRyJPkRAJAKQ7ozqEKi+oWkPwnGfyrpWUn/7iTHXChpd8m4VdLHBtrH3bvN7ICkMWZ2RNK3VLhqyhQYpEJDU7NeqPtNaFs+n0soGgApMtwcSX5Ezdm1db3eaXujOPajhxKMBsBQDbUYfL+7LysZ/3lwZfJkrJ9tPsR9lkj6vrsfCi6E9v8NzG6TdJskXXTRRYOEA5yew0dyGj/lmtC23t5NCUWD/ty3/AG1tnWEtk24YKyWLFqYUETIiOHmyNjzo0SORGWNyB/UghmfKI5v39iTYDToz4PLF2t/+4nrUKPPn6i7Fi1NMCKkwVCLwZ8Fzyz8MBhfL+lHgxzTKmliyXiCpLcH2KfVzEaq0IFtnwpXSK83swckjZbUa2ZH3f2h0oPd/RFJj0jS9OnTo4kUQMa0tnVo6sxbQ9uaV68YYG+gbIabI2PPjxI5EkDY/vbdqp89pTiuX7kjwWiQFictBs3soApXIk3SAklPB2+dIemQpPtOcvgrki41s8mS3pI0R9KNkX1WSbpZ0kYVkufL7u6S/m1JDPWSDvWX6ADUjvzhg9rw6D3FcU/HrgSjAQZ3GjmS/AhgyHK5nF548aXQts6uroSiQa05aTHo7r93qh8cPOMwX9JaSSMkPe7u28xsqaQt7r5K0mOSnjKzFhWueM451e8HoLrVndGrBTMmF8fzGjYOekxDY6Pm3nFiCmhjU7OmzowlPKCPU82R5EcAw+HuGj/lytC27p6tgx63tbFB9XfeUhxvb2qUSu4MAtLQp4nKzL4s6dPB8H+5+z8Ndoy7r5G0JrJtccnro5JuGOQz6ocaI4BsOZLvDk0L3bB5XoLRIMuGmyPJjwDi5vnDoWmhszevTzAapNVQl5b4rqQ7VVhId7ukO4NtAABkGjkSAFCthnpn8I8lTXP3XkkysyckNUi6O67AgKRFu24d3NeeYDQAUowcicyJdm/exzNsQFUa8jRRFbqW7QtenxdDLECqRLturV2zKsFoAKQcORKZEu3evOXHT59kbwBpNdRi8DuSGszsZyp0Tfu0pHtOfggAAJlAjgQAVKVBi0ErrGr7vyV9XNJHVUh033L3tphjA5Bh0aUmJJabQPqQIwEkIbrcBEtN4FQNWgy6u5vZSne/SoV1jwAgdtGlJqShLTcBVBI5EkASostNDGWpCaA/Q+omKulXZvbRWCMBAKA6kSMBAFVpqM8MfkbSPDN7U9K7KkyDcXf/cFyBAQBQJciRAICqNNRi8IuxRgEAQPUiRwIAqtJJi0Ezq5M0T9IlkpokPebu3ZUIDACANCNHAgCq3WB3Bp+QdEzSL1W48nmZpDvjDgoAhqKnY1eo4yjdRlFh5EgAqdXZ1UXHUQxqsGLwMnf/kCSZ2WOSNscfEgAMzShXekKOAAAdzElEQVTLhTqO0m0UFUaOBJBa3T29dBzFoAbrJnrs+AumvgAAEEKOBABUtcHuDH7EzN4JXpukUcH4eKe098YaHQAA6UWOBABUtZMWg+4+olKBAJX04PLF2t++O7Rt9PkTddeipQlFBKDakCNRq+5b/oBa2zqK4wkXjNWSRQsTjAhAXIa6tARQU/a371b97CmhbdfVPxsqELc3NUqRfQAAqHWtbR2aOvPW4vipZfNDxaEkNTY1a+rMSkcGoNwoBoGA5w+HCsTZm9cnGA0AAOlwJN8dKg4lacPmeQlFA6CcBmsgAwAAAACoQRSDAAAAAJBBTBMFUDXyhw+GFpn3o4cSjAYAgHTI5XKhBeYlKZ/PJRQNqgnFIICqUXdGb2iR+ds39iQYDQAA6eDuoQXmJam3d1NC0aCaME0UAAAAADKIYhAAAAAAMohiEAAAAAAyiGcGgQF0dnWFHsbmQWwAAAp6OnbR0AuoARSDwAC6e3pDD2PzIDYAAAWjLEdDL6AGME0UAAAAADKIYhAAAAAAMohiEAAAAAAyKNZi0MyuNbPXzKzFzO7u5/2zzezZ4P1NZjYp2H61mTUGX1vN7Lo44wQAoJLIjwCANIitGDSzEZIelvRFSZdJ+qqZXRbZba6kLne/RNL3Jd0fbG+WNN3dp0m6VtIPzIxmNwCAqkd+BACkRZx3Bq+W1OLuO909L+kZSbMi+8yS9ETw+jlJnzMzc/fD7t4dbK+T5DHGCQBAJZEfAQCpEGcxeKGk3SXj1mBbv/sEye2ApDGSZGYfM7NtkpokzStJfgAAVDPyIwAgFeIsBq2fbdErmAPu4+6b3P1ySR+VdI+Z1fX5Bma3mdkWM9uyd+/e0w4YAIAKiD0/SuRIAMDg4nzOoFXSxJLxBElvD7BPa/DMw3mS9pXu4O6/NrN3JU2VtCXy3iOSHpGk6dOnM1UGA3pw+WLtbz9xIX57U6M0e0qCEQHIsNjzY/A+ORKDum/5A2pt6whta2xq1tSZCQUEoKLiLAZfkXSpmU2W9JakOZJujOyzStLNkjZKul7Sy+7uwTG73b3bzH5f0h9IejPGWFHj9rfvVn1J8Td78/oEowGQceRHpEZrW4emzrw1tG3D5nkJRQOg0mIrBoNENV/SWkkjJD3u7tvMbKmkLe6+StJjkp4ysxYVrnjOCQ7/lKS7zeyYpF5Jt7t7R9/vAgBAdSE/AgDSItZ21O6+RtKayLbFJa+PSrqhn+OekvRUnLEByIaGxkbNvWNhcTzhgrFasmjhSY4A4kd+BJC0rY0Nqr/zltC20edP1F2LliYUEZLA2kQAatqRfHdoClTz6hUJRgMAQDp4/nDoERpJql+5I6FokJQ4u4kCAAAAAFKKYhAAAAAAMohiEAAAAAAyiGIQAAAAADKIYhAAAAAAMohiEAAAAAAyiKUlAGRKdN1BibUHAQCQ+q49yLqDtY9iEECmRNcdlFh7EAAAqe/ag6w7WPuYJgoAAAAAGUQxCAAAAAAZRDEIAAAAABnEM4PIhIamZr1Q95viuLOrK8FokDbRpjI0lAGQFbu2rtc7bW+EtvV07EooGqQNDWVqH8UgMuHwkZzGT7mmOO7u2dpnn86uLr3w4kvFcT6fq0hsSF60qQwNZQBkxYj8QS2Y8YnQtnkNG0Pjno5d2vDoPaFtfvRQ7LEheTSUqX0Ug0Cgu6dX46dcWRz39m5KMBoAANJhlOW0YMbk0LbbN/YkFA2AcqIYBFAz8ocP9rl6zXQnAACkXC4XmgHFIzOQKAYB1JC6M3r7XL2OTncCACCL3D00A6q/R2aQPXQTBQAAAIAMohgEAAAAgAyiGAQAAACADOKZQQA1LdpUhoYyAAD0bSgj0VQmiygGAdS0aFMZGsoAANC3oYxEU5ksYpooAAAAAGQQdwZR9R5cvlj723cXx6PPn6i7Fi1NMCIAANLhvuUPqLWtoziecMFYLVm0MMGIAKQJxSCq3v723aqfPaU4rl+5I8FoAABIj9a2Dk2deWtx3Lx6RYLRAEgbikHUnK2NDaq/85bQtoP72hOKBgCA9GhobNTcO07cGdxHwxAg0ygGUXM8fzh0p1CS1q5ZlVA0AACkx5F8d+hO4ZYfP51gNACSRgMZAAAAAMgg7gwik/pbWyefzyUUDQAA6RFdn9WPHkowGgBxohhEJvW3tk5v76aEogEAID2i67PevrEnwWgAxCnWaaJmdq2ZvWZmLWZ2dz/vn21mzwbvbzKzScH2z5vZq2bWFPz52TjjBACgksiPAIA0iO3OoJmNkPSwpM9LapX0ipmtcvftJbvNldTl7peY2RxJ90v6iqQOSTPd/W0zmyppraQL44oV1SW6ruD2pkYp0jAGANKK/Ii4RNcUlKTGpmZNnZlQQABSL85poldLanH3nZJkZs9ImiWpNNnNklQfvH5O0kNmZu7eULLPNkl1Zna2u/NQF/qsKzh78/oEowGAYSM/IhbRNQUlacPmeQlFA6AaxDlN9EJJu0vGrep79bK4j7t3SzogaUxknz+R1ECiAwDUCPIjACAV4rwzaP1s8+HsY2aXqzA15gv9fgOz2yTdJkkXXXTRqUUJAEBlxZ4fg33IkQCAk4rzzmCrpIkl4wmS3h5oHzMbKek8SfuC8QRJ/yjp6+7+Rn/fwN0fcffp7j593LhxZQ4fAIBYxJ4fJXIkAGBwcRaDr0i61Mwmm9lZkuZIWhXZZ5Wkm4PX10t62d3dzEZL+pGke9ydB8IAALWE/AgASIXYisHgGYf5KnQ6+7WkH7r7NjNbamZfDnZ7TNIYM2uRtEDS8fba8yVdIunbZtYYfI2PK1YAACqF/AgASItYF5139zWS1kS2LS55fVTSDf0c9+eS/jzO2ABgIA2NjZp7x8LieMIFY7Vk0cKTHAEMD/kRQDXa2tig+jtvCW0bff5E3bVoaUIR4XTFWgwCQDU6ku8OtWdvXr0iwWgAAEgHzx8OLe8lSfUrdyQUDcohzmcGAQAAAAApxZ1BAJmSP3xQGx69J7Stp2NXQtEAAJAeuVxOL7z4UnHc2dWVYDSoBIpBAJlSd0avFsyYHNo2r2FjQtEAAJAe7q7xU64sjrt7tiYYDSqBaaIAAAAAkEHcGQSQedGpo0wbBQCAaaNZQDEIIPOiU0eZNgoAANNGs4BiEAAGEV13UGLtQQAApL5rD7LuYHWhGASAQUTXHZRYexAAAKnv2oOsO1hdaCADAAAAABnEnUHUnM6urtDDzpKUz+cSigYAgPTo6dgVapjlRw8lGA2ApFEMouZ09/SGHnaWpN7eTQlFAwBAeoyyXKhh1u0bexKMBkDSmCYKAAAAABlEMQgAAAAAGUQxCAAAAAAZRDEIAAAAABlEMQgAAAAAGUQ3UVS96FISLCOB05U/fDDUer2nY1eC0QDAqWMpCZRTLpfrs3xXZ1dXQtGgHCgGkWoPLl+s/e27Q9u2NzVKs6cUx9GlJFhGAqer7ozeUOv1eQ0bE4wGAPp33/IH1NrWURw3NjVr6szwPiwlgXJy9z7Ld3X3bE0oGpQDxSBSbX/7btWXFH6SNHvz+oSiAQAgPVrbOjR15q3F8YbN8xKMBkA14plBAAAAAMggikEAAAAAyCCmiaLq0DAGAIC+os1iJBrGADg5ikGkSrRhTLRZjETDGFRetLuoJG3b2qi5d5wYT7hgrJYsWljhyABkRbRZjNS3YUy0WYxEwxjEL9phdO2616Q7bwntM/r8ibpr0dJKh4YhoBhEqkQbxtAsBmkQ7S4qFTqMljZuaF69otJhAciQaLMYiYYxSIc+HUa7t/Zp/le/ckeFo8JQ8cwgAAAAAGQQxSAAAAAAZBDFIAAAAABkEMUgAAAAAGQQDWQAoAwaGhs1944T3UTpLgoAQMHWxgbVl3QYpbtoesR6Z9DMrjWz18ysxczu7uf9s83s2eD9TWY2Kdg+xsx+ZmaHzOyhOGMEgHI4ku/W1Jm3Fr+iLeCBUuRHAFni+cOqnz2l+FW6jBiSFVsxaGYjJD0s6YuSLpP0VTO7LLLbXEld7n6JpO9Luj/YflTStyX9l7jiAwAgCeRHAEBaxDlN9GpJLe6+U5LM7BlJsyRtL9lnlqT64PVzkh4yM3P3dyX9bzO7JMb4UAU6u7pCC5lKUj6fSygaACgL8iPKoqdjlzY8ek9x7EcPJRgNgGoUZzF4oaTSe8Ctkj420D7u3m1mBySNkcT8KkiSunt6wwuZSurt3ZRQNABQFuRHlMUoy2nBjMnF8e0bexKMBkA1ivOZQetnm5/CPgN/A7PbzGyLmW3Zu3fvsIIDACAhsedHiRwJABhcnMVgq6SJJeMJkt4eaB8zGynpPEn7hvoN3P0Rd5/u7tPHjRt3muECAFARsedHiRwJABhcnNNEX5F0qZlNlvSWpDmSbozss0rSzZI2Srpe0svuPqwrn6gtDU3NeqHuN8UxzwcCqEHkRwzbrq3r9U7bG6FtPCMI4HTFVgwGzzjMl7RW0ghJj7v7NjNbKmmLu6+S9Jikp8ysRYUrnnOOH29mb0p6r6SzzGy2pC+4+/bo90F1e3D54lB74fa3fqvxf3pTcczzgahW0XUHJdYeRAH5EUNx3/IHQkvUHGj/rf7b1z8R2odnBFGtWHcwPWJddN7d10haE9m2uOT1UUk3DHDspDhjQzrsb9+t+tlTiuO1a1YlGA1QPsfXHSzVvHpFQtEgbciPGExrW0fo35AtP346wWiA8jq+7uBx9St3JBhNtsVaDAKloncBJWl7U6NU8o8BAABZFL0T2NjUrKkzEwwIQCZQDKJioncBJWn25vUJRQNUXnTqKNNGARwXvRO4YfO8BKMBKis6bVRi6milUAwCQBlEF38+9tuG0FiSDr39uqZ++6HimGmjAIAs6Ozq0gsvvlQcv/W734XGHe1vqX72V0LHMHW0MigGAaAM+i7+nA+NJWlew8ZKhwUAQOK6e3o1fsqVJeNNkfHWJMKC4l1nEAAAAACQUtwZBIBTkD98MDQNlPW+AACQcrlcaAqoxLrRaUYxCACnoO6M3si0UNb7AgDA3UNTQCXWjU4zpokCAAAAQAZxZxCJinaXYhoBAAB9OxQzFR1AHCgGkahodymmEQAA0F+HYqaiAyg/ikEAqJBo05nO9rYEowEAIB36azrT0HQwoWiyhWIQsXlw+WLtb99dHG9vapRmT0kwIiBZ0aYzi1e8nmA0AJJy3/IH1NrWEdrW2NSsqTMTCghIWH9NZw7/Yl1C0WQLxSBis799t+pLir/Zm9cnGA0AAOnQ2tahqTNvDW3bsHleQtEAyDKKQQBIkegdgwkXjNWSRQsTjAgAgORFZ5yNPn+i7lq0NMGIagPFIE4JfyGBeETvGDSvXpFgNABOBRd1gPKLzjirX7kjwWhqB8UgTgl/IQEA6B8XdQBUC4pBDMlgzWC2Njao/s5bQsdE94muKSixriAQtWvrer3T9kZxTMdRIN2G0gymobFRc+9YOOD7EusKAoNpaGrWC3W/KRnTbbQcKAYxJIM1g/H84dD7/e0TXVNQYl1BIGpE/qAWzPhEcUzHUSDdhtIM5ki+O7RPf81iWFcQOLnDR3IaP+WaE2O6jZYFxSAApFjnvn2hOwo8ewQAgNS1d0+fWWn0sBi+M5IOAAAwsCOHDuidtjeKX79c+0LSIQEAkLje/CFdUfeb0NfPfvLjpMOqOtwZBICE9HdV8+C+9tCYheoBAFkUnRmzr6sr9D4L1ZcHxSD6iDaLkfo2g4nqrznMW7/7XWgbzWKAsONXNUutPvpuQtEAGIpow5j+msFERZvDHPttQ2gs0TAGiDo+M+a4Y+8eSDCa2kUxiD6izWKkvs1govprDtPdsym0jWYxQFh/VzX5ewKkW7RhTH/NYKL6NofJh8aFbTSMAUpFZ8bwdyQePDMIAAAAABnEnUEAqCLRZygkaWfLDl18yYm7+XQcBQBkUfRZ/NdaduoPLrk4tA8dR8MoBjMo+kwgfymA6tHT29t3TbNvz9OXS7Y1r15R6bCAmhB9HpALK0B1OdOOhdfFXrRe9bOvDe1Tv3JHpcNKNYrBDIo+Exj9S9HQ1KwXIk0tos1gaA4DAKg10ecB+7uwsmvr+nBTi36awUS30RwGQFpRDEJbGxtCt9Tb3/qtxv/pTaF9os1gaA4DVDfugACDa2hs7DMt+0D7b/Xfvv6J4rj/ZjB5Gl8AVaq/rvq1PIuOYhDy/OHQncK1a1YlGA2A07Vx7fP6/CdeLI7Pef94rfzRT0L7DOUOCJB1R/LdfaZlb/nx0wlFA6Ac1q5bp/Wf+HBxHM2R/XXVr+WppRSDNW4oawZG1whkyieQXvnDB/tMSevp2BUan9l7REtvva44/uYDz/S5uzGUtdGAWjfYmoHR9QElpnwCaZbL5UL/T9sZWahektR9VEtv/UJx+J+/83Rohtxga2vXmliLQTO7VtJfShohaYW7fzfy/tmSnpR0laROSV9x9zeD9+6RNFdSj6Q73H1tnLFWo/4KvWjXpO1Njfrht/9DaJ/omoHRNQKZ8gmkV3TdJUma17DxpMf023RmCGujIT7kx/hFC71o112pUPx9bdGDxXH070V0fUCJKZ9AmkXX7+3u2TroMX2azgyytnatia0YNLMRkh6W9HlJrZJeMbNV7r69ZLe5krrc/RIzmyPpfklfMbPLJM2RdLmkD0j6iZlNcXf+BS7R7+Lwka5JWfuFBoC0Iz9WRp/F4SNddyUuigBAnHcGr5bU4u47JcnMnpE0S1JpspslqT54/Zykh8zMgu3PuHtO0i4zawk+7+SXv2tM9M5f9K7fyz9dpysG6frZ7+1xAJkXnf62dcPP9PlXXgztc+jQIc347DXF8VAeoJ/9pX+nd/ftKY47DuV15We+XBzTqEYS+fG0Re/6SX3v/P1q3T8O2vUzOsUaAKKPT0nS8//4z1q/+dXiOJrbpMHzWzQ/SqeWZ8stzmLwQkmlcxhbJX1soH3cvdvMDkgaE2z/VeTYC+ML9YTBOuwNZWpmf/8hByvs1r78c5177rmhY3IHO/WLv55fHP/bP/snzZk6ojheffBA6Fa41LfL57uHN/f5hWZZCKC2RJ8jjD7T1N9zhnW5zki3wxdDz1BI0jeX/E3ogtN3/u5lNbUdLY7/+WerNPbcs0LH7H37N/ofi/+v4vgbi38Q+h/yX25dL1EMVmV+HEqHvaFMzYzm1aEcE/1de7vriG796x+F9vnln83Q2HNP5MgR77ZHfsf7dv38xvp1ob8bLAkB1JboM4RS3//vje5z+MiRPv9/PdI3hXJkNLdJ0up1z8jaf10cR//fPpofpb559vGfNFe8GDR3j+eDzW6QNMPdbw3GN0m62t3/c8k+24J9WoPxGypc4VwqaaO7Px1sf0zSGnd/PvI9bpN0WzD8A0mvxfLDlN9YSR2D7oXBcB7Lg/NYHpzH0zecc/j77j4uzmDiUon8GLxXjTmSv0flwXksD85jeXAey2Oo53FY+THOO4OtkiaWjCdIenuAfVrNbKSk8yTtG+KxcvdHJD1Sxpgrwsy2uPv0pOOodpzH8uA8lgfn8fRl6BzGnh+l6syRGfodiBXnsTw4j+XBeSyPuM7jGeX+wBKvSLrUzCab2VkqPPAeXcBulaSbg9fXS3rZC7cqV0maY2Znm9lkSZdK2hxjrAAAVAr5EQCQCrHdGQyecZgvaa0KrbMfd/dtZrZU0hZ3XyXpMUlPBQ/A71MhISrY74cqPEzfLembdEoDANQC8iMAIC1ie2YQAzOz24LpOzgNnMfy4DyWB+fx9HEOwe9AeXAey4PzWB6cx/KI6zxSDAIAAABABsX5zCAAAAAAIKUoBsvEzO40s2Yz22ZmdwXbPmJmG82sycxWm9l7g+1nmtkTwfZfm9k9JZ9zrZm9ZmYtZnZ3Uj9PUoZ5Hs8ys78Ntm81sz8q+Zyrgu0tZvZXwWLNNcvMHjezPWbWXLLt/Wb2kpm9Hvz5vmC7Beekxcz+xcyuLDnm5mD/183s5pLtmTifZTyPL5rZfjP7p8jnTzazTcFnPRs0D6k55TiPZjYt+Hu/Ldj+lZLPysR5rBXkx/IgP546cuTpIz+WRyrzo7vzdZpfkqZKapb0HhWa8vxEhQ5vr0i6JtjnG5KWBa9vlPRM8Po9kt6UNEmFRgJvSLpY0lmStkq6LOmfL8Xn8ZuS/jZ4PV7Sq5LOCMabJX1Ckkn6saQvJv3zxXzuPi3pSknNJdsekHR38PpuSfcHr/84OCcm6eOSNgXb3y9pZ/Dn+4LX78vS+SzHeQze+5ykmZL+KfL5P5Q0J3j9N5L+LOmfOa3nUdIUSZcGrz8g6XeSRmfpPNbC1yn8u05+LM95JD+Gzx85MgXnMHiP/Jiy/MidwfL4PyT9yt0Pu3u3pJ9Luk6FRX5/EezzkqQ/CV67pHOssHbUKEl5Se+osKBwi7vvdPe8pGckzarcj5G44Z7HyyT9VJLcfY+k/ZKmm9m/kfRed9/ohb8NT0qaXbkfo/Lc/RcqdBwsNUvSE8HrJ3TiHMyS9KQX/ErS6OCczZD0krvvc/cuFc71tVk6n2U6j3L3n0o6WPohwZXiz0p6rp/PqinlOI/uvsPdXw8+721JeySNy9J5rBHkx/IgP54GcuTpIz+WRxrzI8VgeTRL+rSZjTGz96hQyU8Mtn852OcGnVgo+DlJ76pQyf9W0l+4+z5JF0raXfK5rcG2rBjuedwqaZaZjbTCeltXBe9dqMK5Oy5r5/G48939d5IU/Dk+2D7Q79nJtmf5fA73PA5kjKT9wf/IDWX/WnPK59HMrlbhbtAb4jxWG/JjeZAfy48cefrIj+WRaH6kGCwDd/+1pPtVuEr0ogr/CHerMGXjm2b2qqTfU+EKp1S4wtmjwq3dyZL+HzO7WIXbwH0+Pt7o0+MUzuPjKvyib5H0oKQNwf6ZPo9DMND5Ge72rBvueeE89u+k5yW4mvyUpFvcvXew/ZEu5MfyID9WFDny9JEfy6Mi+ZFisEzc/TF3v9LdP63C7d/X3f1f3f0L7n6VpL9XoWqXCs9EvOjux4LpG+slTVfhH+6JJR87QdLblfspkjec8+ju3e7+f7v7NHefJWm0pNdVOI8TSj42c+cx0H58Wkbw555g+0C/ZyfbnuXzOdzzOJAOFaZ4jBzi/rVm2OfRCs0wfiTp3mCKjMR5rDrkx/IgP5YdOfL0kR/LI9H8SDFYJmY2PvjzIkn/XtLfl2w7Q9K9KjzIKRWmvnw26BJ0jgoPhf6rCg+CXxp0AjpL0hxJqyr7kyRrOOfRzN4TnD+Z2ecldbv79uAW+0Ez+3gwf/rrkl6o/E+TuFWSjnc7u1knzsEqSV8Pfv8+LulAcM7WSvqCmb0v6GT1BUlrOZ/DPo/9Cp4l+Zmk6/v5rCwY1nkM/g38RxWel/iH4x/Ceaw+5MfyID+WHTny9JEfyyPZ/Ogp6KxTC1+SfilpuwpTNz4XbLtT0o7g67uSLNh+rqR/kLQtOOa/lnzOHwf7vyHp/03650r5eZwk6TVJv1ahs9rvl3zOdBWepXhD0kPHj6nVLxWuCP9O0jEVriTNVWHu+E9VuBr8U0nvD/Y1SQ8H56ZJ0vSSz/mGpJbg65asnc8ynsdfStor6UjwOTOC7Rer0HWuJfg34Oykf+a0nkdJXwuObyz5mpal81grX8P8d538WJ7zOEnkx9JzR45MzzkkP6YsPx7/RwMAAAAAkCFMEwUAAACADKIYBAAAAIAMohgEAAAAgAyiGAQAAACADKIYBAAAAIAMohgEUs7Mesys0cy2mtk/m9n/GWz/gJk9l3R8AAAkhRwJnB6WlgBSzswOufu5wesZkha5+zUJhwUAQOLIkcDp4c4gUF3eK6lLksxskpk1B6//o5n9TzN70cxeN7MHEo0SAIDKI0cCwzQy6QAADGqUmTVKqpP0byR9doD9pkm6QlJO0mtm9tfuvrtCMQIAkARyJHAauDMIpN8Rd5/m7n8o6VpJT5qZ9bPfT939gLsflbRd0u9XNEoAACqPHAmcBopBoIq4+0ZJYyWN6+ftXMnrHnHnHwCQIeRIYPgoBoEqYmZ/KGmEpM6kYwEAIE3IkcDwcVUESL/jz0NIkkm62d17+p8FAwBAppAjgdPA0hIAAAAAkEFMEwUAAACADKIYBAAAAIAMohgEAAAAgAyiGAQAAACADKIYBAAAAIAMohgEAAAAgAyiGAQAAACADKIYBAAAAIAM+v8BqebFjPU0jvwAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -414,8 +424,8 @@ "data": { "text/plain": [ "(True,\n", - " Ks_2sampResult(statistic=0.09160000000000001, pvalue=5.443764204731642e-37),\n", - " 0.0012453653001820832)" + " Ks_2sampResult(statistic=0.09420000000000006, pvalue=4.2725799439035885e-39),\n", + " 5.064935064935066)" ] }, "execution_count": 10, @@ -424,7 +434,7 @@ } ], "source": [ - "dv.aggtest(ag.dp_count, 'UserId', repeatcount, numbins, debug = False, bound=False)" + "dv.aggtest(ag.dp_count, 'UserId', binsize=\"auto\", debug = False, bound=False)" ] }, { @@ -441,9 +451,9 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -479,9 +489,9 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -510,9 +520,9 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -534,6 +544,104 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Time to run the DP Tests" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Length of D1: 10000 Length of D2: 9999\n", + "Mean fD1: 10000.019953505132 Stdev fD1: 5.305249710261123 Mean fD2: 9998.958132351274 Stdev fD2: 5.337535320484232\n", + "\n", + "KS 2-sample Test Result: Ks_2sampResult(statistic=0.08299999999999996, pvalue=1.9034058160091338e-30) \n", + "\n", + "Sum of frequencies in D1 Histogram: 10000\n", + "Sum of frequencies in D2 Histogram: 10000\n", + "Wasserstein Distance Test: 5.921052631578947 \n", + "\n", + "DP Predicate Test: True \n", + "\n", + "--- 0.024997234344482422 seconds ---\n" + ] + } + ], + "source": [ + "import time\n", + "start_time = time.time()\n", + "dp_count, ks_count, ws_count = dv.aggtest(ag.dp_count, 'UserId', binsize=\"auto\", debug=False, plot=False)\n", + "print(\"--- %s seconds ---\" % (time.time() - start_time))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Length of D1: 10000 Length of D2: 9999\n", + "Mean fD1: 19878.048222427828 Stdev fD1: 63.79398104871362 Mean fD2: 19875.20084390794 Stdev fD2: 65.05318477182048\n", + "\n", + "KS 2-sample Test Result: Ks_2sampResult(statistic=0.02350000000000002, pvalue=0.007841256605877164) \n", + "\n", + "Sum of frequencies in D1 Histogram: 10000\n", + "Sum of frequencies in D2 Histogram: 10000\n", + "Wasserstein Distance Test: 5.566265060240966 \n", + "\n", + "DP Predicate Test: True \n", + "\n", + "--- 0.023999452590942383 seconds ---\n" + ] + } + ], + "source": [ + "start_time = time.time()\n", + "dp_sum, ks_sum, ws_sum = dv.aggtest(ag.dp_sum, 'Usage', binsize=\"auto\", debug=False, plot=False)\n", + "print(\"--- %s seconds ---\" % (time.time() - start_time))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Length of D1: 10000 Length of D2: 9999\n", + "Mean fD1: 10004.999557665647 Stdev fD1: 2.896014025157355 Mean fD2: 10004.02448858249 Stdev fD2: 2.893013668230772\n", + "\n", + "KS 2-sample Test Result: Ks_2sampResult(statistic=0.1039000000000001, pvalue=1.8059306714785786e-47) \n", + "\n", + "Sum of frequencies in D1 Histogram: 10000\n", + "Sum of frequencies in D2 Histogram: 10000\n", + "Wasserstein Distance Test: 6.714285714285714 \n", + "\n", + "DP Predicate Test: False \n", + "\n", + "--- 0.023999929428100586 seconds ---\n" + ] + } + ], + "source": [ + "start_time = time.time()\n", + "dp_count, ks_count, ws_count = dv.aggtest(ag.buggy_count, 'UserId', binsize=\"auto\", debug=False, plot=False)\n", + "print(\"--- %s seconds ---\" % (time.time() - start_time))" + ] + }, { "cell_type": "code", "execution_count": null,