diff --git a/ea/UB3/Antworten.pdf b/ea/UB3/Antworten.pdf
new file mode 100644
index 0000000..ec376be
--- /dev/null
+++ b/ea/UB3/Antworten.pdf
Binary files differ
diff --git a/ea/UB3/Blatt3/.classpath b/ea/UB3/Blatt3/.classpath
index fb50116..5adca5d 100644
--- a/ea/UB3/Blatt3/.classpath
+++ b/ea/UB3/Blatt3/.classpath
@@ -1,6 +1,7 @@
+
diff --git a/ea/UB3/Blatt3/EA3/src/individuals/GAIndividual.java b/ea/UB3/Blatt3/EA3/src/individuals/GAIndividual.java
new file mode 100644
index 0000000..e14ea6a
--- /dev/null
+++ b/ea/UB3/Blatt3/EA3/src/individuals/GAIndividual.java
@@ -0,0 +1,163 @@
+package src.individuals;
+
+//import tools.RandomNumberGenerator;
+
+import java.util.BitSet;
+
+import tools.RandomNumberGenerator;
+
+public class GAIndividual implements Comparable {
+ protected BitSet m_Genotype;
+ protected int m_GenotypeLength;
+
+ /** Constructor **/
+ public GAIndividual(int genotypeLength) {
+ m_GenotypeLength = genotypeLength;
+ initGenotype();
+ }
+
+ /**
+ * This method creates a deep copy of an individual. It should clone all
+ * objects contained by this object.
+ *
+ * @return An deep copy of this {@link GAIndividual}
+ */
+ @Override
+ public Object clone() {
+ GAIndividual c = new GAIndividual(m_GenotypeLength);
+ c.setGenotype((BitSet) this.m_Genotype.clone());
+ return c;
+ }
+
+ /**
+ * This method evaluates the GAIndividual as a simple
+ * "maximize number of bits" problem. The fitness is the number of true bits
+ * in m_Genotype. Best fitness is reached if there are no false bits.
+ *
+ * @return The number of false bits (less is better!)
+ */
+ public double evaluateAsMaxiBits() {
+ int zeros = 0;
+ for (int i = 0; i < m_GenotypeLength; i++) {
+ if (!m_Genotype.get(i)) {
+ zeros++;
+ }
+ }
+ return zeros;
+ }
+
+ /**
+ * This method will return a string description of the GAIndividal notably
+ * the genotype: '0011000101'
+ *
+ * @return A descriptive string
+ */
+ public String getStringRepresentation() {
+ String s = "";
+ for (int i = 0; i < m_GenotypeLength; i++) {
+ if (!m_Genotype.get(i)) {
+ s += '0';
+ } else {
+ s += '1';
+ }
+ }
+ return s;
+ }
+
+ /**
+ * This method will allow the user to read the GA genotype
+ *
+ * @return BitSet
+ */
+ public BitSet getGenotype() {
+ return m_Genotype;
+ }
+
+ /**
+ * This method will allow the user to set the current GA genotype. Should
+ * check if the length of the BitSet and the genotype length match.
+ *
+ * @param b
+ * The new genotype of the Individual
+ */
+ public void setGenotype(BitSet b) {
+ m_Genotype = b;
+ }
+
+ /**
+ * This method allows the user to read the length of the genotype. This may
+ * be necessary since BitSet.length only returns the index of the last
+ * significant bit.
+ *
+ * @return The length of the genotype.
+ */
+ public int getGenotypeLength() {
+ return m_GenotypeLength;
+ }
+
+ /**
+ * This method performs a simple one point mutation in the genotype (script
+ * 5.2.2). Please use the tools.RandomNumberGenerator
+ */
+ public void mutate() {
+ int rand = RandomNumberGenerator.randomInt(1, m_GenotypeLength) - 1;
+ m_Genotype.flip(rand);
+ }
+
+ /**
+ * This method performs a simple one point crossover of two GAIndividuals
+ * (script 5.2.1). Please use the tools.RandomNumberGenerator
+ *
+ * @return An array of length 2 with the two resulting GAIndivuals
+ */
+ public static GAIndividual[] crossover(GAIndividual ind1, GAIndividual ind2) {
+ if (ind1.getGenotypeLength() != ind2.getGenotypeLength()) {
+ System.err
+ .println("crossed individuals with different genotype length");
+ }
+
+ GAIndividual indA = (GAIndividual) ind1.clone();
+ GAIndividual indB = (GAIndividual) ind2.clone();
+
+ int rand = RandomNumberGenerator.randomInt(1, ind1.getGenotypeLength()) - 1;
+ for (int i = rand; i < ind1.getGenotypeLength(); i++) {
+ if (ind2.getGenotype().get(i)) {
+ indA.getGenotype().set(i);
+ } else {
+ indA.getGenotype().clear(i);
+ }
+ if (ind1.getGenotype().get(i)) {
+ indB.getGenotype().set(i);
+ } else {
+ indB.getGenotype().clear(i);
+ }
+ }
+ System.out.println("______");
+ System.out.println(ind1.getStringRepresentation());
+ System.out.println(ind2.getStringRepresentation());
+ System.out.println(rand);
+ System.out.println(indA.getStringRepresentation());
+ System.out.println(indB.getStringRepresentation());
+ GAIndividual[] crossed = { indA, indB };
+ return crossed;
+ }
+
+ /**
+ * This method initializes the GA genotype randomly. Please use the
+ * tools.RandomNumberGenerator
+ */
+ public void initGenotype() {
+ m_Genotype = new BitSet(m_GenotypeLength);
+ for (int i = 0; i < m_GenotypeLength; i++) {
+ if (RandomNumberGenerator.randomBoolean()) {
+ m_Genotype.set(i);
+ }
+ }
+ }
+
+ @Override
+ public int compareTo(GAIndividual o) {
+ return ((Double) this.evaluateAsMaxiBits()).compareTo(o
+ .evaluateAsMaxiBits());
+ }
+}
diff --git a/ea/UB3/Blatt3/EA3/src/strategies/GeneticAlgorithm.java b/ea/UB3/Blatt3/EA3/src/strategies/GeneticAlgorithm.java
new file mode 100644
index 0000000..a901091
--- /dev/null
+++ b/ea/UB3/Blatt3/EA3/src/strategies/GeneticAlgorithm.java
@@ -0,0 +1,146 @@
+package src.strategies;
+
+/**
+ * This class implements a deterministic variant of the Genetic Algorithm described in the script, section 5.1.1.
+ */
+import java.util.Arrays;
+
+import src.individuals.GAIndividual;
+import src.tools.RandomNumberGenerator;
+
+public class GeneticAlgorithm {
+ /** The length of the genotype of the individuals **/
+ private int m_GenotypeLength;
+ /** The number of individuals in the population **/
+ private int m_Mu;
+ /** The number of children generated **/
+ private int m_Lambda;
+ /** The number of single optimization steps to be evaluated **/
+ private int m_OptimizationSteps;
+ /** The number of times the experiment is repeated **/
+ private int m_MultiRuns;
+ /** Number of steps needed to reach best result **/
+ private int m_OptimizationStepsNeeded = 0;
+ /** Current best individual **/
+ private GAIndividual m_Best;
+
+ private GAIndividual[] m_Population;
+
+ /**
+ * This constructor sets up GeneticAlgorithm
+ *
+ * @param genotypeLength
+ * The length of the genotype of the individuals
+ * @param mu
+ * The number of individuals in the population
+ * @param lambda
+ * The number of children generated in each iteration
+ * @param optimizationSteps
+ * The number of single optimization steps to be evaluated
+ * (adjust as necessary)
+ * @param multiRuns
+ * The number of times the experiment is repeated (at least 10)
+ */
+ public GeneticAlgorithm(int genotypeLength, int mu, int lambda,
+ int optimizationSteps, int multiRuns) {
+ m_Mu = mu;
+ m_Lambda = lambda;
+ m_OptimizationSteps = optimizationSteps;
+ m_MultiRuns = multiRuns;
+ m_GenotypeLength = genotypeLength;
+ m_Population = new GAIndividual[m_Mu];
+ }
+
+ /**
+ * This method will initialize the GeneticAlgorithm
+ */
+ public void initialize() {
+ m_OptimizationStepsNeeded = 0;
+ for (int i = 0; i < m_Mu; i++) {
+ m_Population[i] = new GAIndividual(m_GenotypeLength);
+ }
+ }
+
+ /**
+ * This method will optimize the evaulateAsMaxiBits Problem. Use
+ * m_FitnessCallsNeeded to return the number of FitnessCalls (e.g., calling
+ * evaluateAsMaxiBits()) needed to find the optimum. The optimization should
+ * terminate after m_FitnessCalls.
+ */
+ public void optimize() {
+ // The deterministic Genetic Algorithm works as follows:
+ // while maxSteps not reached do
+ for (int j = 0; j < m_OptimizationSteps; j++) {
+ GAIndividual[] nextGen = new GAIndividual[m_Lambda];
+ // do select 2 (distinct) parents from population randomly
+ // perform crossover to generate two children
+ // until lambda children generated
+ for (int i = 0; i < m_Lambda; i = i + 2) {
+ GAIndividual ind1;
+ GAIndividual ind2;
+ do {
+ ind1 = m_Population[RandomNumberGenerator.randomInt(0,
+ m_Population.length - 1)];
+ ind2 = m_Population[RandomNumberGenerator.randomInt(0,
+ m_Population.length - 1)];
+ } while (ind1 == ind2);// distinct parents
+
+ GAIndividual[] children = GAIndividual.crossover(ind1, ind2);
+ nextGen[i] = children[0];
+ nextGen[i + 1] = children[1];
+ }
+ // mutate the children (p_m = 0.5, use randomBoolean from
+ // RandomNumberGenerator)
+ for (int i = 0; i < m_Lambda; i++) {
+ if (RandomNumberGenerator.randomBoolean()) {
+ nextGen[i].mutate();
+ }
+ }
+ // calculate the fitness of the children (use
+ // GAIndividual.evaluateAsMaxiBits())
+ Arrays.sort(nextGen);
+ // System.out.println(nextGen[0].getStringRepresentation());
+ // select the mu best individuals for the new population
+ for (int i = 0; i < m_Mu; i++) {
+ m_Population[i] = nextGen[i];
+ }
+
+ if (m_Population[0].evaluateAsMaxiBits() != 0) {
+ m_OptimizationStepsNeeded++;
+ }
+ }
+ m_Best = m_Population[0];
+ }
+
+ /**
+ * This main method will start a simple GeneticAlgorithm search. No
+ * arguments necessary.
+ *
+ * @param args
+ */
+ public static void main(String[] args) {
+ // TODO: parameters for the GeneticAlgorithm, adjust these values as
+ // necessary
+ int genotypeLength = 50;
+ int mu = 10;
+ int lambda = 50;
+ int optimizationSteps = 1000;
+ int multiRuns = 10;
+ GeneticAlgorithm program = new GeneticAlgorithm(genotypeLength, mu,
+ lambda, optimizationSteps, multiRuns);
+ int TmpMeanCalls = 0, TmpMeanFitness = 0;
+ // perform repeated optimization
+ for (int i = 0; i < program.m_MultiRuns; i++) {
+ System.out.println(i);
+ program.initialize();
+ program.optimize();
+ TmpMeanCalls += program.m_OptimizationStepsNeeded;
+ TmpMeanFitness += program.m_Best.evaluateAsMaxiBits();
+ }
+ TmpMeanCalls = TmpMeanCalls / program.m_MultiRuns;
+ TmpMeanFitness = TmpMeanFitness / program.m_MultiRuns;
+ System.out.println("(" + program.m_MultiRuns + "/"
+ + program.m_OptimizationSteps + ") Mean Fitness : "
+ + TmpMeanFitness + " Mean Calls needed: " + TmpMeanCalls);
+ }
+}
diff --git a/ea/UB3/Blatt3/EA3/src/strategies/HillClimbing.java b/ea/UB3/Blatt3/EA3/src/strategies/HillClimbing.java
new file mode 100644
index 0000000..a47e192
--- /dev/null
+++ b/ea/UB3/Blatt3/EA3/src/strategies/HillClimbing.java
@@ -0,0 +1,89 @@
+package src.strategies;
+
+import src.individuals.GAIndividual;
+
+public class HillClimbing {
+ /** The length of the genotype of the individuals **/
+ private int m_GenotypeLength;
+ /** The number of single optimization steps to be evaluated **/
+ private int m_OptimizationSteps;
+ /** The number of times the experiment is repeated **/
+ private int m_MultiRuns;
+ /** Number of steps needed to reach best result **/
+ private int m_OptimizationStepsNeeded = 0;
+ /** Current best individual **/
+ private GAIndividual m_Best;
+
+ /**
+ * This constructor sets up HillClimber
+ *
+ * @param genotypeLength
+ * The length of the genotype of the individuals
+ * @param optimizationSteps
+ * The number of single optimization steps to be evaluated
+ * (adjust as necessary)
+ * @param multiRuns
+ * The number of times the experiment is repeated (at least 10)
+ */
+ public HillClimbing(int genotypeLength, int optimizationSteps, int multiRuns) {
+ m_OptimizationSteps = optimizationSteps;
+ m_MultiRuns = multiRuns;
+ m_GenotypeLength = genotypeLength;
+ }
+
+ /**
+ * This method will initialize the HillClimber
+ */
+ public void initialize() {
+ m_Best = new GAIndividual(m_GenotypeLength);
+ m_OptimizationStepsNeeded = 0;
+ }
+
+ /**
+ * This method will optimize the defaultEvaulateAsMiniBits Problem. Use
+ * m_FitnessCallsNeeded to return the number of FitnessCalls (e.g., calling
+ * evaluateAsMaxiBits()) needed to find the optimum. The optimization should
+ * terminate after m_FitnessCalls.
+ */
+ public void optimize() {
+ for (int i = 0; i < m_OptimizationSteps; i++) {
+ GAIndividual mutated = (GAIndividual) m_Best.clone();
+ mutated.mutate();
+ m_Best = (m_Best.evaluateAsMaxiBits() <= mutated
+ .evaluateAsMaxiBits()) ? m_Best : mutated;
+
+ if (m_Best.evaluateAsMaxiBits() != 0) {
+ m_OptimizationStepsNeeded++;
+ }
+ }
+ }
+
+ /**
+ * This main method will start a simple hill climber. No arguments
+ * necessary.
+ *
+ * @param args
+ */
+ public static void main(String[] args) {
+ // TODO: parameters for the HillClimber, adjust these values as
+ // necessary
+ int genotypeLength = 50;
+ int optimizationSteps = 1000;
+ int multiRuns = 1000;
+ HillClimbing program = new HillClimbing(genotypeLength,
+ optimizationSteps, multiRuns);
+ int TmpMeanCalls = 0, TmpMeanFitness = 0;
+ // perform repeated optimization
+ for (int i = 0; i < program.m_MultiRuns; i++) {
+ program.initialize();
+ program.optimize();
+ TmpMeanCalls += program.m_OptimizationStepsNeeded;
+ TmpMeanFitness += program.m_Best.evaluateAsMaxiBits();
+ }
+ TmpMeanCalls = TmpMeanCalls / program.m_MultiRuns;
+ TmpMeanFitness = TmpMeanFitness / program.m_MultiRuns;
+ System.out.println("(" + program.m_MultiRuns + "/"
+ + program.m_OptimizationSteps + ") Mean Fitness : "
+ + TmpMeanFitness + " Mean Calls needed: " + TmpMeanCalls);
+ }
+}
diff --git a/ea/UB3/Blatt3/EA3/src/tools/RandomNumberGenerator.java b/ea/UB3/Blatt3/EA3/src/tools/RandomNumberGenerator.java
new file mode 100644
index 0000000..b713539
--- /dev/null
+++ b/ea/UB3/Blatt3/EA3/src/tools/RandomNumberGenerator.java
@@ -0,0 +1,47 @@
+package src.tools;
+
+import java.util.Random;
+
+public class RandomNumberGenerator {
+
+ private static Random random;
+ private static long randomSeed;
+
+ static {
+ randomSeed = System.currentTimeMillis();
+ random = new Random(randomSeed);
+ }
+
+ /**
+ * This method returns a evenly distributed integer value. The boundaries
+ * are included.
+ *
+ * @param lo
+ * Lower bound.
+ * @param hi
+ * Upper bound.
+ * @return Random integer from[lo,hi]
+ */
+ public static int randomInt(int lo, int hi) {
+ return (Math.abs(random.nextInt()) % ((hi - lo) + 1)) + lo;
+ }
+
+ /**
+ * This method returns 0 or 1 with same probability
+ *
+ * @return Random bit
+ */
+ public static int randomBit() {
+ return randomInt(0, 1);
+ }
+
+ /**
+ * This method returns true or false with same
+ * probability
+ *
+ * @return Random boolean value
+ */
+ public static boolean randomBoolean() {
+ return (randomBit() == 1);
+ }
+}
diff --git a/ea/UB3/Blatt3/src/individuals/GAIndividual.java b/ea/UB3/Blatt3/src/individuals/GAIndividual.java
index 02e2f11..b178aae 100644
--- a/ea/UB3/Blatt3/src/individuals/GAIndividual.java
+++ b/ea/UB3/Blatt3/src/individuals/GAIndividual.java
@@ -38,8 +38,12 @@
*/
@Override
public Object clone() {
- // Clone methoden... nein!
- return new GAIndividual(this);
+
+ GAIndividual c = new GAIndividual(m_GenotypeLength);
+ c.setGenotype((BitSet) this.m_Genotype.clone());
+ return c;
+
+ // return new GAIndividual(this);
}
/**
@@ -50,13 +54,13 @@
* @return The number of false bits (less is better!)
*/
public double evaluateAsMaxiBits() {
- int sum = 0;
+ int zeros = 0;
for (int i = 0; i < m_GenotypeLength; i++) {
- if (m_Genotype.get(i)) {
- sum++;
+ if (!m_Genotype.get(i)) {
+ zeros++;
}
}
- return sum;
+ return zeros;
}
/**
@@ -96,8 +100,7 @@
* The new genotype of the Individual
*/
public void setGenotype(BitSet b) {
- assert b.length() == m_Genotype.length() : "Length not euqual: intern:"
- + m_GenotypeLength + " input:" + b.length();
+
this.m_Genotype = b;
}
@@ -118,7 +121,8 @@
* 5.2.2). Please use the tools.RandomNumberGenerator
*/
public void mutate() {
- m_Genotype.flip(RandomNumberGenerator.randomInt(0, m_GenotypeLength));
+ m_Genotype.flip(RandomNumberGenerator
+ .randomInt(0, m_GenotypeLength - 1));
}
/**
@@ -129,15 +133,23 @@
*/
public static GAIndividual[] crossover(GAIndividual ind1, GAIndividual ind2) {
assert ind1.m_GenotypeLength == ind2.m_GenotypeLength;
+
int splitPoint = RandomNumberGenerator.randomInt(0,
- ind1.m_GenotypeLength);
+ ind1.m_GenotypeLength - 1);
GAIndividual ind1Clone = (GAIndividual) ind1.clone();
GAIndividual ind2Clone = (GAIndividual) ind2.clone();
for (int i = splitPoint; i < ind1Clone.m_GenotypeLength; i++) {
- boolean saveBit = ind1Clone.m_Genotype.get(i);
- ind1Clone.m_Genotype.set(i, ind2Clone.m_Genotype.get(i));
- ind2Clone.m_Genotype.set(i, saveBit);
+ ind1Clone.m_Genotype.set(i, ind2.m_Genotype.get(i));
+ ind2Clone.m_Genotype.set(i, ind1.m_Genotype.get(i));
+
}
+ // System.out.println("______");
+ // System.out.println(ind1.getStringRepresentation());
+ // System.out.println(ind2.getStringRepresentation());
+ // System.out.println(splitPoint);
+ // System.out.println(ind1Clone.getStringRepresentation());
+ // System.out.println(ind2Clone.getStringRepresentation());
+
return new GAIndividual[] { ind2Clone, ind1Clone };
}
@@ -154,11 +166,7 @@
@Override
public int compareTo(GAIndividual o) {
- if (this.evaluateAsMaxiBits() > o.evaluateAsMaxiBits()) {
- return 1;
- } else if (this.evaluateAsMaxiBits() < o.evaluateAsMaxiBits()) {
- return -1;
- }
- return 0;
+ return ((Double) this.evaluateAsMaxiBits()).compareTo(o
+ .evaluateAsMaxiBits());
}
}
diff --git a/ea/UB3/Blatt3/src/strategies/GeneticAlgorithm.java b/ea/UB3/Blatt3/src/strategies/GeneticAlgorithm.java
index dcd74de..d0dd3dd 100644
--- a/ea/UB3/Blatt3/src/strategies/GeneticAlgorithm.java
+++ b/ea/UB3/Blatt3/src/strategies/GeneticAlgorithm.java
@@ -8,7 +8,6 @@
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
-import java.util.List;
import tools.RandomNumberGenerator;
@@ -27,8 +26,6 @@
private int m_OptimizationStepsNeeded = 0;
/** Current best individual **/
private GAIndividual m_Best;
- /** Current list of parents **/
- private List m_parents = new ArrayList();
/**
* This constructor sets up GeneticAlgorithm
@@ -48,26 +45,23 @@
public GeneticAlgorithm(int genotypeLength, int mu, int lambda,
int optimizationSteps, int multiRuns) {
assert multiRuns > 9; // use run configurations: vmargument: -ea
- assert (lambda % 2) == 0;
+
this.m_GenotypeLength = genotypeLength;
this.m_Mu = mu;
this.m_Lambda = lambda;
this.m_OptimizationSteps = optimizationSteps;
this.m_MultiRuns = multiRuns;
+ this.m_Best = null;
+
}
/**
* This method will initialize the GeneticAlgorithm
*/
public void initialize() {
- m_parents.clear();
- m_OptimizationStepsNeeded = 0;
- for (int i = 0; i < m_Mu; i++) {
- m_parents.add(new GAIndividual(m_GenotypeLength));
- }
- Collections.sort(m_parents, Collections.reverseOrder());
- m_Best = m_parents.get(0);
+ m_OptimizationStepsNeeded = 0;
+
}
/**
@@ -90,35 +84,44 @@
// select the mu best individuals for the new population
// od
+ ArrayList population = new ArrayList();
+ for (int i = 0; i < m_Mu; i++) {
+ population.add(new GAIndividual(m_GenotypeLength));
+
+ }
+
for (int i = 0; i < m_OptimizationSteps; i++) {
+
ArrayList children = new ArrayList();
for (int a = 0; a < (m_Lambda / 2); a++) {
GAIndividual parent1;
GAIndividual parent2;
do {
- parent1 = m_parents.get(RandomNumberGenerator.randomInt(0,
+ parent1 = population.get(RandomNumberGenerator.randomInt(0,
m_Mu - 1));
- parent2 = m_parents.get(RandomNumberGenerator.randomInt(0,
+ parent2 = population.get(RandomNumberGenerator.randomInt(0,
m_Mu - 1));
} while (parent1 == parent2);// distinct parents
children.addAll(Arrays.asList(GAIndividual.crossover(parent1,
parent2)));
+
}
for (GAIndividual child : children) {
if (RandomNumberGenerator.randomBoolean()) {
child.mutate();
}
}
- m_parents.addAll(children);
- Collections.sort(m_parents, Collections.reverseOrder()); // comparable
- // implemented
- // in
- // GAIndividual
- m_parents = m_parents.subList(0, m_Mu);
- m_Best = m_parents.get(0);
- m_OptimizationStepsNeeded++;
- if (m_Best.evaluateAsMaxiBits() == m_GenotypeLength) {
- break;
+
+ Collections.sort(children); // comparable
+ // implemented
+ // in
+ // GAIndividual
+ // m_population = m_population.subList(0, m_Mu);
+
+ m_Best = children.get(0);
+ population = children;
+ if (m_Best.evaluateAsMaxiBits() != 0) {
+ m_OptimizationStepsNeeded++;
}
}
@@ -133,16 +136,18 @@
public static void main(String[] args) {
// TODO: parameters for the GeneticAlgorithm, adjust these values as
// necessary
- int genotypeLength = 50;
+ int genotypeLength = 25;
int mu = 10;
int lambda = 50;
- int optimizationSteps = 100000;
+ // int optimizationSteps = 100000;
+ int optimizationSteps = 100;
int multiRuns = 100;
GeneticAlgorithm program = new GeneticAlgorithm(genotypeLength, mu,
lambda, optimizationSteps, multiRuns);
int TmpMeanCalls = 0, TmpMeanFitness = 0;
// perform repeated optimization
for (int i = 0; i < program.m_MultiRuns; i++) {
+
program.initialize();
program.optimize();
TmpMeanCalls += program.m_OptimizationStepsNeeded;
diff --git a/ea/UB3/Blatt3/src/strategies/HillClimbing.java b/ea/UB3/Blatt3/src/strategies/HillClimbing.java
index a239c27..0dec224 100644
--- a/ea/UB3/Blatt3/src/strategies/HillClimbing.java
+++ b/ea/UB3/Blatt3/src/strategies/HillClimbing.java
@@ -55,11 +55,11 @@
for (int i = 0; i < m_OptimizationSteps; i++) {
GAIndividual clone = (GAIndividual) m_Best.clone();
clone.mutate();
- m_Best = clone.evaluateAsMaxiBits() > m_Best.evaluateAsMaxiBits() ? clone
+ m_Best = clone.evaluateAsMaxiBits() <= m_Best.evaluateAsMaxiBits() ? clone
: m_Best;
- m_OptimizationStepsNeeded++;
- if (m_Best.evaluateAsMaxiBits() == m_GenotypeLength) {
- break;
+
+ if (m_Best.evaluateAsMaxiBits() != 0) {
+ m_OptimizationStepsNeeded++;
}
}
}
@@ -74,8 +74,8 @@
// TODO: parameters for the HillClimber, adjust these values as
// necessary
int genotypeLength = 50;
- int optimizationSteps = 100000;
- int multiRuns = 100;
+ int optimizationSteps = 100;
+ int multiRuns = 1000;
HillClimbing program = new HillClimbing(genotypeLength,
optimizationSteps, multiRuns);
int TmpMeanCalls = 0, TmpMeanFitness = 0;
diff --git a/ea/UB3/ea2.pdf b/ea/UB3/ea2.pdf
deleted file mode 100644
index cbee4be..0000000
--- a/ea/UB3/ea2.pdf
+++ /dev/null
Binary files differ
diff --git a/ea/UB3/ea2.tex b/ea/UB3/ea2.tex
deleted file mode 100644
index 8bec441..0000000
--- a/ea/UB3/ea2.tex
+++ /dev/null
@@ -1,107 +0,0 @@
-\documentclass[a4paper,12pt]{scrartcl}
-\usepackage[ngerman]{babel}
-\usepackage{graphicx} %BIlder einbinden
-\usepackage{amsmath} %erweiterte Mathe-Zeichen
-\usepackage{amsfonts} %weitere fonts
-\usepackage[utf8]{inputenc} %Umlaute & Co
-\usepackage{hyperref} %Links
-\usepackage{ifthen} %ifthenelse
-\usepackage{enumerate}
-
-\usepackage{algpseudocode} %Pseudocode
-\usepackage{dsfont} % schöne Zahlenräumezeichen
-\usepackage{amssymb, amsthm} %noch stärker erweiterte Mathe-Zeichen
-\usepackage{tikz} %TikZ ist kein Zeichenprogramm
-\usetikzlibrary{trees,automata,arrows,shapes}
-
-\pagestyle{empty}
-
-
-\topmargin-50pt
-
-\newcounter{aufgabe}
-\def\tand{&}
-
-\newcommand{\makeTableLine}[2][0]{%
- \setcounter{aufgabe}{1}%
- \whiledo{\value{aufgabe} < #1}%
- {%
- #2\tand\stepcounter{aufgabe}%
- }
-}
-
-\newcommand{\aufgTable}[1]{
- \def\spalten{\numexpr #1 + 1 \relax}
- \begin{tabular}{|*{\spalten}{p{1cm}|}}
- \makeTableLine[\spalten]{A\theaufgabe}$\Sigma$~~\\ \hline
- \rule{0pt}{15pt}\makeTableLine[\spalten]{}\\
- \end{tabular}
-}
-
-\def\header#1#2#3#4#5#6#7{\pagestyle{empty}
-\begin{minipage}[t]{0.47\textwidth}
-\begin{flushleft}
-{\bf #4}\\
-#5
-\end{flushleft}
-\end{minipage}
-\begin{minipage}[t]{0.5\textwidth}
-\begin{flushright}
-#6 \vspace{0.5cm}\\
-% Number of Columns Definition of Columns second empty line
-% \begin{tabular}{|*{5}{C{1cm}|}}\hline A1&A2&A3&A4&$\Sigma$\\\hline&&&&\\\hline\end{tabular}\\\vspace*{0.1cm}
-\aufgTable{#7}
-\end{flushright}
-\end{minipage}
-\vspace{1cm}
-\begin{center}
-{\Large\bf Übungsblatt #1}
-
-{(Abgabe #3)}
-\end{center}
-}
-
-
-
-%counts the exercisenumber
-\newcounter{n}
-
-%Kommando für Aufgaben
-%\Aufgabe{AufgTitel}{Punktezahl}
-\newcommand{\Aufgabe}[2]{\stepcounter{n}
-\textbf{Aufgabe \arabic{n}: #1} (#2 Punkte)}
-
-
-\begin{document}
- %\header{BlattNr}{Tutor}{Abgabedatum}{Vorlesungsname}{Namen}{Semester}{Anzahl Aufgaben}
- \header{3}{}{2015-12-05}{Evolutionäre Algorithmen}{
- \textit{Jan-Peter Hohloch}\\ \textit{Maximus Mutschler}
- }{SS 15}{3}
- \vspace{0.5cm} \Aufgabe{Bit String Individuum}{6}\\
- Siehe Quellcode\\
- \Aufgabe{Hill-Climber und Genetischer Algorithmus}{10}\\
- Siehe Quellcode\\
- \Aufgabe{Vergleich Hill-Climber und Genetischer Algorithmus}{4}\\
- $\mu=10$ \\$\lambda =50$\\
- Durchschnittliche Optimierungsschritte bei 100 Optimierungsläufen:\\\\
- \begin{tabular}{c|c|c}
- n & Hill-Climber & Genetischer Algorithmus \\ \hline
- 10 & 24 & 3 \\
- 25 & 80 & 8 \\
- 50 & 202 & 18
- \end{tabular}\\\\
- Warum ist es nötig die Ergebnisse zu mitteln?\\
- Es handelt sich um stochastische Optimierungsverfahren. Demnach gibt es kein deterministisches Ergebnis. Folglich muss der Mittelwert aus den Zufalls belasteten Ergebnissen als Ergebnismaß verwendet werden.\\\\
-
- Sind die Ergebnisse von Hill-Climber und Genetischen Algorithmus direkt vergleichbar?\\
- warum nicht ?? TODO\\
- Beim Hill-Climber Algorithmus kommt es nur zu 1 Bit Mutationen beim Genetischen Algorithmus werden Crossover angewandt. Wehrendessen es beim Hill-Climber Algorithmus maßgeblich vom initialen Individuum abhängt, wie viele Schritte benötigt werden um das Maximum zu erreichen, ist beim Genetischen Algorithmus der Crossover ausschlaggebend.
- Beim Hill Climber wird nur eine "Population" von einem Individuum angenommen, um ihn mit dem Genetischen Algorithmus vergleichbar zu machen, müsste man $\mu$ Individuuen und deren Mutationen und die daraus folgende Fitness je Optimierungsschritt untersuchen.
- \\
- Gibt das Sinn?
-
-
-
-
-\end{document}
-
diff --git a/ea/UB3/ea3.pdf b/ea/UB3/ea3.pdf
deleted file mode 100644
index cbee4be..0000000
--- a/ea/UB3/ea3.pdf
+++ /dev/null
Binary files differ
diff --git a/ea/UB3/ea3.tex b/ea/UB3/ea3.tex
index 8bec441..ef11119 100644
--- a/ea/UB3/ea3.tex
+++ b/ea/UB3/ea3.tex
@@ -86,19 +86,18 @@
Durchschnittliche Optimierungsschritte bei 100 Optimierungsläufen:\\\\
\begin{tabular}{c|c|c}
n & Hill-Climber & Genetischer Algorithmus \\ \hline
- 10 & 24 & 3 \\
- 25 & 80 & 8 \\
- 50 & 202 & 18
+ 10 & 21 & 2 \\
+ 25 & 72 & 7 \\
+ 50 & 99 & 17
\end{tabular}\\\\
Warum ist es nötig die Ergebnisse zu mitteln?\\
Es handelt sich um stochastische Optimierungsverfahren. Demnach gibt es kein deterministisches Ergebnis. Folglich muss der Mittelwert aus den Zufalls belasteten Ergebnissen als Ergebnismaß verwendet werden.\\\\
Sind die Ergebnisse von Hill-Climber und Genetischen Algorithmus direkt vergleichbar?\\
- warum nicht ?? TODO\\
- Beim Hill-Climber Algorithmus kommt es nur zu 1 Bit Mutationen beim Genetischen Algorithmus werden Crossover angewandt. Wehrendessen es beim Hill-Climber Algorithmus maßgeblich vom initialen Individuum abhängt, wie viele Schritte benötigt werden um das Maximum zu erreichen, ist beim Genetischen Algorithmus der Crossover ausschlaggebend.
- Beim Hill Climber wird nur eine "Population" von einem Individuum angenommen, um ihn mit dem Genetischen Algorithmus vergleichbar zu machen, müsste man $\mu$ Individuuen und deren Mutationen und die daraus folgende Fitness je Optimierungsschritt untersuchen.
+ Beim Hill-Climber Algorithmus kommt es nur zu 1 Bit Mutationen beim Genetischen Algorithmus werden Crossover angewandt.
+ Beim Hill Climber wird nur eine "Population" von einem Individuum angenommen, um ihn mit dem Genetischen Algorithmus vergleichbar zu machen, müsste man $\mu$ Individuen und deren Mutationen und die daraus folgende Fitness je Optimierungsschritt untersuchen.
\\
- Gibt das Sinn?
+
diff --git a/ea/UB3/hohlochMutschler.zip b/ea/UB3/hohlochMutschler.zip
new file mode 100644
index 0000000..efc9b1c
--- /dev/null
+++ b/ea/UB3/hohlochMutschler.zip
Binary files differ
diff --git a/ea/UB3/src/individuals/GAIndividual.java b/ea/UB3/src/individuals/GAIndividual.java
new file mode 100644
index 0000000..b178aae
--- /dev/null
+++ b/ea/UB3/src/individuals/GAIndividual.java
@@ -0,0 +1,172 @@
+package individuals;
+
+//import tools.RandomNumberGenerator;
+
+import java.util.BitSet;
+
+import tools.RandomNumberGenerator;
+
+public class GAIndividual implements Comparable {
+ protected BitSet m_Genotype;
+ protected int m_GenotypeLength;
+
+ /** Constructor **/
+ public GAIndividual(int genotypeLength) {
+ // This method should call initGenotype() to initialize the genotype
+ this.m_GenotypeLength = genotypeLength;
+ initGenotype();
+ }
+
+ /**
+ * cloning constructor
+ *
+ * @param toClone
+ */
+ private GAIndividual(GAIndividual toClone) {
+ this.m_Genotype = (BitSet) toClone.m_Genotype.clone();// allowed, has
+ // only native
+ // typed
+ // fields
+ this.m_GenotypeLength = toClone.m_GenotypeLength;
+ }
+
+ /**
+ * This method creates a deep copy of an individual. It should clone all
+ * objects contained by this object.
+ *
+ * @return An deep copy of this {@link GAIndividual}
+ */
+ @Override
+ public Object clone() {
+
+ GAIndividual c = new GAIndividual(m_GenotypeLength);
+ c.setGenotype((BitSet) this.m_Genotype.clone());
+ return c;
+
+ // return new GAIndividual(this);
+ }
+
+ /**
+ * This method evaluates the GAIndividual as a simple
+ * "maximize number of bits" problem. The fitness is the number of true bits
+ * in m_Genotype. Best fitness is reached if there are no false bits.
+ *
+ * @return The number of false bits (less is better!)
+ */
+ public double evaluateAsMaxiBits() {
+ int zeros = 0;
+ for (int i = 0; i < m_GenotypeLength; i++) {
+ if (!m_Genotype.get(i)) {
+ zeros++;
+ }
+ }
+ return zeros;
+ }
+
+ /**
+ * This method will return a string description of the GAIndividal notably
+ * the genotype: '0011000101'
+ *
+ * @return A descriptive string
+ */
+ public String getStringRepresentation() {
+ // this should return exactly the representation shown in the comment
+ // above:
+ // only 0 (for false bits) and 1 (for true bits) with no extra white
+ // space!
+ String representation = "";
+ for (int i = 0; i < m_GenotypeLength; i++) {
+ representation = m_Genotype.get(i) ? representation + "1"
+ : representation + "0";
+
+ }
+ return representation;
+ }
+
+ /**
+ * This method will allow the user to read the GA genotype
+ *
+ * @return BitSet
+ */
+ public BitSet getGenotype() {
+ return m_Genotype;
+ }
+
+ /**
+ * This method will allow the user to set the current GA genotype. Should
+ * check if the length of the BitSet and the genotype length match.
+ *
+ * @param b
+ * The new genotype of the Individual
+ */
+ public void setGenotype(BitSet b) {
+
+ this.m_Genotype = b;
+
+ }
+
+ /**
+ * This method allows the user to read the length of the genotype. This may
+ * be necessary since BitSet.length only returns the index of the last
+ * significant bit.
+ *
+ * @return The length of the genotype.
+ */
+ public int getGenotypeLength() {
+ return m_GenotypeLength;
+ }
+
+ /**
+ * This method performs a simple one point mutation in the genotype (script
+ * 5.2.2). Please use the tools.RandomNumberGenerator
+ */
+ public void mutate() {
+ m_Genotype.flip(RandomNumberGenerator
+ .randomInt(0, m_GenotypeLength - 1));
+ }
+
+ /**
+ * This method performs a simple one point crossover of two GAIndividuals
+ * (script 5.2.1). Please use the tools.RandomNumberGenerator
+ *
+ * @return An array of length 2 with the two resulting GAIndivuals
+ */
+ public static GAIndividual[] crossover(GAIndividual ind1, GAIndividual ind2) {
+ assert ind1.m_GenotypeLength == ind2.m_GenotypeLength;
+
+ int splitPoint = RandomNumberGenerator.randomInt(0,
+ ind1.m_GenotypeLength - 1);
+ GAIndividual ind1Clone = (GAIndividual) ind1.clone();
+ GAIndividual ind2Clone = (GAIndividual) ind2.clone();
+ for (int i = splitPoint; i < ind1Clone.m_GenotypeLength; i++) {
+ ind1Clone.m_Genotype.set(i, ind2.m_Genotype.get(i));
+ ind2Clone.m_Genotype.set(i, ind1.m_Genotype.get(i));
+
+ }
+ // System.out.println("______");
+ // System.out.println(ind1.getStringRepresentation());
+ // System.out.println(ind2.getStringRepresentation());
+ // System.out.println(splitPoint);
+ // System.out.println(ind1Clone.getStringRepresentation());
+ // System.out.println(ind2Clone.getStringRepresentation());
+
+ return new GAIndividual[] { ind2Clone, ind1Clone };
+ }
+
+ /**
+ * This method initializes the GA genotype randomly. Please use the
+ * tools.RandomNumberGenerator
+ */
+ public void initGenotype() {
+ m_Genotype = new BitSet(m_GenotypeLength);
+ for (int i = 0; i < m_GenotypeLength; i++) {
+ m_Genotype.set(i, RandomNumberGenerator.randomBoolean());
+ }
+ }
+
+ @Override
+ public int compareTo(GAIndividual o) {
+ return ((Double) this.evaluateAsMaxiBits()).compareTo(o
+ .evaluateAsMaxiBits());
+ }
+}
diff --git a/ea/UB3/src/strategies/GeneticAlgorithm.java b/ea/UB3/src/strategies/GeneticAlgorithm.java
new file mode 100644
index 0000000..d0dd3dd
--- /dev/null
+++ b/ea/UB3/src/strategies/GeneticAlgorithm.java
@@ -0,0 +1,162 @@
+package strategies;
+
+/**
+ * This class implements a deterministic variant of the Genetic Algorithm described in the script, section 5.1.1.
+ */
+import individuals.GAIndividual;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+
+import tools.RandomNumberGenerator;
+
+public class GeneticAlgorithm {
+ /** The length of the genotype of the individuals **/
+ private int m_GenotypeLength;
+ /** The number of individuals in the population **/
+ private int m_Mu;
+ /** The number of children generated **/
+ private int m_Lambda;
+ /** The number of single optimization steps to be evaluated **/
+ private int m_OptimizationSteps;
+ /** The number of times the experiment is repeated **/
+ private int m_MultiRuns;
+ /** Number of steps needed to reach best result **/
+ private int m_OptimizationStepsNeeded = 0;
+ /** Current best individual **/
+ private GAIndividual m_Best;
+
+ /**
+ * This constructor sets up GeneticAlgorithm
+ *
+ * @param genotypeLength
+ * The length of the genotype of the individuals
+ * @param mu
+ * The number of individuals in the population
+ * @param lambda
+ * The number of children generated in each iteration
+ * @param optimizationSteps
+ * The number of single optimization steps to be evaluated
+ * (adjust as necessary)
+ * @param multiRuns
+ * The number of times the experiment is repeated (at least 10)
+ */
+ public GeneticAlgorithm(int genotypeLength, int mu, int lambda,
+ int optimizationSteps, int multiRuns) {
+ assert multiRuns > 9; // use run configurations: vmargument: -ea
+
+ this.m_GenotypeLength = genotypeLength;
+ this.m_Mu = mu;
+ this.m_Lambda = lambda;
+ this.m_OptimizationSteps = optimizationSteps;
+ this.m_MultiRuns = multiRuns;
+ this.m_Best = null;
+
+ }
+
+ /**
+ * This method will initialize the GeneticAlgorithm
+ */
+ public void initialize() {
+
+ m_OptimizationStepsNeeded = 0;
+
+ }
+
+ /**
+ * This method will optimize the evaulateAsMaxiBits Problem. Use
+ * m_FitnessCallsNeeded to return the number of FitnessCalls (e.g., calling
+ * evaluateAsMaxiBits()) needed to find the optimum. The optimization should
+ * terminate after m_FitnessCalls.
+ */
+ public void optimize() {
+ // The deterministic Genetic Algorithm works as follows:
+ // initialize the population
+ // while maxSteps not reached do
+ // do select 2 (distinct) parents from population randomly
+ // perform crossover to generate two children
+ // until lambda children generated
+ // mutate the children (p_m = 0.5, use randomBoolean from
+ // RandomNumberGenerator)
+ // calculate the fitness of the children (use
+ // GAIndividual.evaluateAsMaxiBits())
+ // select the mu best individuals for the new population
+ // od
+
+ ArrayList population = new ArrayList();
+ for (int i = 0; i < m_Mu; i++) {
+ population.add(new GAIndividual(m_GenotypeLength));
+
+ }
+
+ for (int i = 0; i < m_OptimizationSteps; i++) {
+
+ ArrayList children = new ArrayList();
+ for (int a = 0; a < (m_Lambda / 2); a++) {
+ GAIndividual parent1;
+ GAIndividual parent2;
+ do {
+ parent1 = population.get(RandomNumberGenerator.randomInt(0,
+ m_Mu - 1));
+ parent2 = population.get(RandomNumberGenerator.randomInt(0,
+ m_Mu - 1));
+ } while (parent1 == parent2);// distinct parents
+ children.addAll(Arrays.asList(GAIndividual.crossover(parent1,
+ parent2)));
+
+ }
+ for (GAIndividual child : children) {
+ if (RandomNumberGenerator.randomBoolean()) {
+ child.mutate();
+ }
+ }
+
+ Collections.sort(children); // comparable
+ // implemented
+ // in
+ // GAIndividual
+ // m_population = m_population.subList(0, m_Mu);
+
+ m_Best = children.get(0);
+ population = children;
+ if (m_Best.evaluateAsMaxiBits() != 0) {
+ m_OptimizationStepsNeeded++;
+ }
+
+ }
+ }
+
+ /**
+ * This main method will start a simple GeneticAlgorithm search. No
+ * arguments necessary.
+ *
+ * @param args
+ */
+ public static void main(String[] args) {
+ // TODO: parameters for the GeneticAlgorithm, adjust these values as
+ // necessary
+ int genotypeLength = 25;
+ int mu = 10;
+ int lambda = 50;
+ // int optimizationSteps = 100000;
+ int optimizationSteps = 100;
+ int multiRuns = 100;
+ GeneticAlgorithm program = new GeneticAlgorithm(genotypeLength, mu,
+ lambda, optimizationSteps, multiRuns);
+ int TmpMeanCalls = 0, TmpMeanFitness = 0;
+ // perform repeated optimization
+ for (int i = 0; i < program.m_MultiRuns; i++) {
+
+ program.initialize();
+ program.optimize();
+ TmpMeanCalls += program.m_OptimizationStepsNeeded;
+ TmpMeanFitness += program.m_Best.evaluateAsMaxiBits();
+ }
+ TmpMeanCalls = TmpMeanCalls / program.m_MultiRuns; // ja klar 3.9 =3
+ TmpMeanFitness = TmpMeanFitness / program.m_MultiRuns;
+ System.out.println("(" + program.m_MultiRuns + "/"
+ + program.m_OptimizationSteps + ") Mean Fitness : "
+ + TmpMeanFitness + " Mean Calls needed: " + TmpMeanCalls);
+ }
+}
diff --git a/ea/UB3/src/strategies/HillClimbing.java b/ea/UB3/src/strategies/HillClimbing.java
new file mode 100644
index 0000000..0dec224
--- /dev/null
+++ b/ea/UB3/src/strategies/HillClimbing.java
@@ -0,0 +1,96 @@
+package strategies;
+
+import individuals.GAIndividual;
+
+public class HillClimbing {
+ /** The length of the genotype of the individuals **/
+ private int m_GenotypeLength;
+ /** The number of single optimization steps to be evaluated **/
+ private int m_OptimizationSteps;
+ /** The number of times the experiment is repeated **/
+ private int m_MultiRuns;
+ /** Number of steps needed to reach best result **/
+ private int m_OptimizationStepsNeeded = 0;
+ /** Current best individual **/
+ private GAIndividual m_Best;
+
+ /**
+ * This constructor sets up HillClimber
+ *
+ * @param genotypeLength
+ * The length of the genotype of the individuals
+ * @param optimizationSteps
+ * The number of single optimization steps to be evaluated
+ * (adjust as necessary)
+ * @param multiRuns
+ * The number of times the experiment is repeated (at least 10)
+ */
+ public HillClimbing(int genotypeLength, int optimizationSteps, int multiRuns) {
+ assert multiRuns > 9;
+ this.m_GenotypeLength = genotypeLength;
+ this.m_OptimizationSteps = optimizationSteps;
+ this.m_MultiRuns = multiRuns;
+ }
+
+ /**
+ * This method will initialize the HillClimber
+ */
+ public void initialize() {
+ m_Best = new GAIndividual(m_GenotypeLength);
+ m_OptimizationStepsNeeded = 0;
+ }
+
+ /**
+ * This method will optimize the defaultEvaulateAsMiniBits Problem. Use
+ * m_FitnessCallsNeeded to return the number of FitnessCalls (e.g., calling
+ * evaluateAsMaxiBits()) needed to find the optimum. The optimization should
+ * terminate after m_FitnessCalls.
+ */
+ public void optimize() {
+ // nur mutieren oder auch crossover?
+
+ // TODO implement this
+ // use GAIndividual.evaluateAsMaxiBits() to evaluate the fitness of an
+ // individual and call it m_OptimizationSteps times before terminating
+ for (int i = 0; i < m_OptimizationSteps; i++) {
+ GAIndividual clone = (GAIndividual) m_Best.clone();
+ clone.mutate();
+ m_Best = clone.evaluateAsMaxiBits() <= m_Best.evaluateAsMaxiBits() ? clone
+ : m_Best;
+
+ if (m_Best.evaluateAsMaxiBits() != 0) {
+ m_OptimizationStepsNeeded++;
+ }
+ }
+ }
+
+ /**
+ * This main method will start a simple hill climber. No arguments
+ * necessary.
+ *
+ * @param args
+ */
+ public static void main(String[] args) {
+ // TODO: parameters for the HillClimber, adjust these values as
+ // necessary
+ int genotypeLength = 50;
+ int optimizationSteps = 100;
+ int multiRuns = 1000;
+ HillClimbing program = new HillClimbing(genotypeLength,
+ optimizationSteps, multiRuns);
+ int TmpMeanCalls = 0, TmpMeanFitness = 0;
+ // perform repeated optimization
+ for (int i = 0; i < program.m_MultiRuns; i++) {
+ program.initialize();
+ program.optimize();
+ TmpMeanCalls += program.m_OptimizationStepsNeeded;
+ TmpMeanFitness += program.m_Best.evaluateAsMaxiBits();
+
+ }
+ TmpMeanCalls = TmpMeanCalls / program.m_MultiRuns;
+ TmpMeanFitness = TmpMeanFitness / program.m_MultiRuns;
+ System.out.println("(" + program.m_MultiRuns + "/"
+ + program.m_OptimizationSteps + ") Mean Fitness : "
+ + TmpMeanFitness + " Mean Calls needed: " + TmpMeanCalls);
+ }
+}
diff --git a/ea/UB3/src/tools/RandomNumberGenerator.java b/ea/UB3/src/tools/RandomNumberGenerator.java
new file mode 100644
index 0000000..facdcca
--- /dev/null
+++ b/ea/UB3/src/tools/RandomNumberGenerator.java
@@ -0,0 +1,47 @@
+package tools;
+
+import java.util.Random;
+
+public class RandomNumberGenerator {
+
+ private static Random random;
+ private static long randomSeed;
+
+ static {
+ randomSeed = System.currentTimeMillis();
+ random = new Random(randomSeed);
+ }
+
+ /**
+ * This method returns a evenly distributed integer value. The boundaries
+ * are included.
+ *
+ * @param lo
+ * Lower bound.
+ * @param hi
+ * Upper bound.
+ * @return Random integer from[lo,hi]
+ */
+ public static int randomInt(int lo, int hi) {
+ return (Math.abs(random.nextInt()) % (hi - lo + 1)) + lo;
+ }
+
+ /**
+ * This method returns 0 or 1 with same probability
+ *
+ * @return Random bit
+ */
+ public static int randomBit() {
+ return randomInt(0, 1);
+ }
+
+ /**
+ * This method returns true or false with same
+ * probability
+ *
+ * @return Random boolean value
+ */
+ public static boolean randomBoolean() {
+ return (randomBit() == 1);
+ }
+}
diff --git a/is/UB2/ISUB2.pdf b/is/UB2/ISUB2.pdf
index 09ab0bd..7d38015 100644
--- a/is/UB2/ISUB2.pdf
+++ b/is/UB2/ISUB2.pdf
Binary files differ
diff --git a/is/UB2/ISUB2.tex b/is/UB2/ISUB2.tex
index 32cd13f..2f761a6 100644
--- a/is/UB2/ISUB2.tex
+++ b/is/UB2/ISUB2.tex
@@ -83,7 +83,7 @@
\vspace{1cm}
\Aufgabe{Monster vs. mouse}{50}
Assume:
- $P(M=0)=0.7,P(M=1)=0.2,P(M=2)=0.1;P(m)=0.2, P(e)=0.5$, mice are also afraid of monsters, so if there is a monster under the bed there is no mouse.\\
+ $P(M=0)=0.7,P(M=1)=0.2,P(M=2)=0.1;P(m)=0.2, P(e)=0.5$, mice are also afraid of monsters, so if there is a monster under the bed there is no mouse.\color{red} and nothing else \color{black} \\
$P(n|M=1)=0.7,P(n|M=2)=0.8,P(n|M=0)=0.1, P(n|m)=0.2, P(n|e)=0.1$\\
$\Rightarrow P(n)=0.29$\\
$\hat{M}^{MAP}=\arg\max\limits_M P(M|n=1)$\\
diff --git a/is/UB3/ExerciseSheet3.ipynb b/is/UB3/ExerciseSheet3.ipynb
deleted file mode 100644
index e58609c..0000000
--- a/is/UB3/ExerciseSheet3.ipynb
+++ /dev/null
@@ -1,370 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "preamble": true
- },
- "source": [
- "(Defining latex commands: not to be shown...)\n",
- "$$\n",
- "\\newcommand{\\norm}[1]{\\left \\| #1 \\right \\|}\n",
- "\\DeclareMathOperator{\\minimize}{minimize}\n",
- "\\newcommand{\\real}{\\mathbb{R}}\n",
- "\\newcommand{\\normal}{\\mathcal{N}}\n",
- "$$"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#Intelligent Systems Sheet 3\n",
- "Maximus Mutschler & Jan-Peter Hohloch"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Gaussian Algebra (25 Points)\n",
- "\n",
- "Prove that the product of two univariate (scalar) Gaussian distributions is a Gaussian again, i.e. show, by explicitly performing the required arithmetic transformations, that\n",
- "\n",
- "\\begin{equation}\n",
- " \\normal(x;\\mu,\\sigma^2)\\normal(x;m,s^2) = \\normal\\left[x; \\left(\\frac 1{\\sigma^2}+\\frac 1{s^2}\\right)^{-1}\\left(\\frac \\mu{\\sigma^2}+\\frac m{s^2}\\right),\\left(\\frac 1{\\sigma^2}+\\frac 1{s^2}\\right)^{-1}\\right]\\normal\\left[\\mu;m,\\sigma^2+s^2\\right].\n",
- "\\end{equation}"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Proof\n",
- "\\begin{align*}\n",
- " f(x) &= \\frac{1}{\\sqrt{2\\pi\\sigma^2}}\\cdot e^{\\frac{-(x-\\mu)^2}{2\\sigma^2}}\\cdot \\frac{1}{\\sqrt{2\\pi s^2}}\\cdot e^{\\frac{-(x-m)^2}{2s^2}}\\\\\n",
- " &=\\frac{1}{2\\pi s\\sigma}\\cdot e^{-\\alpha}\\\\\n",
- " \\text{where }\\alpha &= \\frac{s^2(x-\\mu)^2+\\sigma^2(x-m)^2}{2\\sigma^2 s^2}\\\\\n",
- " &=\\frac{(s^2+\\sigma^2)x^2-2(s^2\\mu+\\sigma^2 m)x+s^2\\mu^2+\\sigma^2m^2}{2\\sigma^2s^2}\\\\\n",
- " &=\\frac{x^2-2\\frac{s^2\\mu+\\sigma^2 m}{s^2+\\sigma^2}x+\\frac{s^2\\mu^2+\\sigma^2m^2}{s^2+\\sigma^2}}{\\frac{2\\sigma^2s^2}{s^2+\\sigma^2}}\\\\\n",
- " &=\\frac{\\left(x-\\frac{s^2\\mu+\\sigma^2 m}{s^2+\\sigma^2}\\right)^2-\\left(\\frac{s^2\\mu+\\sigma^2 m}{s^2+\\sigma^2}\\right)^2+\\frac{s^2\\mu^2+\\sigma^2m^2}{s^2+\\sigma^2}}{\\frac{2\\sigma^2s^2}{s^2+\\sigma^2}}\\\\\n",
- " &=\\frac{\\left(x-\\frac{s^2\\mu+\\sigma^2 m}{s^2+\\sigma^2}\\right)^2}{\\frac{2\\sigma^2s^2}{s^2+\\sigma^2}}+\\underbrace{\\frac{\\frac{s^2\\mu^2+\\sigma^2m^2}{s^2+\\sigma^2}-\\left(\\frac{s^2\\mu+\\sigma^2 m}{s^2+\\sigma^2}\\right)^2}{\\frac{2\\sigma^2s^2}{s^2+\\sigma^2}}}_\\beta\\\\\n",
- " \\beta&= \\frac{\\frac{s^4\\mu^2+s^2\\sigma^2\\mu^2+s^2\\sigma^2m^2+\\sigma^4m^2-\\left(s^4\\mu^2+2s^2\\sigma^2\\mu m+\\sigma^4m^2\\right)}{\\left(s^2+\\sigma^2\\right)^2}}{\\frac{2\\sigma^2s^2}{s^2+\\sigma^2}}\\\\\n",
- " &=\\frac{s^2\\sigma^2\\left(\\mu^2-2\\mu m+m^2\\right)}{2\\sigma^2s^2\\left(s^2+\\sigma^2\\right)}\\\\\n",
- " &=\\frac{(\\mu-m)^2}{2(s^2+\\sigma^2)}\\\\\n",
- " \\Rightarrow f(x)&=\\frac{1}{2\\pi s\\sigma}\\cdot e^{-(\\alpha-\\beta)-\\beta}\\\\\n",
- " &=\\frac{1}{2\\pi s\\sigma}\\cdot e^{-\\frac{\\left(x-\\frac{s^2\\mu+\\sigma^2 m}{s^2+\\sigma^2}\\right)^2}{\\frac{2\\sigma^2s^2}{s^2+\\sigma^2}}}\\cdot e^{-\\frac{(\\mu-m)^2}{2(s^2+\\sigma^2)}}\\\\\n",
- " &=\\frac{\\sqrt{2\\pi(s^2+\\sigma^2)}\\sqrt{2\\pi\\frac{\\sigma^2s^2}{s^2+\\sigma^2}}}{2\\pi s\\sigma}\\normal\\left[x;\\frac{s^2\\mu+\\sigma^2 m}{s^2+\\sigma^2},\\frac{\\sigma^2s^2}{s^2+\\sigma^2}\\right]\\normal\\left[\\mu;m,\\sigma^2+s^2\\right]\\\\\n",
- " &=\\frac{\\sqrt{2\\pi\\cdot 2\\pi\\sigma^2s^2}}{2\\pi s\\sigma}\\normal\\left[x; \\left(\\frac 1{\\sigma^2}+\\frac 1{s^2}\\right)^{-1}\\left(\\frac \\mu{\\sigma^2}+\\frac m{s^2}\\right),\\left(\\frac 1{\\sigma^2}+\\frac 1{s^2}\\right)^{-1}\\right]\\normal\\left[\\mu;m,\\sigma^2+s^2\\right]\\\\\n",
- " &=\\normal\\left[x; \\left(\\frac 1{\\sigma^2}+\\frac 1{s^2}\\right)^{-1}\\left(\\frac \\mu{\\sigma^2}+\\frac m{s^2}\\right),\\left(\\frac 1{\\sigma^2}+\\frac 1{s^2}\\right)^{-1}\\right]\\normal\\left[\\mu;m,\\sigma^2+s^2\\right]\\hspace{2cm} q.e.d.\n",
- "\\end{align*}"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Maximum Likelihood Estimator of Simple Linear Regression (25 Points)\n",
- "\n",
- "Derive the formula $\\mathbf{w}_{MLE} = (X^TX)^{-1}X^T\\mathbf{y}$ from the lecture, by calculating the derivative of $p(\\mathbf{y}\\,|X,\\mathbf{w}) = \\normal(\\mathbf{y}\\,|X\\mathbf{w}, \\sigma^2I)$ with respect to $\\mathbf{w}$, setting it to zero and solving it for $\\mathbf{w}$.\n",
- "\n",
- "\n",
- "Note: _To refresh your linear algebra you might find it useful to have a look in [here](http://webdav.tuebingen.mpg.de/lectures/ei-SS2015/pdfs/Murray_cribsheet.pdf)._"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "##wtf?\n",
- "\n",
- "$\\vec{w}=X^{-1}\\vec{y}$, zumindest wenn ich das ausrechne..."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Linear regression (50 Points)\n",
- "\n",
- "In this exercise you will perform a regression analysis on a toy dataset. You will implement ridge regression and learn how to find a good model through a comparative performance analysis.\n",
- "\n",
- "1) Download the [training set](http://webdav.tuebingen.mpg.de/lectures/ei-SS2015/data/ex1_train.csv)!
\n",
- "2) Implement $\\mathbf{w}_{RIDGE}$ as a function of a given $X, \\mathbf{y}$ array and a regularization parameter $\\lambda$!"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "# Loading the required packages\n",
- "%matplotlib inline\n",
- "import numpy as np\n",
- "import matplotlib.pyplot as plt\n",
- "from IPython.html.widgets import interact"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false,
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "def wRidge(X,y,lamb):\n",
- " # Change the following line and implement the ridge regression estimator wRidge\n",
- " w = np.zeros(X.shape[-1])\n",
- " return w"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "3) Load \"ex1_train.csv\" into a numpy array! The first column in the csv file is $X$ and the second column is $\\mathbf{y}$, assign them to each variable!"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": [
- "# Read ex1_train.csv and assign the first column and \n",
- "# second column to variables x and y respectively."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "4) Plot the training data with appropriate labels on each axes!"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false,
- "scrolled": false
- },
- "outputs": [],
- "source": [
- "# Plot the input data here"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "5) Implement a function which constructs features upto a input polynomial degree $d$!
\n",
- "Note: _Constructing higher polynomial features is similar to what you implemented in Exercise 3 (SVM) of the previous exercise sheet._"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 68,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": [
- "def construct_poly(x,d):\n",
- " ## Implement a method which given an array of size N, \n",
- " ## returns an array of dimension (N,d)\n",
- " return np.zeros((x.shape[0],d+x.shape[1]))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "6) Implement the Mean Squared Error Loss (MSE) as a function of the predicted and true values of the target variable!
"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": [
- "def MSE(y_predict,y_true):\n",
- " ## Implement mean squared error for a given input y and its predictions.\n",
- " return 0.0"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "7) By comparing the MSE find the degree $d$ for the polynomial that fits the training data best! You might find it useful to use the code below to interactively change the variable $d$, set $\\lambda = 1$ and keep it fixed. Plot the error as a function of different values of $d$!
"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false,
- "scrolled": true
- },
- "outputs": [],
- "source": [
- "##This function provides an interactive mode to change polynomial degree. \n",
- "@interact(n=[1,16])\n",
- "def plot(n):\n",
- " X = construct_poly(x,n)\n",
- " w = wRidge(X,y,1.0)\n",
- " plt.plot(x,X.dot(w))\n",
- " plt.title(\"MSE %f\" % MSE(X.dot(w),y))\n",
- " plt.plot(x,y)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "8) Apply models with different values of $d$ after being trained on the training dataset, to the test data available [here](http://webdav.tuebingen.mpg.de/lectures/ei-SS2015/data/ex1_test.csv). Compare the errors on the test data to the ones from the training by plotting the error curves as functions of the polynomial degree in a single plot! What do you conclude?
"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 82,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "array([[ 1.00000000e+02, 1.00000000e+01, 1.00000000e+00],\n",
- " [ 1.00000000e+01, 1.00000000e+00, 1.00000000e-01],\n",
- " [ 1.00000000e+00, 1.00000000e-01, 1.00000000e-02]])"
- ]
- },
- "execution_count": 82,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "A.T.dot(A)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "import scipy\n",
- "from scipy import linalg\n",
- "import numpy as np"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 25,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "1\n",
- "[[ 9.80101960e-03 9.80101960e-04 9.80101960e-05]\n",
- " [ 9.80101960e-04 9.80101960e-05 9.80101960e-06]\n",
- " [ 9.80101960e-05 9.80101960e-06 9.80101960e-07]]\n",
- "True\n"
- ]
- }
- ],
- "source": [
- "A = np.array([[10,1,0.1],[10,1,0.2],[10,1.1,0.7]])\n",
- "a = np.array([[10,1,0.1]])\n",
- "A = a.T.dot(a)\n",
- "\n",
- "B,rank = linalg.pinv(A,return_rank=True)\n",
- "print rank\n",
- "print B\n",
- "print np.allclose(A,A.dot(B.dot(A)))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 67,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": [
- "## Read test data here"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "9) With a fixed optimal $d$, change the value of $\\lambda$ to one of the following values $[0.1, 1.0, 10.0]$ and find the minimum MSE!
"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Hand in printed copy of completed notebook."
- ]
- }
- ],
- "metadata": {
- "annotations": {
- "author": "",
- "categories": [
- "intelligent-systems-1-2015"
- ],
- "date": "2015-04-30",
- "location": "Beginning of next lecture",
- "parent": "IS_SS2015",
- "submission_date": "2015-05-07",
- "subtitle": "Exercise Sheet 3, Linear Regression",
- "tags": [
- "IntelligenSystems",
- "Course"
- ],
- "title": "Intelligent Systems 1 - Summer Semester 2015"
- },
- "celltoolbar": "Edit Metadata",
- "kernelspec": {
- "display_name": "Python 3",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.4.3"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}
diff --git a/is/UB3/ExerciseSheet3Fiete.ipynb b/is/UB3/ExerciseSheet3Fiete.ipynb
new file mode 100644
index 0000000..1c60e8e
--- /dev/null
+++ b/is/UB3/ExerciseSheet3Fiete.ipynb
@@ -0,0 +1,775 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "preamble": true
+ },
+ "source": [
+ "(Defining latex commands: not to be shown...)\n",
+ "$$\n",
+ "\\newcommand{\\norm}[1]{\\left \\| #1 \\right \\|}\n",
+ "\\DeclareMathOperator{\\minimize}{minimize}\n",
+ "\\newcommand{\\real}{\\mathbb{R}}\n",
+ "\\newcommand{\\normal}{\\mathcal{N}}\n",
+ "$$"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Gaussian Algebra (25 Points)\n",
+ "\n",
+ "Prove that the product of two univariate (scalar) Gaussian distributions is a Gaussian again, i.e. show, by explicitly performing the required arithmetic transformations, that\n",
+ "\n",
+ "\\begin{equation}\n",
+ " \\normal(x;\\mu,\\sigma^2)\\normal(x;m,s^2) = \\normal[x; (\\frac 1{\\sigma^2}+\\frac 1{s^2})^{-1}(\\frac \\mu{\\sigma^2}+\\frac m{s^2}),(\\frac 1{\\sigma^2}+\\frac 1{s^2})^{-1}]\\normal[m,\\mu,\\sigma^2+s^2].\n",
+ "\\end{equation}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Maximum Likelihood Estimator of Simple Linear Regression (25 Points)\n",
+ "\n",
+ "Derive the formula $\\mathbf{w}_{MLE} = (X^TX)^{-1}X^T\\mathbf{y}$ from the lecture, by calculating the derivative of $p(\\mathbf{y}\\,|X,\\mathbf{w}) = \\normal(\\mathbf{y}\\,|X\\mathbf{w}, \\sigma^2I)$ with respect to $\\mathbf{w}$, setting it to zero and solving it for $\\mathbf{w}$.\n",
+ "\n",
+ "\n",
+ "Note: _To refresh your linear algebra you might find it useful to have a look in [here](http://webdav.tuebingen.mpg.de/lectures/ei-SS2015/pdfs/Murray_cribsheet.pdf)._"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Linear regression (50 Points)\n",
+ "\n",
+ "In this exercise you will perform a regression analysis on a toy dataset. You will implement ridge regression and learn how to find a good model through a comparative performance analysis.\n",
+ "\n",
+ "1) Download the [training set](http://webdav.tuebingen.mpg.de/lectures/ei-SS2015/data/ex1_train.csv)!
\n",
+ "2) Implement $\\mathbf{w}_{RIDGE}$ as a function of a given $X, \\mathbf{y}$ array and a regularization parameter $\\lambda$!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ ":0: FutureWarning: IPython widgets are experimental and may change in the future.\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Loading the required packages\n",
+ "%matplotlib inline\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "from IPython.html.widgets import interact"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[1 2 3]\n",
+ "[1, 1, 1]\n",
+ "3\n"
+ ]
+ }
+ ],
+ "source": [
+ "testx = np.array([1, 2, 3]);\n",
+ "testy = [1, 1, 1];\n",
+ "\n",
+ "print(testx);\n",
+ "print(testy);\n",
+ "\n",
+ "foo = testx.T * testy;\n",
+ "\n",
+ "print(len(foo));"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "collapsed": false,
+ "scrolled": false
+ },
+ "outputs": [],
+ "source": [
+ "def wRidge(X,y,lamb):\n",
+ " # Change the following line and implement the ridge regression estimator wRidge\n",
+ " # w = np.zeros(X.shape[-1])\n",
+ " a = np.linalg.inv(lamb + np.dot(X.T, X));\n",
+ " # print('a');\n",
+ " # print(a);\n",
+ " b = X.T;\n",
+ " # print('b');\n",
+ " # print(b);\n",
+ " c = y;\n",
+ " # print('y');\n",
+ " # print(y);\n",
+ " ab = np.dot(a, b);\n",
+ " abc = np.dot(ab, c);\n",
+ " # print('abc');\n",
+ " # print(abc);\n",
+ " w = abc;\n",
+ " return w;"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "3) Load \"ex1_train.csv\" into a numpy array! The first column in the csv file is $X$ and the second column is $\\mathbf{y}$, assign them to each variable!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[-3. -2.5 -1. -0.5 0. 1. 2. 2.5 3. 4. ]\n",
+ "[ 4.87103994 -1.03777715 -6.73176788 -4.08540431 0. 8.73176788\n",
+ " 13.27437941 13.53777715 13.12896006 13.94558004]\n",
+ "(-3.0, 4.0, -6.731767878463172, 13.945580037536574)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Read ex1_train.csv and assign the first column and \n",
+ "# second column to variables x and y respectively.\n",
+ "from numpy import genfromtxt\n",
+ "data = genfromtxt('ex1_train.csv', delimiter=' ');\n",
+ "X = data[:, 0];\n",
+ "y = data[:, 1];\n",
+ "\n",
+ "print(X);\n",
+ "print(y);\n",
+ "\n",
+ "print(min(X), max(X), min(y), max(y));"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "4) Plot the training data with appropriate labels on each axes!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "collapsed": false,
+ "scrolled": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": [
+ "iVBORw0KGgoAAAANSUhEUgAAAXAAAAD7CAYAAABzGc+QAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n",
+ "AAALEgAACxIB0t1+/AAADu5JREFUeJzt3X9sXeddx/HPZw2Ts8VQTZuystlKlXQC5rFuQoFQJO4E\n",
+ "21ILLfQPGJUQ5Ucs/mD2hCbYWCQaNKHxQxRiIyQUtmkI9gMBKwtLf4SuV1RCFIrSLiEJXcKC3dJl\n",
+ "QxvDFrbo1i9/nBPl2jm2r++v5zz3vl9S1Huee+85nzryJ8fPec61I0IAgPy8LHUAAEBnKHAAyBQF\n",
+ "DgCZosABIFMUOABkigIHgEzt6vcBbLNOEQA6EBHe7gV9/VMcor/H6CDT8dQZcshU11xkItMo5Gqn\n",
+ "O5lCAYBMUeAAkKlRLfBm6gAVmqkDbKKZOkCFZuoAFZqpA1Ropg5QoZk6wCaaqQN0wuVcS/8OYEds\n",
+ "NxEPAFinne7s+yoUAKgre2pampiTxsek5TVpaT7i/OnUudpFgQMYSUV5HzohnTxwY3Rmvz2lXEp8\n",
+ "VOfAAYy8ibn15S0V25OzafLsHAUOYESNj1WP79k92BydYwoFwKZynyPe2vJa9fjK6mBzdI4CB1Bp\n",
+ "GOaIt7Y0L83sX///d/SKtLiQLtPOsIwQQCX77oelh9558zPTD0ecvnvwiXqv+EdqcraYNllZlRYX\n",
+ "6vKPE8sIgRHUu2mP/OeIt1N+XWpR2J2gwIEh0ttpj97NEQ/3XHo6FDgwVDZbGjc9qx2fafZmjnj4\n",
+ "59LTocCBodK7aY+I86ftKRXl380ccS//UUErChwYKr1dGtebOeLhn0tPhRt5gKGyNC/NXF4/lnpp\n",
+ "XP7rreuKM3BgiPRu2qOX8l9vXVesAwfQd3Veb11X7XQnBQ4ANdROdzIHDgCZosABIFMUOABkigIH\n",
+ "gExR4ACQKQocADJFgQNApihwAMgUBQ4AmaLAASBTFDgAZIoCB4BMUeAAkCkKHAAyRYEDQKYocADI\n",
+ "FAUOAJmiwAEgUxQ4AGSKAgeATFHgAJApChwAMtVWgdv+qO1rts+1jL3K9hnbz9p+1Pat/YsJANio\n",
+ "3TPwj0k6vGHsA5LORMQbJD1WbgMABqStAo+IJyR9fcPwuyR9vHz8cUk/3sNcAIBtdDMHvjcirpWP\n",
+ "r0na24M8AIA27erFTiIibMdmz9s+3rLZjIhmL44LAMPCdkNSY0fvidi0dzfufJ+kUxHxpnL7kqRG\n",
+ "RHzZ9m2SHo+I76p4X0SEdxIKAEZdO93ZzRTKZyXdVz6+T9KDXewLALBDbZ2B2/6kpB+W9GoV892/\n",
+ "LulvJP2FpElJVyX9ZET8d8V7OQMHgB1qpzvbnkLpZwgAwHr9nkIBACREgQNApihwAMgUBQ4AmaLA\n",
+ "ASBTPbkTExhV9tS0NDEnjY9Jy2vS0nzE+dOpc2E0UOBAh4ryPnRCOnngxujMfntKlDgGgSkUoGMT\n",
+ "c+vLWyq2J2fT5MGoocCBjo2PVY/v2T3YHBhVFDjQseW16vGV1cHmwKiiwIGOLc1LM5fXjx29Ii0u\n",
+ "pMmDUcNnoQBdKC5kTs4W0yYrq9LiAhcw0Qt8mBUAZIoPswKAIUaBA0CmKHAAyBQFDgCZosABIFMU\n",
+ "OABkigIHgExR4ACQKQocADJFgQNApihwAMgUBQ4AmaLAASBTFDgAZIoCB4BMUeAAkCkKHAAyRYED\n",
+ "QKYocADIFAUOAJmiwAEgUxQ4AGSKAgeATFHgAJApChwAMkWBA0CmKHAAyNSubndg+6qk/5H0LUkv\n",
+ "RsTBbvcJANhe1wUuKSQ1IuJrPdgXAKBNvZpCcY/2AwBokyOiux3Y/y7pGyqmUP44Ik5ueD4iohYF\n",
+ "b09NSxNz0viYtLwmLc1HnD+dOhcAbNROd/ZiCuWuiHjB9msknbF9KSKe2BDkeMtmMyKaPTjujhTl\n",
+ "feiEdPLAjdGZ/faUKHEAqdluSGrs6D3dnoFvCHC/pJWI+L2WsVqcgdt3Pyw99M6bn5l+OOL03YNP\n",
+ "BACba6c7u5oDt/0K2+Pl41dKeoekc93ss3/Gx6rH9+webA4A6I1up1D2SvqM7ev7+vOIeLTrVH2x\n",
+ "vFY9vrI62BwA0BtdFXhEfEnSnT3K0mdL89LM/vVz4EevSIsL6TIBQOd6OgdeeYCazIFL1y9kTs4W\n",
+ "0yYrq9LiAhcwAdRRO905UgUOALno+0VMAEA6FDgAZIoCB4BMUeAAkCkKHAAyRYEDQKYocADIFAUO\n",
+ "AJmiwAEgUxQ4AGSKAgeATFHgAJApChwAMkWBA0CmKHAAyBQFDgCZosABIFMUOABkigIHgExR4ACQ\n",
+ "KQocADJFgQNApihwAMgUBQ4AmaLAASBTFDgAZIoCB4BMUeAAkCkKHAAyRYEDQKYocADIFAUOAJmi\n",
+ "wAEgUxQ4AGSKAgeATFHgAJApChwAMkWBA0Cmui5w24dtX7L9Rdvv70UoAMD2HBGdv9m+RdK/SfpR\n",
+ "Sc9L+mdJ90bExZbXRES426AAMEra6c5dXR7joKTLEXG1POCnJB2RdHGrNwGdsKempYk5aXxMWl6T\n",
+ "luYjzp9OnQtIpdsCf52kpZbt5yR9f5f7BG5SlPehE9LJAzdGZ/bbU6LEMaq6nQPvfP4F2JGJufXl\n",
+ "LRXbk7Np8gDpdXsG/rykiZbtCRVn4evYPt6y2YyIZpfHxcgZH6se37N7sDmA/rDdkNTYyXu6LfCn\n",
+ "JN1he5+k/5T0bkn3bnxRRBzv8jgYectr1eMrq4PNAfRHeWLbvL5t+/7t3tPVFEpEfFPSeyQ9IumC\n",
+ "pE+3rkABemdpXpq5vH7s6BVpcSFNHiC9rpYRtnUAlhGiR4oLmZOzxbTJyqq0uMAFTAyrdrqTAgeA\n",
+ "GmqnO7mVHgAyRYEDQKa6XYUysrgrEEBqFHgHuCsQQB0whdIR7goEkB4F3hHuCgSQHgXeEe4KBJAe\n",
+ "Bd4R7goEkB438nSIuwIB9BN3YgJAprgTEwCGGAUOAJmiwAEgUxQ4AGSKAgeATFHgAJApChwAMkWB\n",
+ "A0CmKHAAyBQFDgCZosABIFMUOABkigIHgExR4ACQKQocADJFgQNApihwAMgUBQ4AmaLAASBTFDgA\n",
+ "ZIoCB4BMUeAAkKldqQNguNlT09LEnDQ+Ji2vSUvzEedPp84FDAMKHH1TlPehE9LJAzdGZ/bbU6LE\n",
+ "ge4xhYI+mphbX95SsT05myYPMFwocPTR+Fj1+J7dg80BDCcKHH20vFY9vrI62BzAcKLA0UdL89LM\n",
+ "5fVjR69Iiwtp8gDDxRHR3wPYERHu60FQW8WFzMnZYtpkZVVaXOACJrC9drqTAgeAGmqnOzueQrF9\n",
+ "3PZzts+Wfw53ui8AwM51sw48JD0QEQ/0KgwAoH3dXsRkagQAEum2wGdtP2P7I7Zv7UkiAEBbtryI\n",
+ "afuMpNdWPHVM0j9K+mq5/SFJt0XEL1TsIyT9RstQMyKanQYGgGFkuyGp0TJ0/0BWodjeJ+lURLyp\n",
+ "4jlWoQDADvV7FcptLZv3SDrX6b4AADvXzSqU37Z9p4rVKF+S9Iu9iQQAaAc38gBADfV1CgUAkBYF\n",
+ "DgCZosABIFMUOABkigIHgExR4ACQKQocADJFgQNApihwAMhUN7fSY4gVv8tyYk4aHyt+u/zSPL/L\n",
+ "EqgXChw3Kcr70Anp5IEbozP77SlR4kB9MIWCChNz68tbKrYnZ9PkAVCFAkeF8bHq8T27B5sDwFYo\n",
+ "cFRYXqseX1kdbA4AW6HAUWFpXpq5vH7s6BVpcSFNHgBV+DxwVCouZE7OFtMmK6vS4gIXMIHBaac7\n",
+ "KXAAqCF+oQMADLGRLHDbjdQZNqpjJqmeucjUHjK1r665tjOSBS6pkTpAhUbqAJtopA5QoZE6QIVG\n",
+ "6gAVGqkDVGikDrCJRuoAnRjVAgeA7FHgAJCpgaxC6esBAGBIJV9GCADoD6ZQACBTFDgAZGpgBW77\n",
+ "fbZfsv2qQR1zK7Y/ZPsZ20/bfsz2RA0y/a7ti2Wuv7b9HTXI9BO2/9X2t2y/NXGWw7Yv2f6i7fen\n",
+ "zHKd7Y/avmb7XOos19mesP14+fd23vZcDTKN2X6y/H67YPvDqTNdZ/sW22dtn0qdRZJsX7X9hTLT\n",
+ "P2312oEUeFmOb5f0H4M4Xpt+JyLeHBF3SnpQ0v2pA0l6VNIbI+LNkp6V9GuJ80jSOUn3SPr7lCFs\n",
+ "3yLpDyUdlvQ9ku61/d0pM5U+piJTnbwo6Zcj4o2SfkDSL6X+WkXEmqS3ld9v3yvpbbZ/KGWmFu+V\n",
+ "dEFSXS4IhqRGRLwlIg5u9cJBnYE/IOlXB3SstkTEcsvmHkn/lSrLdRFxJiJeKjeflPT6lHkkKSIu\n",
+ "RcSzqXNIOijpckRcjYgXJX1K0pHEmRQRT0j6euocrSLiyxHxdPl4RdJFSd+ZNpUUEf9bPny5pFsk\n",
+ "fS1hHEmS7ddLmpb0J5Lq9JlNbWXpe4HbPiLpuYj4Qr+PtVO2f9P2oqT7JP1W6jwb/LwkPv3vhtdJ\n",
+ "WmrZfq4cwxZs75P0FhUnBEnZfpntpyVdk/R4RFxInUnS70v6FUkvbffCAQpJf2f7KdszW72wJ78T\n",
+ "0/YZSa+teOqYimmAd7S+vBfHbMcWuT4YEaci4pikY7Y/oOIv8udSZypfc0zS/0XEJ/qdp91MNVCX\n",
+ "H2+zYXuPpL+U9N7yTDyp8qfLO8trO4/YbkREM1Ue2z8m6SsRcbZmn4VyV0S8YPs1ks7YvlT+pHeT\n",
+ "nhR4RLy9atz2lKTbJT1jWyqmBP7F9sGI+Eovjt1Jrgqf0IDOdrfLZPtnVfxI9yODyCPt6OuU0vOS\n",
+ "Wi80T6g4C0cF298m6a8k/VlEPJg6T6uI+Ibtz0n6PknNhFF+UNK7bE9LGpP07bb/NCJ+JmEmRcQL\n",
+ "5X+/avszKqYPKwu8r1MoEXE+IvZGxO0RcbuKb7i3DqK8t2P7jpbNI5LOpspyne3DKn6cO1Je9Kmb\n",
+ "lHOET0m6w/Y+2y+X9G5Jn02Yp7ZcnC19RNKFiPiD1Hkkyfarbd9aPt6tYlFD0u+5iPhgREyU3fRT\n",
+ "kj6furxtv8L2ePn4lSpmLzZd4TTodeB1+jH4w7bPlXNyDUnvS5xHkhZUXFA9Uy4h+qPUgWzfY3tJ\n",
+ "xWqGz9l+KEWOiPimpPdIekTFioFPR8TFFFla2f6kpH+Q9AbbS7b7Pg3Xhrsk/bSKlR5nyz+pV8rc\n",
+ "Junz5ffbk5JORcRjiTNtVId+2ivpiZav099GxKObvZhb6QEgU9yJCQCZosABIFMUOABkigIHgExR\n",
+ "4ACQKQocADJFgQNApihwAMjU/wMrPuHX/p0aFAAAAABJRU5ErkJggg==\n"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Plot the input data here\n",
+ "def plotData(X, y):\n",
+ " plt.plot(X, y, 'bo')\n",
+ " plt.axis([min(X) - 1, max(X) + 1, min(y) - 1, max(y) + 1])\n",
+ " \n",
+ " \n",
+ "plotData(X, y) "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "5) Implement a function which constructs features upto a input polynomial degree $d$!
\n",
+ "Note: _Constructing higher polynomial features is similar to what you implemented in Exercise 3 (SVM) of the previous exercise sheet._"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "def construct_poly(x,d):\n",
+ " ## Implement a method which given an array of size N, \n",
+ " ## returns an array of dimension (N,d)\n",
+ " res = np.zeros((len(x), d));\n",
+ " for i in range(len(x)) :\n",
+ " xi = x[i];\n",
+ " for j in range(d) :\n",
+ " res[i][j] = np.power(xi, j);\n",
+ " \n",
+ " return res;\n",
+ "\n",
+ "# testX = [1, 2, 3, 4, 5, 6];\n",
+ "# testY = [1, 1, 1, 1, 1, 1];\n",
+ "# foo = construct_poly(testX, testY);\n",
+ "# print(foo[1,:]);"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "6) Implement the Mean Squared Error Loss (MSE) as a function of the predicted and true values of the target variable!
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "def MSE(y_predict,y_true):\n",
+ " ## Implement mean squared error for a given input y and its predictions.\n",
+ " error = sum(np.power((y_predict - y_true), 2)) / float(len(y_predict));\n",
+ " return error;\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "7) By comparing the MSE find the degree $d$ for the polynomial that fits the training data best! You might find it useful to use the code below to interactively change the variable $d$, set $\\lambda = 1$ and keep it fixed. Plot the error as a function of different values of $d$!
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "('Best d: ', 6)\n",
+ "('Best theta: ', array([ -1.48019799e+00, 6.47756826e+00, 1.20573199e+00,\n",
+ " -6.46681792e-01, 1.20936028e-03, 1.08880545e-02]))\n",
+ "('mse errors for each d: ', [88.938436293253972, 58.242200994141662, 24.151575218954584, 17.772988325257703, 2.6042621684559881, 1.9740426997964349, 1.6839081464600774, 1.762196096936659, 1.8951684291047843, 1.8996652873425053])\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": [
+ "iVBORw0KGgoAAAANSUhEUgAAAXIAAAEACAYAAACuzv3DAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n",
+ "AAALEgAACxIB0t1+/AAAEilJREFUeJzt3X+QXedd3/H3JxbBNjZRRNq1SqTaOFWdVqGNB1KnQLPJ\n",
+ "OMTSBKFpZ0SYEnYysf5oi22YASwzU9A/lCQzDLHd4Q9MnG5LSCsMCLsjCy1GW2DaCYTIxbKtEfZU\n",
+ "lRKqNYE4scCeyY9v/7jH4/V6tbt3tfcePbvv18yOzvPcc+753pH0mec+5+x5UlVIktr1ur4LkCRd\n",
+ "GoNckhpnkEtS4wxySWqcQS5JjTPIJalxywZ5kruSPJHkZJK7ur4tSWaSnE5yLMnm0ZcqSVrMkkGe\n",
+ "ZCdwO/DdwD8B3p/kRuAAMFNVO4DHurYkqQfLjchvAj5TVS9V1deB/wH8K2APMN3tMw3sHV2JkqSl\n",
+ "LBfkJ4Hv66ZSrgZ2A28GJqpqrttnDpgYYY2SpCVsWurFqjqV5KPAMeBvgMeBry/Yp5L4e/6S1JMl\n",
+ "gxygqh4EHgRI8vPA54G5JNdV1fkkW4HnFjvWgJek1amqrHTfZYM8yd+tqueSbAf+JXALcAMwBXy0\n",
+ "+/PwWhRzKZJdR+HR9w1aB7sfgN1Hq47sGkcNfUpysKoO9l3HOPmZN4YN+pmHGgQvG+TAQ0m+Dfgq\n",
+ "8G+r6stJPgIcSvJh4Aywb+hK19y1Vy7ef81V461DksZrJVMr/2KRvr8Gbh1JRav2wkuL9194cbx1\n",
+ "SNJ4raPf7Dx3H+x/ZrA92fXd/iycvb+visZstu8CejDbdwE9mO27gB7M9l3A5S6jXFgiSY1rjnxw\n",
+ "vp27Yfsdg+mUCy/C2furTh4Z1/klaS0Mm53rKsglaT0YNjvX0dSKJG1MBrkkNc4gl6TGGeSS1DiD\n",
+ "XJIaZ5BLUuMMcklqnEEuSY0zyCWpcQa5JDXOIJekxhnkktQ4g1ySGrdskCe5J8mTSZ5I8utJvjnJ\n",
+ "liQzSU4nOZZk8ziKlSS91pJBnuR6YD9wc1W9DbgC+ABwAJipqh3AY11bktSD5UbkX2GwVufVSTYB\n",
+ "VwN/AewBprt9poG9I6tQkrSkJYO8W5vzF4GzDAL8+aqaASaqaq7bbQ6YGGmVkqSLWnLx5SQ3Aj8O\n",
+ "XA98GfiNJD8yf5+qqiQXXWYoycF5zdmqml1tsZK0HiWZ5JXFhoc/fqml3pL8EPDeqrq9a38QuAV4\n",
+ "D/DuqjqfZCtwvKpuWuR4l3qTpCGt9VJvp4BbklyVJMCtwFPAI8BUt88UcHg1xUqSLt2yiy8n+WkG\n",
+ "Yf0N4HPA7cC1wCFgO3AG2FdVzy9yrCNySRrSsNm5bJCPsxhJ0tpPrUiSLnMGuSQ1ziCXpMYZ5JLU\n",
+ "OINckhpnkEtS4wxySWqcQS5JjTPIJalxBrkkNc4gl6TGGeSS1DiDXJIaZ5BLUuMMcklqnEEuSY1b\n",
+ "NsiT/MMkJ+b9fDnJnUm2JJlJcjrJsSSbx1GwJOnVhlohKMnrgC8A7wDuAL5YVR9Lcjfwxqo6sGB/\n",
+ "VwiSpCGNeoWgW4FnquocsAeY7vqngb1DvpckaQ0MG+QfAD7dbU9U1Vy3PQdMrFlVkqQV27TSHZO8\n",
+ "HvgB4O6Fr1VVJVl0jibJwXnN2aqaHbJGSVrXkkwCk6s+fqVz5El+EPg3VXVb1z4FTFbV+SRbgeNV\n",
+ "ddOCY5wjl6QhjXKO/Id5ZVoF4GFgqtueAg4P8V6SpDWyohF5km8B/i9wQ1W90PVtAQ4B24EzwL6q\n",
+ "en7BcY7IJWlIw2bnULcfjroYSdLobz+UJF1mDHJJapxBLkmNM8glqXEGuSQ1ziCXpMYZ5JLUOINc\n",
+ "khpnkEtS4wxySWqcQS5JjTPIJalxBrkkNc4gl6TGGeSS1DiDXJIat6IgT7I5yUNJnk7yVJJ/lmRL\n",
+ "kpkkp5McS7J51MVKkl5rpSPye4EjVfVW4DuBU8ABYKaqdgCPdW1J0pgtu9RbkjcAJ6rqOxb0nwLe\n",
+ "VVVzSa4DZqvqpgX7uNSbJA1pFEu93QD8ZZJPJvlckge6xZgnqmqu22cOmFhFvZKkS7RphfvcDPxY\n",
+ "Vf1Jko+zYBqlqirJokP7JAfnNWeranaVtUrSupRkEphc9fErmFq5DvhfVXVD1/5e4B7gO4B3V9X5\n",
+ "JFuB406tSNKlW/Oplao6D5xLsqPruhV4EngEmOr6poDDQ9a6riQ7dye7jib7Zgd/7tzdd02SNoaV\n",
+ "TK0A3AF8KsnrgWeBDwFXAIeSfBg4A+wbSYUNGIT2O++FB97ySu/+G5OdVJ080l9lkjaCZadWLunN\n",
+ "N8jUSrLrKDz6vte+svto1ZFd469IUstGcdeKlnXtlYv3X3PVeOuQtBEZ5GvihZcW77/w4njrkLQR\n",
+ "GeRr4tx9sP+ZV/fd/iycvb+feiRtJM6Rr5HBBc/tdwymUy68CGfv90KnpNUYNjsNckm6zHixU5I2\n",
+ "GINckhpnkEtS4wxySWqcQS5JjTPIJalxBrkkNc4gl6TGGeSS1DiDXJIaZ5BLUuNWtEJQkjPAV4Cv\n",
+ "A1+tqnck2QL8N+Dv060QVFXPj6hOSdJFrHREXsBkVb29qt7R9R0AZqpqB/BY15YkjdkwUysLn8S1\n",
+ "B5jutqeBvWtSkSRpKMOMyH8vyWeT7O/6JqpqrtueAybWvDpJ0rJWNEcOfE9V/b8kfweYSXJq/otV\n",
+ "VUkWfbB5koPzmrNVNbuqSiVpnUoyCUyu+vhhF5ZI8nPABWA/g3nz80m2Aser6qYF+7qwhCQNac0X\n",
+ "lkhydZJru+1vAb4feAJ4GJjqdpsCDg9friTpUi07Ik9yA/DbXXMT8Kmq+oXu9sNDwHYucvuhI3JJ\n",
+ "Gp5rdkpS41yzU5I2GINckhpnkEtS4wxySWqcQS5JjTPIJalxBrkkNc4gl6TGGeSS1DiDXJIaZ5BL\n",
+ "UuMMcklqnEEuSY0zyCWpcQa5JDXOIJekxq0oyJNckeREkke69pYkM0lOJzmWZPNoy5QkXcxKR+R3\n",
+ "AU8BLy8ndACYqaodwGNdW5LUg5UsvvxmYDfwq8DLSw/tAaa77Wlg70iqkyQtayUj8l8Cfgr4xry+\n",
+ "iaqa67bngIm1LkyStDKblnoxyfuB56rqRJLJxfapqkpy0RWckxyc15ytqtlV1ClJ61aXr5OrPr7q\n",
+ "ohlMkv8AfBD4GnAl8K3AbwHfDUxW1fkkW4HjVXXTIscPtRK0JGn47FxyaqWqfqaqtlXVDcAHgN+v\n",
+ "qg8CDwNT3W5TwOHVFixJujTD3kf+8vD9I8B7k5wG3tO1JUk9WHJq5ZLf3KkVSRramk6tSJIufwa5\n",
+ "JDXOIJekxhnkktQ4g1ySGmeQS1LjDHJJapxBLkmNM8glqXEGuSQ1ziCXpMYZ5JLUOINckhpnkEtS\n",
+ "4wxySWqcQS5JjVsyyJNcmeQzSR5P8lSSX+j6tySZSXI6ybEkm8dTriRpoWVXCEpydVX9bZJNwB8B\n",
+ "PwnsAb5YVR9Lcjfwxqo6sMixrhAkSUNa8xWCqupvu83XA1cAX2IQ5NNd/zSwd8g6JUlrZNkgT/K6\n",
+ "JI8Dc8DxqnoSmKiquW6XOWBihDVKkpawabkdquobwD9N8gbgd5O8e8HrleSi8zNJDs5rzlbV7Cpr\n",
+ "laR1KckkMLnq45ebI19wsn8PvAjcDkxW1fkkWxmM1G9aZH/nyCVpSGs6R57kTS/fkZLkKuC9wAng\n",
+ "YWCq220KOLy6ciVJl2q5qZWtwHSS1zEI/f9SVY8lOQEcSvJh4Aywb7RlSpIuZqiplaHf3KkVSRra\n",
+ "mt9+KEm6vBnkktQ4g1ySGmeQS1LjDHJJapxBLkmNM8glqXHLPmtFl7dk527YdidceyW88BKcu6/q\n",
+ "5JG+65I0PgZ5wwYh/s574YG3vNK7/8ZkJ4a5tHE4tdK0bXe+OsRh0N5+Rz/1SOqDQd60a69cvP+a\n",
+ "q8Zbh6Q+GeRNe+GlxfsvvDjeOiT1ySBv2rn7YP8zr+67/Vk4e38/9Ujqg08/bNzgguf2OwbTKRde\n",
+ "hLP3e6FTatuw2WmQS9JlxsfYStIGs2yQJ9mW5HiSJ5OcTHJn178lyUyS00mOvbwknCRpvJadWkly\n",
+ "HXBdVT2e5BrgT4G9wIeAL1bVx5LcDbyxqg4sONapFUka0ppPrVTV+ap6vNu+ADwNfDuwB5judptm\n",
+ "EO6SpDEbao48yfXA24HPABNVNde9NAdMrGllkqQVWfGzVrppld8E7qqqF5JXRv1VVUkWnaNJcnBe\n",
+ "c7aqZldXqiStT0kmgclVH7+S2w+TfBPw34FHq+rjXd8pYLKqzifZChyvqpsWHOccuSQNac3nyDMY\n",
+ "en8CeOrlEO88DEx121PA4WEKlSStjZXctfK9wB8Afwa8vPM9wB8Dh4DtwBlgX1U9v+BYR+TrmM9C\n",
+ "l0Zj2Oxcdo68qv6Ii4/cb13pibS++Cx06fLhb3ZqlXwWunS5MMi1Sj4LXbpcGORaJZ+FLl0uDHKt\n",
+ "ks9Cly4XPsZWq+az0KXR8HnkktQ4n0cuSRuMQS5JjTPIJalxBrkkNc4gl6TGGeSS1DiDXJIaZ5BL\n",
+ "UuMMcklqnEEuSY1byVJvDyaZS/LEvL4tSWaSnE5yLMnm0ZYpSbqYlYzIPwnctqDvADBTVTuAx7q2\n",
+ "JKkHywZ5Vf0h8KUF3XuA6W57Gti7xnVJklZotXPkE1U1123PARNrVI8kaUiXfLGzBs/BHd2zcCVJ\n",
+ "S9q0yuPmklxXVeeTbAWeu9iOSQ7Oa85W1ewqzylJ61KSSWBy1cevZGGJJNcDj1TV27r2x4C/qqqP\n",
+ "JjkAbK6q11zwdGEJSRremq8QlOTTwLuANzGYD/9Z4HeAQ8B24Aywr6qev9RiJEku9SZJzXOpN0na\n",
+ "YAxySWqcQS5JjTPIJalxBrkkNc4gl6TGGeSS1DiDXJIaZ5BLUuMMcklqnEEuSY1b7WNspd4kO3fD\n",
+ "tjvh2ivhhZfg3H1VJ4/0XZfUF4NcTRmE+DvvhQfe8krv/huTnRjm2qh8+qGakuw6Co++77Wv7D5a\n",
+ "dWTXaM/d3zeBvs7tZ+7nG9+w2emIXI259srF+6+5apRn7fObQF/n9jOP77yXrKpG9kO3pOe4f4DJ\n",
+ "Ps7b589G+cxw21GoGvwcr1e2dz06vvPW2M7rZ944n/nVdVDD7L9e71qZ7LuAHkz2XcB4nLsP9j8z\n",
+ "2J7t+m5/Fs7eP9rz9vNN4LXnnh3juf3M4zvvpXFqRU2pOnkk2QnsvgP+/K3wx0/D2ftH/7X3hZcW\n",
+ "77/w4mjP2+e5/czjO++lWa8jcq1jVSePDC5sPvOfqo7sGs/c5fxvAi8bxzeBPs/tZx7feS/NyO9a\n",
+ "GdmbS9I6VpfL4suSpNFzakWSGmeQS1LjDHJJaty6C/IktyU5leTPk9zddz2jlmRbkuNJnkxyMsmd\n",
+ "fdc0DkmuSHIiySN91zIOSTYneSjJ00meSnJL3zWNWpJ7un/XTyT59STf3HdNay3Jg0nmkjwxr29L\n",
+ "kpkkp5McS7J5ufdZV0Ge5ArgPwK3Af8I+OEkb+23qpH7KvATVfWPgVuAf7cBPjPAXcBTwEa5Wn8v\n",
+ "cKSq3gp8J/B0z/WMVJLrgf3AzVX1NuAK4AN91jQin2SQV/MdAGaqagfwWNde0roKcuAdwDNVdaaq\n",
+ "vgr8V+AHe65ppKrqfFU93m1fYPAf/O/1W9VoJXkzsBv4VWDdP5QtyRuA76uqBwGq6mtV9eWeyxq1\n",
+ "rzAYpFydZBNwNfCFfktae1X1h8CXFnTvAaa77Wlg73Lvs96C/NuBc/Pan+/6NoRuFPN24DP9VjJy\n",
+ "vwT8FPCNvgsZkxuAv0zyySSfS/JAkqv7LmqUquqvgV8EzgJ/ATxfVb/Xb1VjM1FVc932HDCx3AHr\n",
+ "Lcg3ytfs10hyDfAQcFc3Ml+XkrwfeK6qTrABRuOdTcDNwC9X1c3A37CCr9stS3Ij8OPA9Qy+YV6T\n",
+ "5F/3WlQPavCLPsvm2noL8i8A2+a1tzEYla9rSb4J+E3g16rqcN/1jNg/B/Yk+T/Ap4H3JPnPPdc0\n",
+ "ap8HPl9Vf9K1H2IQ7OvZdwH/s6r+qqq+BvwWg7/7jWAuyXUASbYCzy13wHoL8s8C/yDJ9UleD/wQ\n",
+ "8HDPNY1UkgCfAJ6qqo/3Xc+oVdXPVNW2qrqBwcWv36+qH+27rlGqqvPAuSQ7uq5bgSd7LGkcTgG3\n",
+ "JLmq+zd+K4OL2xvBw8BUtz0FLDs4W1dPP6yqryX5MeB3GVzl/kRVreur+8D3AD8C/FmSE13fPVV1\n",
+ "tMeaxmmjTKfdAXyqG6A8C3yo53pGqqr+d/dN67MMroV8DviVfqtae0k+DbwLeFOSc8DPAh8BDiX5\n",
+ "MHAG2Lfs+/isFUlq23qbWpGkDccgl6TGGeSS1DiDXJIaZ5BLUuMMcklqnEEuSY37/1VfWTzms98x\n",
+ "AAAAAElFTkSuQmCC\n"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "bestTheta = 1;\n",
+ "bestMSE = 9999999999;\n",
+ "bestD = 0;\n",
+ "alpha = 1.0;\n",
+ "\n",
+ "dMax = 10;\n",
+ "mseErrors = [];\n",
+ "\n",
+ "for d in range(dMax) :\n",
+ " newPoly = construct_poly(X, d);\n",
+ " newTheta = wRidge(newPoly, y, alpha);\n",
+ " newMSE = MSE(newPoly.dot(newTheta), y);\n",
+ " mseErrors.append(newMSE);\n",
+ " if newMSE < bestMSE :\n",
+ " bestMSE = newMSE;\n",
+ " bestTheta = newTheta;\n",
+ " bestD = d;\n",
+ " \n",
+ "print('Best d: ', bestD);\n",
+ "print('Best theta: ', bestTheta);\n",
+ "print('mse errors for each d: ', mseErrors);\n",
+ "plotData(range(dMax), mseErrors);"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "collapsed": false,
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": [
+ "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEKCAYAAADpfBXhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n",
+ "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3XecHVX9xvHPk4SQQAgldEITBESqSm9RaSLSpEtvChqQ\n",
+ "3pTJIE1RVAQUBQHp7SeCgoBCAFEBJdSETui9Q4Ak5Pv740xks9lkb925e/d5v177yu69M2e+G8iz\n",
+ "Z8+cOUcRgZmZtZd+ZRdgZmaN53A3M2tDDnczszbkcDcza0MOdzOzNuRwNzNrQw53M7M25HC3HiVp\n",
+ "vKSPJQ3r9PoYSVMkLVZ8PVzS1ZJek/S2pAcl7V68t0Rx7HudPrabwTW3l/RPSR9IurWb+o7p1OYE\n",
+ "SZ9ImqfDMRtKulfS+5Kem3pdSctI+pOkVyW9IemvkpbpcN4Kkm4svqcpXVz7c5JuKb7fxyVt1en9\n",
+ "2SSd1eHv5Lbu/8atr3K4W08L4Clgp6kvSFoRGFy8N9WFwDPAYsA8wK7AK53amjMi5ujwceUMrvkG\n",
+ "cBpwSrfFRZzUsU3gx8CtEfFmUevywMXA0cBQYCXgv1PrAa4BlgEWAO4G/tSh+YnAZcDena8raUBx\n",
+ "7LXA3MB+wEWSPtvhsN8CcwHLFcd8v7vvx/ou+QlV60mSngbOAbaMiNWL134KvAmcACwREc9Keg9Y\n",
+ "JyIe6KKNJUg/IAZExHQ94Jlcex/gWxHx5QqPF/AkkEXEhcVrlwCPR0RWwfnzAK8DwyLirQ6vLw08\n",
+ "FhH9Ory2AvCv4gfK1NduBO6KiOMkLQfcBSwSEe9XUr/1be65Wxn+DQyVtJyk/sAOwEVdHHOWpB2m\n",
+ "DtV0Qc0sElgPmA+4usNra5By/wFJL0q6UNLcMzh/feCljsFepX7A54vPVyf9JnN8MSzzgKRtamzX\n",
+ "+gCHu5XlQmA3YCNgLPBCp/e3A+4Afgg8VYzJf6nTMa9LeqvDx7INrnF34MqImNDhtUWBXYBtgM+S\n",
+ "hpN+1flEScOBM4BDKrzWo8Crkg6XNIukjUk/HGYr3h8OrAC8DSwEfA+4oOjRm03H4W5lCFK4f4sU\n",
+ "oH+gUy88It6OiKMjYgXS+PV9pPHsjoZFxNwdPh5tVIGSZgO2BS7o9NYE4LyIeCIiPgBOAjbrdO58\n",
+ "wE3AmRFxeSXXi4hJwFbA14GXgIOBK4Dni0M+BCYBJ0TE5Ii4HbgV2LiGb8/6AIe7lSIiniWNm38N\n",
+ "+L9ujn0D+Bmw8EyGQCq6bBXHbg28ERGdZ6RMdw+go6K+m4BrIuLkqoqLeDAiRkTEvBHxNWAp0k3Z\n",
+ "jtftPBTlm2bWJYe7lWlv4CsR8WHnNyT9WNLnJQ2QNAewP+lGZsfx64rG3CX1kzQImAXoJ2lWSbN0\n",
+ "c9rU3yg6Ow/YU9KSRe/+KOC64jpDgRuBf0TEMTOoZRAwsPh8VkmzdnhvRUmDiimPh5F+Yzm/ePs2\n",
+ "4Fng6OLvZB1gRHE9s+k43K00EfFURNzb8aUOnw8G/gi8RZqxsiiwRacm3u40J31GUwN3Iw2nnEW6\n",
+ "SfohcPbUN4tz1+nw9SKk4Jwu3CPivOL1u4DxRVsHFm9vDXyJFP5Ta3q3GH+fOstnAvBQ8b1+CIzr\n",
+ "0PyuwIukKZ9fBjYqhmuIiMnAlqQhoLeL+neNiMdm8D1bH1f3VEhJvyeNE74aESsWr40C9gFeKw47\n",
+ "OiL+WteFzMysYo3ouZ8HbNrptQBOi4hViw8Hu5lZD6o73CPiDtKvzp01ew6ymZnNQDPH3EdKul/S\n",
+ "uZLmauJ1zMysk2aF+6+BJYFVSHN2f9ak65iZWRcGNKPRiHh16ueSzqGYKtaRJM/PNTOrQUR0O+zd\n",
+ "lHCXtFBEvFR8uTXwYFfHVVJgq5I0KiJGlV1HrVx/uVx/eXpz7VB5x7jucJd0KbABMK+k54AMGCFp\n",
+ "FdKsmaeBb9d7HTMzq1zd4R4RO3Xx8u/rbdfMzGrnJ1RrN7rsAuo0uuwC6jS67ALqNLrsAuo0uuwC\n",
+ "6jC67AJ6QmmbdUiK3jzmbmZWhkqz0z13M7M25HA3M2tDTZkKaWZmjaNcw4Bli4+KONzNzHqIhIBZ\n",
+ "gTmBodN8zPr23Cw5+jPM/+CSzP3UcIY+tyBDXxzGHC/MSb/Z+/PWZz7m9WU+mXZL35lcyzdUzcxm\n",
+ "rgjlwXQO5K5CeqbvTRnKkFemMN/DHzL/w5OY/6Fg3kf7M/eTg5j9tcF8OPd7vL/g67y/4Eu8O/xZ\n",
+ "3lzqaZ5f6zGeWe9ZYsC7wLugxyvJToe7mbUFiX6kXa4GknrHs87g80HAHFQe1FNfnwS8C7xT/NnV\n",
+ "R3pv9pc/ZPmr5mCJ2+ZhvnHzM+TFhZn1/cXpN+kziMmkDdE7fzwZWUzs/vusLDsd7mbWY5RLpLBc\n",
+ "CFi4+PPTj4+HLMVHcy/FewtP5M2lJ/Da8h/xygof88rKn/DOooJ+nYO6Y3gPACYCH3fxZ+fPpw/k\n",
+ "GQV1+ngvgmmCt/heFuHTsfBlgeWKPxck7RE8XYhHFm/U9XfocDeznlIE3TC6CuzpX5tEWi32048P\n",
+ "5n2Hu0auzQtrrMGs717I4rd9yHzjFmDocwsy2xsLM+u7i6IYwORBTzNp8FNMGvw4E4c+xgfzjWPs\n",
+ "to9wz3ffASZFNH7DcOUaAizDtCG+bPHa+3wa3I90+Hx8ZDG50bWAw93MmkC5+pM2K/880wb2AsAH\n",
+ "fBrYL9I5wIuPyOL9/7UnZgEOAI4FrgSyCF6fwbU7zhjp+PGZou2uhjpeiKz7kCu+r8Vm0P48wBNd\n",
+ "tR9ZvNNd243mcDezhlKuOYBLgSHAVUwb4C9HFh9V3Fa6Qfl14KfAM8AhETxcY10DSPtHdBXMQ4DH\n",
+ "6BT4wOJ8OoSyLLAU8AZd/4B4NrKYUkttzeBwN7OGUa7FSPsy/Bv4XmQxqea2xArAacCiwKHADc0Y\n",
+ "TgFQrrmYfkhlEWA80wb44x1/o2hlDnczawjlWg24hrSj2s8rGebosh0xH3A88E3gR8BvIqj5h0Rf\n",
+ "VWl2+iEmM5sh5doWOAvYJ7K4tqY2xKzASOAo4CJguQjebFyV1hWHu5lNp5j9chTp5ukmkcWYqttI\n",
+ "4+pbAacC44B1Ini0oYXaDDnczWwayjUQ+C2wArBmZPFi1W2IVUnj6vMC+0dwc2OrtO54VUgz+59i\n",
+ "uuHNpAeNNqg22CUWlDgXuAG4HFjVwV4Oh7uZAaBcy5Jmw/wb+GZk8UHF54pBEkcDD5GmFC4bwW8i\n",
+ "aMqDPNY9D8uYGcr1ZeAy4JjI4tyKz0vj6tsBPwHuBdaM4InmVGnVcLib9XHKtTdwErBjZHFrxeeJ\n",
+ "LwG/AGYH9ojoG3uT9hYOd7M+Srn6AacAWwPrRRaPVXSeWIT0w2Aj4IfA+RF80rRCrSYOd7M+SLlm\n",
+ "J805n4c0I6ailQolPgv8AziHNK7+XvOqtHr4hqpZH6NciwC3A28DG1UR7EOBPwHHRXCsg721OdzN\n",
+ "+hDl+gJpNsyVwF6VbA4B/9sI4yLgtgjObmKJ1iAeljHrI5RrS9Jwyncii8o24vxUDswFbNvwwqwp\n",
+ "HO5mba5YSuAQ4GBgs8jinqrOF9sBuwGrdd6NyFqXw92sjSnXLMCZwOrAWpHFc1WdL1YmLRy2SQSv\n",
+ "NqFEaxKHu1mbUq65SWPrH5KmOlZ1A1RiXtJSvyMjuLcJJVoT+YaqWRtSrqWAfwEPAlvVEOyzkH4w\n",
+ "XB7BZU0o0ZrMPXezNqNc65GCeVRk8ZsamzmN1OM/tmGFWY9yuJu1EeXajbQv6S6RxU01tSH2ATYG\n",
+ "1vCTp72Xw92sDRRLCRwP7AyMiCzG1tSOWJu0tMD6EbzdwBKthznczXo55RoMXEDa+HmNyOK1mtoR\n",
+ "w0nDOXtG8EgDS7QS+IaqWS+mXAsCo4FJwFfrCPbBwB+BX0Xwl8ZVaGVxuJv1Usq1Emkpgb+Qxtg/\n",
+ "qqmdtCb7b4EngR83rkIrU93DMpJ+D3wdeDUiVixem4e0xdbiwHhg+4jw+J1ZgyjXZsD5wIGRRb1T\n",
+ "FQ8GPg+sG0HUW5u1hkb03M8DNu302lHAzRGxDPD34mszawDlGklaI2bLeoNdYmPgcGCrCCY0oj5r\n",
+ "DYqo/we1pCWA6zr03B8BNoiIV6Q0JhgRy3U6JyJCdV/crI9QrgGknY9GAJtHFuPrak8sDdwJbBfB\n",
+ "7XUXaD2i0uxs1myZBSLileLzV4AFmnQdsz5BueYk7XEqYJ3I4p262ktrs18LZA729tT0qZAREZK6\n",
+ "/PVA0qgOX46OiNHNrsest1GuJYA/A7cBB0UWk+tqL63NfiFwewS1PsFqPUTSCNJva9Wd18RhmRER\n",
+ "8bKkhYBbPSxjVj3lWgu4mrTX6a8iq/8frMTxwJeBr3oJ396n7GGZa4HdSdOqdietLGdmVVCuHYHT\n",
+ "gT0ji4bMPZfYlvRvcnUHe3uru+cu6VJgA2Be0vj6caR9Fq8AFmMGUyHdczfrWrG5xg+BvYFvRBYP\n",
+ "NKRdsRJp9tqmEfy3EW1az6s0OxsyLFMLh7vZ9JRrEGma42dJUx1fbki7aW32e4BjI7ikEW1aOSrN\n",
+ "Tj+hatYilGs+Us96IGnxr0YF+yyk36SvcLD3HQ53sxagXMsDdwG3AjtGFh82sPmfAR8DxzSwTWtx\n",
+ "XhXSrGTKtRFwMXBYZPGHhrYt9gI2wWuz9zkOd7MSKdd3gFHANyOLOxratliLNIXSa7P3QQ53sxIo\n",
+ "V3/SjklfA9aNLJ5oaPtiEeAqYC+vzd43OdzNephyzQFcAswGrBVZvNXQ9sUg0trsZ0Tw50a2bb2H\n",
+ "p0Ka9aBiO7xbgCeA/SOLSQ1tP63NfgFpxs1OXsK3/ZT9hKqZdW0PYBCwX2QxpQntfx9YEa/N3ue5\n",
+ "527WQ5RrGPAw8LXIYkzD2xcbAX8A1ozgmUa3b63BPXez1vNj4LImBfvSwEXA9g52A4e7WY9QrnVI\n",
+ "O5Yt3/C2xRyk9ZxGRXBbo9u33slPqJo1mXLNAvwGOCSyeLehbX+6NvudxTXMAPfczXrCQcCLwJVN\n",
+ "aDsjrci6vW+gWkcOd7MmUq5FSRvEr9mIjTamaVt8E9gTWM1rs1tnDnez5volaQelRj+BuhJpGOZr\n",
+ "EbzS3fHW9zjczZpEub5OmnO+c0PbFcNIu5t9P4L/NLJtax+e527WBMo1G2lO+36Rxc0Na1cMAG4E\n",
+ "/hvBEY1q13oPb9ZhVq5jgbsaGeyFnwITgaMb3K61GQ/LmDWYcn0O2A9YuaHtij2BzfDa7FYBh7tZ\n",
+ "AxWbW58F/CiyeLFh7Yo1SU+4bhBBQ1eRtPbkYRmzxvoWMCcp4BtCYmHS2ux7RzCuUe1ae/MNVbMG\n",
+ "Ua65gbHAlpHF3Q1pM63NfhvwpwhOakSb1rv5hqpZzzsRuKaBwS7SXPZngJMb0ab1HR5zN2sA5Vod\n",
+ "2JrGLgx2ELAKsI6XFrBqOdzN6qRcA0g97MMbtWWexIZMXbYg+KARbVrf4nA3q98BwNvAxY1oTGKp\n",
+ "oq0dIhjfiDat7/ENVbM6KNfCwP3AepHFI3W3l9Zm/xfw6wjOrLc9az++oWrWM04DftugYO9H2ibv\n",
+ "XzRwKqX1TR6WMauRcm0ErA7s1aAmjwPmB3b0DVSrl8PdrAbKNYjUux4ZWUyouz2xDemHxOoRfFxv\n",
+ "e2YOd7PaHAk8GFn8pd6GJFYEziatzf5y3ZWZ4XA3q5pyLQ2MBFatu61P12Y/2GuzWyN5toxZFYqF\n",
+ "wf4K3BxZ/LSuttLa7H8FxkRweCPqs/bn2TJmzbEdsDBp+7x6nQp8QnpYyayhPCxjViHlGkqa+rhD\n",
+ "ZDGprrbEHsDmpBuoXpvdGq6p4S5pPPAuqXcyKSJWb+b1zJrseODGyOLOehqRWAP4CTDCa7NbszS7\n",
+ "5x7AiIh4s8nXMWsq5VoV2An4fF3tiHmBK4F9IhjbiNrMutITY+6+aWq9mnL1A34NHBNZvF5zO+kJ\n",
+ "1POByyO4tkHlmXWp2eEewN8k/UfSvk2+llmz7EsaWjyvznYOBoYBx9RdkVk3mjoVUtJCEfGSpPmA\n",
+ "m4GREXFH8V5AzBLB5KYVYFYn5VoAeAj4amTxQM3tpHH260g3UMc3qDzrgyqdCtnUMfeIeKn48zVJ\n",
+ "fyStw3HHp0dscLF0+9Q9IUdHxOhm1mNWg1OBC+oM9rmBy4BvO9itWpJGACOqPq9ZPXdJswH9I+I9\n",
+ "SbMDNwF5RNxUvB8sfcO98fimX2xKAWZ1Uq4RpFUal48s3q+pjbRV3lXACxEc2MDyrI9qhYeYFgDu\n",
+ "kHQfcBfw56nB/j+rnbm8VN/sA7NmUK6BpIXBDqo12AvfBZYAP4FqPatpwzIR8TRp/8cZW/LWKQz/\n",
+ "59Gw9i7NqsOsRocCT5HWfamJxBeADFjLKz1aTyt3+YGJQ37HqudvKzG01DrMOlCuJUnhPjKy2sYt\n",
+ "i/+nLwdGRvBEI+szq0S54T7klZNZ8ZJ+zP/g/qXWYVYoFgY7HTgtsni6pjbSOPvZwC0RXNbI+swq\n",
+ "VWq4Rxav8N5CN7HSRYcW/yDMyrYlsDRQz4qPewMrAN9vSEVmNSh/Vci5njmcL5w7D3M9vXHZpVjf\n",
+ "plxDSKs9HhBZTKypDbECcDKwfQQfNrI+s2qUHu5x/MRxTBg2lpX/cHLZtVifdxxwe2Rxay0nS8wO\n",
+ "XAEcFsG47o43a6bSwx2AfpOPYKWLVtbgNxctuxTrm5RrBWAP4LA6mjkDuCeCCxpSlFkdWiPc53nq\n",
+ "Rvp98jpfPKeunW3MatFhYbAssnilpjbEbsCapHntZqVriXCPLIJ3h/+Y5a7ZSmJg2fVYn7M7MCvw\n",
+ "21pOllgO+BmwQwT1PPBk1jAtEe4ALH7H6cz19BTW/PkRZZdifYdyDSPdAP1OZFH1jkgSg0nz2Y+N\n",
+ "oOb1Z8warWXCPbKYzEtfvISlbzyo7FqsTzkFuCKyuLfG808DxgG/a1xJZvVrmXAHYPCbh7LI3fNo\n",
+ "7Z99vexSrP0p1zrAZsAPazpfbA9sBOwXQfPWzjarQVPXc5/phWewspl23uI2pvQbFpdds0IZdVnf\n",
+ "oFyzAP8FToosqn6KVGIp4F/A1yL4b6PrM5uRVlgVsjZvLjWSJW5bXhsdtWTZpVhbOxB4hTReXhWJ\n",
+ "WYvzTnCwW6tquZ47gHb52pNMmv2RuPwqD89YwynXosAYYO3I4rGqzxe/ABYHtvFwjPW03ttzB3hm\n",
+ "/YzFb99E3/nC4LJLsbb0C+DMGoN9K2ArYC8Hu7Wy1gz3fxx9Ma8tP4F3hp9YdinWXpRrM2Bl0vTH\n",
+ "6s4Vi5NWe9wxgrcaXZtZI7VkuEcQPLHJb1nw/n2LpwfN6qZcs5GWCPhuZPFRVeeKWYBLgZ9G8O9m\n",
+ "1GfWSK0bnGP2PI6P5hrMM+vuUXYp1jaOAf4TWdxYw7k/At4mPYlq1vJaNtzj/QUnMG6bm5j9tazs\n",
+ "Wqz3U67lgG8DB1d9rtgU+BawewRTGl2bWTO0bLgDcN8ehzLw/eE6dPjaZZdivVexu9JZwAmRxQtV\n",
+ "nSsWAc4DvhXBa82oz6wZWjrc4+3Fx3H/ro/z0ZynlV2L9Wo7A3MDZ1ZzksQA4BLgzAhub0ZhZs3S\n",
+ "0uEOwP27HsfQF76oXEuUXYr1Pso1F3AqaWGwyVWe/kNgEjXMrDErW+uH++vLX839u03gzaVOKrsU\n",
+ "65VOBK6NLO6q5iSJrwD7ArtEUPVqkWZla/lwj+AT7t/lDIa8/E3lmrvseqz3UK7VgG2Ao6s6TywA\n",
+ "XAjsFsHLzajNrNlaPtwBeHH1n/PIFuKD+bybvFVEufoDvwGOjCwqfuBIoh8p2M+L4G/Nqs+s2XpF\n",
+ "uEfwOmP2uoEBH31fubxTk1XiAOA9UlBX40hgEDCq0QWZ9aReEe4APL3hCbz0hYF8MmDnskux1qZc\n",
+ "CwHHAQdEVvnKeBLrAgcBO0dQ7c1Xs5bSa8I9gnu4a+QzTJp9VDFv2WxGTgPOiSzGVnqCxLykaY97\n",
+ "R/B80yoz6yG9JtwBeGSrk5kwbBiwcdmlWGtSro2AtUjLBVR2jhBwPnB5BH9pUmlmPap3hXv0v5w7\n",
+ "jg4+HlLTtmjW3pRrEOlBpZGRxYQqTj0YmBc4timFmZWgV4V7BB/x0I6/YcqAlZVrlbLrsZZzBDA2\n",
+ "sriu0hMkVgeOIi3jO7FplZn1sF4V7gBMGnIW/zysH5MHHlF2KdY6lGtp0tZ5B1Z8jpgLuAz4dgTj\n",
+ "m1SaWSl6XbhHMJ5797kNtGWxXZr1ccUN9jOAn0QWz1Z0ThpnPwf4cwR/bGZ9ZmXodeEOwAcL/JL7\n",
+ "d/2A4KCyS7GWsC0wHPh5FeccACwJHN6UisxK1pIbZHd/Lv2Y+8kn+d5y89B/8mKRxTuNrs96B+Ua\n",
+ "CowFdoos7qjoHLEqcBOwVgRPNLM+s0br3RtkdyOCKby11Ok8s8FbpMWdrO/KgZurCPY5gCuAkQ52\n",
+ "a2dNC3dJm0p6RNLjko5swiXO528nz8OU/gd7SYK+qZgx9S3SLJnuj0/j7GcDt0ZwWTNrMytbU8Jd\n",
+ "Un/SDa5NgeWBnSR9rpHXiOAtXlztMt76zEfA9o1s21pfsXH6r4FjI4tKd0jaC1gR8AJ01vaa1XNf\n",
+ "HXgiIsZHxCTSdLMtm3CdM7np1KEEh3lJgj5nHyCAcys5WGIF4BRg+wiqecDJrFdqVrgvAjzX4evn\n",
+ "i9caKoL7efQbj/LxnPMAX210+9aalGt+4ATS7krdblgtMTtwOXBYBOOaXZ9ZK2hWuPfgFJx+Z3Lb\n",
+ "Dz4ADuu5a1rJTgMujCweqPD4XwH/ieCCJtZk1lIGNKndF4CODxgtCtOvtCdpVIcvR0fE6BqudTV3\n",
+ "f+80Njx6mHKtVMU/eOuFlGtz0sJgK1V0vNgVWBv4UjPrMmsWSSOAEVWf14x57pIGAI+ShkpeBO4G\n",
+ "doqIcR2OqXme+/TX40d8Y58N+eK5j0YWezSiTWs9yjUn8BCwe2RxS7fHi2WBfwBfjcA/9K0tlDrP\n",
+ "PSImA98DbiQ9YHJ5x2BvgrP52ynLEdpCuRo+tm8t41Tg+gqDfTBpPvsPHOzWFzVrWIaIuAG4oVnt\n",
+ "T3stnpfm/TvPrDuMJe4YSVrlz9qIcm1Imlq7YoWn/Ax4BPht04oya2G98gnVGTiT6343nGAf5Zqj\n",
+ "7GKscZRrCPA70uyYbpeakNiOtKHLvhE9eXPfrHW0U7iP5o1lJ/Luog8Ce5ddjDXUScDtkcX13R0o\n",
+ "8RnShh07RPBu0ysza1FtE+5FD+0srv3tFOBg5WrakJP1HOVaj7Tq48HdHitmJc1nPyGC/za7NrNW\n",
+ "1jbhXriQJzddlUmDXiQFgvViyjWY9ATqdyOLNys45RTSNNxfNbUws16grcK9+DX8Em49fjxwnHIN\n",
+ "L7kkq88o4L7IotvNNCS2ALYG9vI4u1mbhXvhLP556AgmD7wM+K9yuQffCynXasAewMhujxWLkW64\n",
+ "7hRBJT18s7bXKzfr6L5tbgF+xyg9CVwM3AEcFFm814zrWWMp16zAf4GTIotLZnqsmAUYDVwTwak9\n",
+ "UJ5Zqdp6s44KnAkcyah4FVgVmAKMUa41yy3LKnQM8BRwaQXHHg+8Q5rXbmaFdu259wd+SPqV/kLg\n",
+ "JEZpXdL632eSeoSTm3Ftq49yrQz8DVglsnhhpseKTUibXH8hgkrXdDfr1fp0zz2CTyIYBXwOEDCO\n",
+ "UbES47ZaH1gPuE25PlNmjTa9Yvrq74EjKwj2hYHzgV0c7GbTa8twnyqCVyM4CPgisCSX//F2jp94\n",
+ "PZMGXwPcpVy7eZOPlnIY8AZw3swOKn4zuwQ4K4LbeqIws96mLYdlZnxNViRt8rAKK59/DlvtuQPi\n",
+ "YdJj7W/1ZC02LeX6HOnG95cii/EzPC7tg3oaacnfjSP4pGcqNGsNlWZnnwr3T6/N2sApzPLBvOy1\n",
+ "7lMseN9KiN0iq2k9eauTcvUnBfvFkcWZMzwu9dh/Qwr2zSJ4o4dKNGsZfXrMvTsR/BPYgEmzH8bZ\n",
+ "Yxblyss/YPKsVyrXKco1sOz6+qCRwGTSDe8uFUsLXAEsQVqf3cFuNhN9suc+bR30A3ZkyMsnst32\n",
+ "s7PQva8z8INtIotHyq6tL1CupYC7gLUii8e7PEbMAfwReIt0A/XjHizRrKV4WKZKEgPRJ/uw2pkn\n",
+ "8ZUfDuKdxU5kgYdOiKykv6A+QLn6AX8H/hxZdDlPXWJe4HpgDHCAx9itr/OwTJUimBhT+p/F3Qcu\n",
+ "wpWXn0X0z3jhS09r/RMr3RzCqrcvMBvwi67elFiUNBb/N+A7DnazyjncO4ngg3hi00O44ZfDeWfx\n",
+ "l1n9jPu1xulXSMxddm3tRLkWI81c2iuymC60i/1P7wDOieAYLwZmVh0Py3RDe47Yjvkf+j1jtx3A\n",
+ "3088gQ+H/TyCCWXX1ZsVzxZcD9wZWZww3fvii8CfgWMiZj7n3ayv8bBMg8R5o69ktjcWY/krb+Hb\n",
+ "XziChf7ztMR3igWrrDa7AQsCP+78hsQI0t67+zvYzWrnnnuFit7mLnwy4HT+efir3PKjfkT/HwJX\n",
+ "RDCl7Pp6C+VaCLgf2CSyGDPNe2Ir0obWO0Rwaxn1mbU6z5ZpEuVaEriI9+cfxDn/6sfbnwngaOAm\n",
+ "jwvPXPED8o/AQ5HFD6Z5T+wBnAxs7i3yzGbMwzJNElk8DWzAkFev4aClFmbz79wM/BK4RcJLCs/c\n",
+ "9sAywI86vihxCJADIxzsZo3hnnsdivXhL2JKv9v5xdP38O5iR5M2mfhBBA+XXF5LUa75gAeArSKL\n",
+ "u+B/68ScSNoeb+MIniuxRLNewT33HhBZ/BtYlX5TgkMWP4RDFtmZNH3vFonzJBYvucRW8kvgkg7B\n",
+ "PnWdmI2A9RzsZo3lcK9TZPFeZLE3cBRDX7yaUZqN+R5eDngeuFfi5xLzlVxmqZRrS2B10gYqU9eJ\n",
+ "uRRYGvhKBK+XWJ5ZW/KwTAMp13DSBhKDgF0ZFROAHwA7A6cDp0XQp/ZxVa65gYeAnSOL2ySGAP8H\n",
+ "vA/sHMFHpRZo1st4WKYEkcXzwMakGSF3M0obMUoHAquReqmPSxxU9Fz7ip8B1xTBPoy0lMCzwPYO\n",
+ "drPmcc+9SZRrFdJuQfcD+0cWb0usRLqBuCKQARe183opyrUJcDawIqNiKHAT8BfgSE8bNauNe+4l\n",
+ "iyzuI23v9zpwv3JtEMEDEXwD2IW0aNYDElsWs0bainLNQQr2/RgVCwL/AC6I4AgHu1nzuefeA5Rr\n",
+ "M+Ac4ALdFmOOAAAJ/UlEQVQgiywmFoG+GenBnQ+Ao9ppP1DlOhMYzKj4Fam3flwE55Rcllmv5557\n",
+ "C4ksrgdWAVYA/qlcy0YQEfyleP0M4DyJGyRWLbPWRlCuDYEtOffOq4AbgZEOdrOe5XDvIZHFq8AW\n",
+ "wLnAP5RrP+VSBFMiuBhYjrQS4vUSl0osXWa9tVKu9YFL+McRv+a5tS8gzYi5uuy6zPoaD8uUQLk+\n",
+ "B1xMmjWyb2Tx2v/eS1MFDwIOBq4Ejo/gpVIKrZJyjSB0BTf88jruHvl1YIsI7i67LrN24mGZFhZZ\n",
+ "jAPWBB4F7lOuTf/3XvB+BCcCy5Lmgj8kcZLEXOVUWxkdvuCmTJztOi786wDuHjkHsK6D3aw87rmX\n",
+ "TLm+TLrR+kfgyMhimrnfxVZzxwFbAacCZ7TSZiESg1j7Jz9l3Z/sz3Vn38m4b34vggfKrsusXZXa\n",
+ "c5c0StLzksYUH5t2f1bfFFncCqwMLATco1zT7NkawXMR7AusR3qE/zGJ/creLERioMR3WObPz7L+\n",
+ "SfvyyFb7xdhvru9gN2sNTem5S8qA9yLitJkc4557B8Va57sBPwVOAn4ZWUy3CYjEaqTpk4uRlja4\n",
+ "qic3Cyl+qOwO/IAVL36NrfZYiv6TvxFZ3NlTNZj1Za0w5u7grkJkEZHFBcAawHbAX5Vr4emOC+6J\n",
+ "YEPgAOBw4B6JjZv9IJTEAIndgUeAHdlmlzP45i6L03/y1x3sZq2nmeE+UtL9ks6V1NI3A1tJZPEU\n",
+ "sD5wJ3Cvcm3d5XHB30jDNCcDvwL+LrFGo+uR6C/xLWAssBewF6P0S1a6+AjgG5HFvxp9TTOrX83D\n",
+ "MpJuJm1y3NmxwL+BqdP7fgQsFBF7dzo/SLvvTDU6IkbXVEybUq61gIuAW4CDI4v3uzxODAD2IK1X\n",
+ "cw9ps5CxdV1b9AO2BUYBb5OW672FUdqCtM/p5pHFPfVcw8y6J2kEMKLDS1lL7KEqaQnguohYsdPr\n",
+ "HnOvQLFGy+nAOsC3ZhaoEoOB7wJHkB6IGhXBs1VdLw3vbE36wTuBNFPnpghCubYBzgI2iyzureX7\n",
+ "MbP6lLpBtqSFIuKl4vODgdUiYudaCrREubYjLVNwOnBKZDHD1SSLOfGHAfuTplme1N2GGEWob04K\n",
+ "9SCF+vVTF/lSrm2L638tshhT/3dkZrUoO9z/QFozJYCngW9HxCu1FGifKjYD+QMwANg1snhmpseL\n",
+ "BUkzanYk/VD4eefNQopQ3wQ4HpiVNLTzp44rNyrXDsAvgE0ji/sb9x2ZWbVKDfdKONxro1z9gENJ\n",
+ "M2UOjiwu7vYcsRSpR74haZrl2cBE4KukUJ+TNLZ+dedplcq1M2nDjY0jiwcb952YWS0c7m1OuVYl\n",
+ "rU8zBvhuZPF2t+eIlUmbhawAPAfMTwr1K7raNES5dgF+AmwUWTzcuOrNrFYO9z5AuWYjLUnwddIw\n",
+ "zR0VnSfWBRYh9dQnz6Dt3Um9/I0ii7pm3phZ4zjc+xDl2hz4HfB7YFRkManO9vYiDddsGFk80oAS\n",
+ "zaxBWuEJVeshkcWfSTewVwHuVK5lam1LufYhjc9/xcFu1nu5595GivVp9ieF8zHAOZFV/h9Yub5N\n",
+ "egjtK5HFE82p0szq4WGZPky5lifdbB1P2gxkpnPci3MOID389NXI4snmVmhmtfKwTB9W3ABdE3iC\n",
+ "tBnIxjM7Xrm+R5pa+WUHu1l7cM+9zSnXV0hPqV4FHD3dZiC5DiJt6/eVyGJ8z1doZtVwz90AiCxu\n",
+ "IW0GMhy4u+NmIMp1CHAgMMLBbtZe3HPvI4qbrbuT5sWfQFpqYF9Sj/25Mmszs8r5hqp1SbmWIi0j\n",
+ "PIw0xv5CySWZWRUc7jZDytUfGBhZfFh2LWZWHYe7mVkb8g1VM7M+zOFuZtaGHO5mZm3I4W5m1oYc\n",
+ "7mZmbcjhbmbWhhzuZmZtyOFuZtaGHO5mZm3I4W5m1oYc7mZmbcjhbmbWhhzuZmZtyOFuZtaGHO5m\n",
+ "Zm3I4W5m1oYc7mZmbcjhbmbWhhzuZmZtyOFuZtaGHO5mZm3I4W5m1oZqDndJ20l6WNInkr7Q6b2j\n",
+ "JT0u6RFJG9dfppmZVaOenvuDwNbA7R1flLQ8sAOwPLApcJaktvsNQdKIsmuoh+svl+svT2+uvRo1\n",
+ "h25EPBIRj3Xx1pbApRExKSLGA08Aq9d6nRY2ouwC6jSi7ALqNKLsAuo0ouwC6jSi7ALqMKLsAnpC\n",
+ "M3rUCwPPd/j6eWCRJlzHzMxmYMDM3pR0M7BgF28dExHXVXGdqKoqMzOriyLqy11JtwKHRsS9xddH\n",
+ "AUTEKcXXfwWyiLir03kOfDOzGkSEujtmpj33KnS80LXAJZJOIw3HfBa4u5bizMysNvVMhdxa0nPA\n",
+ "msBfJN0AEBFjgSuAscANwAFR768HZmZWlbqHZczMrPWUOv9c0o8k3S/pPkl/l7RomfVUS9KpksYV\n",
+ "38P/SZqz7JqqMbMH0VqVpE2Lh+Mel3Rk2fVUS9LvJb0i6cGya6mWpEUl3Vr8P/OQpAPLrqkakgZJ\n",
+ "uqvIm7GSTi67plpI6i9pjKSZTmop++Gin0TEyhGxCnANkJVcT7VuAj4fESsDjwFHl1xPtbp8EK1V\n",
+ "SeoPnEF6OG55YCdJnyu3qqqdR6q/N5oEHBwRnycNx363N/39R8RHwJeLvFkJ+LKkdUsuqxYHkYa9\n",
+ "ZzrsUmq4R8R7Hb4cArxeVi21iIibI2JK8eVdwPAy66nWTB5Ea1WrA09ExPiImARcRnporteIiDuA\n",
+ "t8quoxYR8XJE3Fd8/j4wjvRcS68REROKTwcC/YE3SyynapKGA5sB5zDtRJbplN1zR9KJkp4FdgdO\n",
+ "KbueOuwFXF92EW1uEeC5Dl/7AbmSSFoCWJXUqek1JPWTdB/wCnBrMQGkN/k5cDgwpbsDmx7ukm6W\n",
+ "9GAXH98AiIhjI2Ix4HxS4S2lu/qLY44FJkbEJSWW2qVK6u9FfPe/BUgaAlwFHFT04HuNiJhSDMsM\n",
+ "B9bvTevMSNoceDUixtBNrx0aN899hiJiowoPvYQW7Pl2V7+kPUi/Jn21RwqqUhV//73BC0DHm+6L\n",
+ "Mu1SF9ZkkmYBrgYuiohryq6nVhHxjqS/AF8CRpdcTqXWBraQtBkwCBgq6Q8RsVtXB5c9W+azHb7c\n",
+ "EhhTVi21kLQp6VekLYubNb1Zb3io7D/AZyUtIWkgafXRa0uuqc+QJOBcYGxE/KLseqolaV5JcxWf\n",
+ "DwY2ohdlTkQcExGLRsSSwI7ALTMKdih/zP3kYojgPtJKbYeWXE+1fkW6EXxzMTXprLILqsaMHkRr\n",
+ "VRExGfgecCNptsDlETGu3KqqI+lS4J/AMpKek7Rn2TVVYR1gF9IskzHFR2+a+bMQcEuRN3cB10XE\n",
+ "30uuqR4zHab0Q0xmZm2o7J67mZk1gcPdzKwNOdzNzNqQw93MrA053M3M2pDD3cysDTnczczakMPd\n",
+ "zKwN/T9xkbdVhKP+GwAAAABJRU5ErkJggg==\n"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "x = X;\n",
+ "\n",
+ "##This function provides an interactive mode to change polynomial degree. \n",
+ "@interact(n=[1,16])\n",
+ "def plot(n):\n",
+ " X = construct_poly(x,n)\n",
+ " w = wRidge(X,y,alpha)\n",
+ " plt.plot(x,X.dot(w))\n",
+ " plt.title(\"MSE %f\" % MSE(X.dot(w),y))\n",
+ " plt.plot(x,y)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "8) Apply models with different values of $d$ after being trained on the training dataset, to the test data available [here](http://webdav.tuebingen.mpg.de/lectures/ei-SS2015/data/ex1_train.csv). Compare the errors on the test data to the ones from the training by plotting the error curves as functions of the polynomial degree in a single plot! What do you conclude?
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "## Read test data here"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "9) With a fixed optimal $d$, change the value of $\\lambda$ to one of the following values $[0.1, 1.0, 10.0]$ and find the minimum MSE!
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Hand in printed copy of completed notebook."
+ ]
+ }
+ ],
+ "metadata": {
+ "annotations": {
+ "author": "",
+ "categories": [
+ "intelligent-systems-1-2015"
+ ],
+ "date": "2015-04-30",
+ "location": "Beginning of next lecture",
+ "parent": "IS_SS2015",
+ "submission_date": "2015-05-07",
+ "subtitle": "Exercise Sheet 3, Linear Regression",
+ "tags": [
+ "IntelligenSystems",
+ "Course"
+ ],
+ "title": "Intelligent Systems 1 - Summer Semester 2015"
+ },
+ "celltoolbar": "Edit Metadata",
+ "kernelspec": {
+ "display_name": "Python 2",
+ "language": "python",
+ "name": "python2"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 2
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython2",
+ "version": "2.7.9"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/is/UB3/ExerciseSheet3final.ipynb b/is/UB3/ExerciseSheet3final.ipynb
index 50fdb3f..0f6c9c0 100644
--- a/is/UB3/ExerciseSheet3final.ipynb
+++ b/is/UB3/ExerciseSheet3final.ipynb
@@ -91,8 +91,7 @@
" \\Leftrightarrow & \\vec{y}&=& X\\vec{w}\\\\\n",
" \\Leftrightarrow & X^T\\vec{y} &=& X^TX\\vec{w}\\\\\n",
" \\Leftrightarrow & \\vec{w} &=& \\left(X^TX\\right)^{-1}X^T\\vec{y}\\hspace{1cm} q.e.d.\n",
- "\\end{align*}\\\\\n",
- "Warum lautet die Formel dann nicht einfach w=X^{-1}y"
+ "\\end{align*}\n"
]
},
{
@@ -109,7 +108,7 @@
},
{
"cell_type": "code",
- "execution_count": 24,
+ "execution_count": 51,
"metadata": {
"collapsed": false
},
@@ -125,7 +124,7 @@
},
{
"cell_type": "code",
- "execution_count": 25,
+ "execution_count": 52,
"metadata": {
"collapsed": false,
"scrolled": false
@@ -146,7 +145,7 @@
},
{
"cell_type": "code",
- "execution_count": 26,
+ "execution_count": 53,
"metadata": {
"collapsed": false
},
@@ -169,7 +168,7 @@
},
{
"cell_type": "code",
- "execution_count": 27,
+ "execution_count": 54,
"metadata": {
"collapsed": false,
"scrolled": false
@@ -178,10 +177,10 @@
{
"data": {
"text/plain": [
- ""
+ ""
]
},
- "execution_count": 27,
+ "execution_count": 54,
"metadata": {},
"output_type": "execute_result"
},
@@ -293,7 +292,7 @@
"oJt+CXUlyycAAAAASUVORK5CYII=\n"
],
"text/plain": [
- ""
+ ""
]
},
"metadata": {},
@@ -318,7 +317,7 @@
},
{
"cell_type": "code",
- "execution_count": 28,
+ "execution_count": 55,
"metadata": {
"collapsed": false
},
@@ -345,7 +344,7 @@
},
{
"cell_type": "code",
- "execution_count": 29,
+ "execution_count": 56,
"metadata": {
"collapsed": false
},
@@ -365,164 +364,177 @@
},
{
"cell_type": "code",
- "execution_count": 30,
+ "execution_count": 57,
"metadata": {
"collapsed": false,
"scrolled": true
},
"outputs": [
{
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "minimal MSE for n=7\n"
+ ]
+ },
+ {
"data": {
"image/png": [
"iVBORw0KGgoAAAANSUhEUgAAAXcAAAEKCAYAAADpfBXhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n",
- "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3XmYHGW5/vHvTVjSCCFgHAj7SABxREE5gCLHsKghKovK\n",
- "5sImwhFIOP6MJwIqAQWNCSiJqPyURUEQkM0gBFmSA6JEUOBwCCoJiYYtDQk7HQjJc/6oGqczzGSm\n",
- "p7unuqvvz3X1lemq6qpn5oJ7at566i1FBGZmli9rZF2AmZnVnsPdzCyHHO5mZjnkcDczyyGHu5lZ\n",
- "DjnczcxyyOFuZpZDDncbVJIWSnpN0lu7Lb9f0kpJW6bvN5d0jaRnJD0v6SFJR6brtk63fanb6+Be\n",
- "jnmIpD9IekXSrD7qO7XbPl+VtELSRun6YZIuS+t6Jv16/bLPD5H0bUlPSHpR0l8kbZCuW0fS99N1\n",
- "SyWdL2nNss9uLmmGpCWSnpI0XdKQHmr8Zvr9793/n7y1Goe7DbYAHgMO71wgaUegkK7rdCnwD2BL\n",
- "YCPg88DibvvaICLWL3td3csxlwDnAt/ts7iIs8v3CUwGZkXE0nSTScAIoB3YBtg4XdbpDGB3YPeI\n",
- "GAZ8DliWrvsa8F6gA9gu/frrZZ+dBjwLjAR2Aj4EnFBen6RtgE8DT/b1vVhrc7hbFi4Djih7fyTw\n",
- "C0Bly3YBLomIUkSsjIgHImLmQA4WEbdHxK+Bpyr5nCSltf28bHEHcH1EvBwRLwLXp8uQtCFwMvDF\n",
- "iFiUHntuRLyWfvbjwPSIeD4iniUJ82O67fvKiHg9IhYDMzv3XeaHwERgeSXfi7Ueh7tl4R5gmKR3\n",
- "pMMOh5IEfvdtfiTp0M6hmh6ol+W1sifwNuCasmW3AJ+SNDwN808BN6XrdgTeAA5Oh1X+JmmVM+9u\n",
- "Na8BbF42rHML8BlJBUmbAfsBN//rg8mw07KIuBmzPjjcLSuXkpy9fxiYCzzRbf3BwF3AN4DH0jH5\n",
- "Xbpt86yk58pe29e4xiOBqyPi1bJl56f/LiEZQlkO/DhdtjmwAbAtsDXJ8MkkSfum62cCJ0saIWkT\n",
- "YDzJUNS66fpJwLuAF4FFwL0RcQNA+gvgLJK/DMz65HC3LARJuH+WnodkSIcuTomId5GMaz9AMgRS\n",
- "7q0RsWHZ62+1KlDSuiTh/PNuq34J/A1YDxhGcv2g86+OUvrvmRHxWkQ8BPwKGJsuPwu4P/1efg9c\n",
- "B7wREYvTIaBbgKtJwn4EsJGkyelnJwGXRsQ/y8uswbdqOeVwt0ykIfUYydDDtX1suwQ4B9g0HQoZ\n",
- "8GEr2PYgYElE/He35WOAC9JrAa8AF9AV3v+zuuNGxLKIGBcRm0fEKGApcF+6zQjgfcAPI2J5egH3\n",
- "krJ97w2MT4d7ngK2AK6S9NUKvidrIQ53y9IXgL0jotR9haTJkjokrZkOSXwJeDQinivfrD8HkbSG\n",
- "pKHAWsAaaUviWn18rPMviu7+B/iipKGSCsBxwIMAETGfZCjpNElrS9qB5HrCjWkdm6YvSdqdpFPm\n",
- "9HS/z5Jc8P1S2k45PK3hwXT9PiQXV99D0knzZHrsH/XnZ2Ctx+FumYmIxyLiL+WLyr4ukAxbPAfM\n",
- "JzlT3b/bLp7v1pP+n70c6gjgVZIg3JNk+OSCzpXpZ/coe78ZMJqew/0okjbGJ4DHScbWjyxbfziw\n",
- "FcmY/I3A1yOis7d+G+Bu4GXgYmBiRNyW/iwC+CTwCZKgfxR4Dfhyun5pRBTT12JgBfBc+teD2Zuo\n",
- "2od1SLoI+BhQjIgd02WTgGOBZ9LNThloG5uZmVWuFmfuF5OMQ5YL4NyI2Dl9OdjNzAZR1eEeEXeR\n",
- "/Oncna/km5llpJ5j7uMkPSjpwvTikJmZDZJ6hfuPSebe2ImkA+CcOh3HzMx6sGbfm1QuIoqdX0v6\n",
- "GTCj+zaSqruSa2bWoiKiz2HvuoS7pJER0TlJ00HAQz1t158CG5WkSRExKes6Bsr1Z8v1Z6eZa4f+\n",
- "nxhXHe6SriCZmnSEpEUkN2WMlrQTSdfMAuD4ao9jZmb9V3W4R8ThPSy+qNr9mpnZwPkO1YGbnXUB\n",
- "VZqddQFVmp11AVWanXUBVZqddQFVmJ11AYOh6jtUB3xgKZp5zN3MLAv9zc66XFA1M7Paam/X2LY2\n",
- "xvd3ew/LmJk1uPZ2je3o4LzJk/lofz/jcDcza3BtbYyfMIFRlXzGwzJmZhmSWIPkqV4b9fbaZZeO\n",
- "neDhivbrcDezhiAxZMMNJ5w9cuTdxxYKy3jttXj1n//83J0vvjjhLpJpTDpfT0ewPNtq30xiTWA4\n",
- "qwnpXl7DgVdInszV0+uJ5ctfeYbkcZP95nA3s0xJDAEOWXfdqyfvvPOVb/vGNx4fmq7a6OyzF425\n",
- "5551N3zppRNWACPT19skXmDVwH+K5OlUqyyL4E1P+epHPWsDG1J5SK8PvEDvIT0fuLeH5c/39cuq\n",
- "vX3hI1Oncl4lQzNuhTSzfuvs2CgUGFoqsaxYZNqCBXHTQPaVhvphJI8bXLLzzpusc+65i3fpvt3E\n",
- "icycMyf26/a5EXSF/Uhg027vRwKbAMt48y+BJax+GGQoyTTmvYX0kl6WvxDByoH8LPoj/dmP+9Of\n",
- "GONWSDOrmc6OjfKzx6lT2aa9XVQS8OnwxWHAN4AicBJwx7Bhi2f1tH2hQKH8fQQrgMXp64HVHEck\n",
- "Z+AjgZHDh39tzJZbXveJddahsGyZli1adOjvnn/+jKt5c0i/FFHRw9QHRfozvmnQ5pYxs9bQU8fG\n",
- "hAmMmjiRcUCf4Z6G+mdIztSfJnno+azOIN1tN5b19LlSqfKhFYB0v0uBpe3t2qqjgwNW/cV0ph5+\n",
- "+MybFixInmObN26FNLN+KRQY2svyQk/LO0msKXEk8AhwDMlEgh+K4I7yM+RikWlTpzKv/LNTpjC/\n",
- "WGR6tbX39ouprY1x1e67UfnM3cz6pVSq7MxaYi3gc8BpwCLgixG9z+uyYEHc1N4uJk5kXKFAoVSi\n",
- "VCwyfaBj+uUG+oupmTnczaxf0jPrbcrPgHs6s05D/fMkob4QOCaCO/tzjM5x5dpVnaj0F1MeuFvG\n",
- "zPqts2OjpzPrNNSPIAn1x4AzIrgry3o79XQxeMoU5s+dy/ha/GUwmPqbnQ53M6tK2hd+JHAq8ChJ\n",
- "qN+dbVVvtrpfTM3E4W5mdZWG+lEkof43klD/Q6ZFtQBP+WtmdSGxDnA0cAowFzg8gj9mW5V153A3\n",
- "s36T2AS4E5gHHBLBnIxLsl54WMbM+kViXZJH1N0YwZkZl9OyPOZuZjWTTkt7NcnshUc24u35rcJj\n",
- "7mZWS98lmazrMw725uBwN7PVkjgOOAB4fwSvZV2P9Y/D3cx6JfER4EzggxEszboe6z+Hu5n1SOJd\n",
- "wGXAJyNWndDLGp9nhTSzN0lbHm8E/jOC32ddj1XO4W5mq0hbHmcAF0Zwedb12MC4FdLM/iVtefw1\n",
- "8BJwlDtjGo9bIc1sICaTPEf0cAd7c3O4mxkAEscD++OWx1xwuJsZEh8FJuGWx9xwuJu1OIkdgUuB\n",
- "gyKYn3U9VhvuljFrYRIjSVoeT27EB2zYwDnczVqUxFuA3wA/jeCKrOux2nIrpFkLkhhC0vL4AnC0\n",
- "O2Oah1shzWx1JgPDgUMd7PlU9bCMpIskLZb0UNmyjSTdKunvkn4naXi1xzGz2pD4EvBx4FMRvJ51\n",
- "PVYftRhzvxgY023Z14BbI2I74Pb0vZllTGIM8E3gY255zLeqwz0i7gKe67Z4f+Dn6dc/Bw6s9jhm\n",
- "Vh2Jd5O0PH7aLY/5V69umY0jYnH69WJg4zodx8z6IW15nAGMd8tja6j7BdWICEk9XrCRNKns7eyI\n",
- "mF3vesxaTdryOAP4/255bD6SRgOjK/5cLVohJW0NzIiIHdP3fwVGR8TTkkYCsyLiHd0+41ZIszpL\n",
- "Wx6vAZ7HLY+50N/srNewzG+AI9OvjwSur9NxzGz1vgdsABznYG8tVZ+5S7oC+BDJk9EXk1yJvwG4\n",
- "CtgSWAgcEhHPd/ucz9zN6kjiBGA8ySyP3ZserEn1Nzt9h6pZDknsB1xEMsujO2NyxHeomrUoifeQ\n",
- "tiA72FuXJw4zyxGJTelqefxD1vVYdhzuZjlR1vJ4QQS/yroey5bH3M1yIG15vBZYChzjzpj88pi7\n",
- "WQNqb9fYtjbGFwoMLZVYViwybcGCuKkGu54KrA8c7GA3cLibDZr2do3t6OC8CRMY1bls6lS2aW8X\n",
- "1QS8xInAfiQtj57l0QCPuZsNmrY2xpcHO8CECYxqa2PcQPcpMRb4OjDWvexWzmfuZoOkUGBoL8sL\n",
- "A9lfWcvj/hE8Vk1tlj8+czcbJKUSy3pZXqp0X2UtjydF8Mdqa7P8cbibDZJikWlTpzKvfNmUKcwv\n",
- "FpleyX4k1gNuBH4SwZW1rNHyw62QZoMo7ZYZVyhQKJUoFYtMr+RiatryeB3wLPAFd8a0Hs8tY5ZD\n",
- "Ej8A3g2McWdMa3Kfu1nOSJwEfBT4gIPd+uJwN2sCEh8DTgP2cMuj9YfD3azBSewEXIJbHq0C7pYx\n",
- "a2ASm5G0PJ7olkerhMPdrEGlLY8zgB9FcFXW9VhzcbeMWQNKWx6vB4rAsW55tE5ZPyDbzKpzLrAu\n",
- "8B8OdhsIX1A1azAS44APk7Q8Ls+6HmtODnezBpK2PJ5KEuzPZ12PNS+Hu1mDKGt5/EQECzIux5qc\n",
- "x9zNGoDE5iSdMSdEcE/W9Vjzc7ibZays5fH8CK7Ouh7LB7dCmmUobXm8AXga+KI7Y6wvboU0aw7f\n",
- "B4YCX3KwWy35gqpZRiTGA/vilkerA4e7WQYkPg6cglserU4c7maDTGJn4GLc8mh15DF3s0EksQnJ\n",
- "BVS3PFpdOdzNBonEOsC1wEVuebR6cyuk2SCQEHAhMBz4dAQrMy7JmpSfoWrWWMYDu5BcQHWwW905\n",
- "3M3qTGJfks6Y90fwctb1WGtwuJvVkcQo4JfAYe6MscFU13CXtBB4EVgBLI+IXet5PLNGIjGMpDPm\n",
- "zAhmZV2PtZa6XlCVtAB4X0Qs7WGdL6habkmsQfKYvKeB4z21gNVKI11QdYBbKzoT2JCkM8bBboOu\n",
- "3n3uAdwm6T5JX+y+8n3v2/Du9naNrXMNZoNK4hDg88CnIng963qsNdU73PeIiJ2B/YATJe1ZvvKc\n",
- "c57/QEcH5zngLS/SqQXOBw6MoJh1Pda66josExFPpf8+I+k6YFfgrs71l1wCI0Yw6tVXOU/SqxEx\n",
- "u571mNWTRBvJOPtJEdyfdT2WD5JGA6Mr/Vzdwl3SusCQiHhJ0luAjwBnlG9z1FHJvwsX8sTixQ52\n",
- "a14SawPXAJdGcGXW9Vh+pCe9szvfSzq9P5+r55n7xsB1kjqP88uI+F1PG5ZKlOpYh1ldpVMLTAeW\n",
- "At/MuBwzoI7hHhELgJ362u6MM9pXPv74+pfVqw6zQfAl4IMkd6B6agFrCJneoTpxIjPnzp045OWX\n",
- "j980yzrMBkpiNHA6yZwxL2Zcjtm/ZD4rpMSewAVAh/uBrZlItAN/BD4XwW1Z12OtoZkekP17YG3g\n",
- "37IuxKy/JNYjmVrgOw52a0SZh3t6tn4JcHTGpZj1Szq1wC+A+4BpGZdj1qPMh2WSr9kCeADYPMKd\n",
- "M9bYJCaRtPbuFcFrGZdjLaaZhmWIYBHwZ+DArGsxWx2JTwFfAD7pYLdG1hDhnroYOCrrIsx6I/Fu\n",
- "4CfAQRE8nXU9ZqvTEMMyyXsKwBPAe9IzebOGITECuBc4LYLLs67HWldTDcsApGPtVwFHZF2LWTmJ\n",
- "tYCrgasc7NYsGubMPVnGbsBlwHbuebdGIXE+sDWwfwQrMi7HWlzTnbmn/gQsJ7mV2yxzEscB+wCf\n",
- "cbBbM2mocE/P1n1h1RpCevf0t0nO2F/Iuh6zSjTUsEyynJHAXJKe91cGvzIzkNgKuAc4OoKZWddj\n",
- "1qlZh2WI4CngbuDTWddirUniLSQP3TjHwW7NquHCPXUxno7AMpDOzX4x8BBwTsblmA1Yo4b7DKBD\n",
- "4u1ZF2It51RgK+A4d2xZM2vIcE+fGH8FcGTWtVjrkNif5MEbB0WwLOt6zKrRcBdUu9azM3Ad8HY/\n",
- "3cbqTaKD5DmVH49gTsblmPWqaS+odkqfHv88sFfWtVi+SWxEMjf7VxzslhcNG+4p97xbXUmsCVwJ\n",
- "3BDBL7Kux6xWGnZYJtmGEcA8YCvfRGL1IPEDYAfgYxG8kXU9Zn1p+mEZgAieBe4ADsm6FssfiWOA\n",
- "scBhDnbLm4YO95R73q3mJD4ATAYOiOC5rOsxq7VmCPebgXaJd2RdiOVD+ljHXwNHRfBI1vWY1UPD\n",
- "h3v65/JluOfdaiB9KMx1wLQIfpt1PWb10tAXVLu2pQP4HbClp121gUqnFvhl+vazvgPVmlEuLqh2\n",
- "iuBhkkfwfSTrWqyp/RewPXCsg93yrinCPeULqzZgEh8DTgYOjODVrOsxq7emGJZJtmdDYAHJdARL\n",
- "61eZ5Y3EDsCdJMF+d9b1mFUjV8MyAGm72s3A4VnXYs0jPSm4Afiag91aSdOEe+oSPDRj/SQxhGR2\n",
- "0ZkRXJh1PWaDqdnC/TZgY4kdsy7EmsJkYE3g/2VdiNlga6pwT9sgf4EnE7M+SBwBHAgc6qkFrBU1\n",
- "zQXVrs+xLfB7kgdoL699ZdbsJHYFfguMTttozXIjdxdUO0XwKPAoyYRPZquQ2BS4lqSX3cFuLavp\n",
- "wj3lnnd7E4mhJFML/CSCG7KuxyxLdQt3SWMk/VXSo5Im1nj3VwGjJdpqvF9rUunUAhcA/wDOyrgc\n",
- "s8zVJdwlDQF+CIwB3gkcLmmHWu0/gpdIepc/W6t9WtP7MvBu4GhPLWCWtInVw67AvIhYCCDpV8AB\n",
- "UNPpVS8Gpkn8wP8zt472do1ta2N8ocDQUollxSLTFi6MFcBXgd0jeCXrGs0aQb3CfTNgUdn7x4Hd\n",
- "anyMO4H1gfcCf67xvq0BtbdrbEcH502YwKjOZd/73lrvWLz4ug1KpYP2j+AfWdZn1kjqNeZe9zPp\n",
- "CFbiO1ZbSlsb48uDHeC//mv5VtttN+GJCO7Kqi6zRlSvM/cngC3K3m9Bcva+CkmTyt7OjojZFR7n\n",
- "58B9El+J4LVKi7TmUigwtKflw4c/9uxg12I2WCSNBkZX+rl6hft9wLaStgaeBA6lhwm/ImJSNQeJ\n",
- "YKHEg8D+wNXV7MsaX6nEsl6Wlwa7FrPBkp70zu58L+n0/nyuLsMyEfEGcBJwCzAXuDIi6vWsSve8\n",
- "t4hikWlTpzKvfNmUKcwvFpmeVU1mjarpph94835Yl2QY6F0RPFF9ZdaoJNYYNuzcyzfd9Mb9R4y4\n",
- "939ff/3lJcUi0xcsiJuyrs1ssPQ3O5s+3JN98VNgXgSTa7E/azwSbyGZNG4T4KAIihmXZJaJ3M4t\n",
- "04uLgaPTuxQtZyQ2B+4CXgb2drCb9a1eF1QH2x8BAbu3t2vD7je5+M/25pXO8HgtMB34nm9YM+uf\n",
- "XIR7BCFxyfrr//ibHR2MKu+FnjqVbdrbhQO++UgcRhLqx3oiMLPK5GLMPdkfm22//T4LfvKTO9bq\n",
- "vm7iRGbOmRP71epYVl8SawCnkzyUZf8IHsy2IrPG0Wpj7kTwxHrrLX2pp3WFAoXBrscGJu1++hXw\n",
- "EWA3B7vZwOQm3AFWrHh2UU/LfZNLc5DYjGTOoNeAvSJ4OuOSzJpWrsJ9yZJXJp15ZvvK8mW+yaU5\n",
- "SOwCzAGuAY6I6PluVDPrn9yMuXcaNuz8G7fe+ofbbbTRX58slSj5JpfGJ3EIcD5wXATXZV2PWSNr\n",
- "qZuYVt0vu5A8qWlUOnOkNaj0voRvAscAB0Zwf8YlmTW8lrugWubPwCvAnlkXYr2TKABXAPuRXDh1\n",
- "sJvVUO7CPb3J5WLgeCkfffx5I7Ep8N/ASnzh1KwuchfuqUuB7YBnJK6TOFFiO09PkD2J95JcOL0B\n",
- "+GyEO5nM6iF3Y+6rHoONgX2AD6evlcCtwG3A7Z6jZHBJfBr4MfAfEVyTdT1mzahlL6j2fjwEbA/s\n",
- "SxL0HwIW0hX2d0Xw6mDV00rSn/1pwHEkF07/knFJZk3L4d7n8VkT2JUk7PcFdgbupSvs/xLBiqzq\n",
- "y4v0wumFwCjggAieyrgks6bmcK+QxPrAv5Oc1e8LjARmkYZ9BPMzLK8pSYwErgcWAEd7fN2seg73\n",
- "KqUdHZ3j9fsCy0jO6G8F7ohgSYblNTyJnUkumv4M+Jan6jWrDYd7DaVjxu+ka7x+T+BRusL+bt8u\n",
- "n0iHu74AfBs4IcIPLjerJYd7HUmsDexGV9jvSPLAkM6wf7DV7o5Np+k9GPgWyTNtvxzBA9lWZZY/\n",
- "DvdBJLEBMJqusH8rcDtJ2N8WwcLMiquz9K+a/YCzgDeAU0m+Zw/DmNWBwz1DElvQ1YWzL/AiXWf1\n",
- "syJ4LsPyakZiT+Bskl9mXweuc6ib1ZfDvUGkwxXvouvC7B7AI3SF/R8jeC27CiuXXiw9G3gHMAm4\n",
- "zG2jZoPD4d6gJNYB3k9X2O8A3E1Xf/1DjXr2K7E9yZj6niTDMD9ttl9MZs3O4d4kJDYE9qIr7IeR\n",
- "jtUDt0bweIblASCxJcnUvAcA5wLTIngl26rMWpPDvUlJbE3Xhdl9gGfpOqufHcELg1hLG3AKcARw\n",
- "ATAlL9cLzJqVwz0H0vH6negK+92Bh+gK+3siWF6H424AfAU4EbgcOMvT8po1Bod7DqXztOxBV9iP\n",
- "Au6iK+znVjNen+7/JOCrwE3AGREsqLZuM6sdh3sLkBgB7E1X2K9DVxfO7RE82c/9rEVyV+k3gHuA\n",
- "b0Qwty5Fm1lVHO4tJr2Z6O10XZjdG3iSrrC/M4KXun1mCHAYcCYwHzgtgnurqaO9XWPb2hhfKDC0\n",
- "VGJZscg0P6DcrHYc7i0uDe730hX2/wbcT1fYv42knfFl4NQIZlV7zPZ2je3o4LwJExjVuWzqVOY9\n",
- "/DAnO+DNasPhbquQeAvwQbqeSrWC5AakGbXqq99tN82cPJmPdl8+cSIz58yJ/WpxDLNW19/s9AOk\n",
- "W0Tal35L+qqLQoGhvSwv1OuYZtazvD4g2zJQKvU87XGp5Id0mA02h7vVTLHItKlTmVe+bMoU5heL\n",
- "TM+qJrNW5TF3q6m0W2ZcoUChVKJULDLdF1PNaifTC6qSJgHHAs+ki06JiJkDKdDMzLpkfUE1gHMj\n",
- "4tw67d/MzFajnmPuPis3M8tIPcN9nKQHJV0oaXgdj2NmZt0MeMxd0q3AJj2sOo1kfpLO8fZvASMj\n",
- "4gvdPh/AGWWLZkfE7AEVY2aWU5JGkzyjudPpDXGHqqStgRkRsWO35b6gamZWof5mZ12GZSSNLHt7\n",
- "EMkc5GZmNkjq1S0zWdJOJF0zC4Dj63QcMzPrgW9iMjNrIpkOy5iZWbYc7mZmOeRwNzPLIYe7mVkO\n",
- "OdzNzHLI4W5mlkMOdzOzHHK4m5nlkB+Q3WLSJyWNLxQYWiqxrFhkmp+UZJY/DvcW0t6usR0dnDdh\n",
- "AqM6l02dyjbt7cIBb5YvHpZpIW1tjC8PdoAJExjV1sa4rGoys/pwuLeQQoGhvSwvDHYtZlZfDvcW\n",
- "UiqxrJflpcGuxczqy+HeQopFpk2dyrzyZVOmML9YZHpWNZlZfXjK3xaTdsuMKxQolEqUikWm+2Kq\n",
- "WfPob3Y63M3Mmojnczcza2EOdzOzHHK4m5nlkMPdzCyHHO5mZjnkcDczyyGHu5lZDjnczcxyyOFu\n",
- "ZpZDDnczsxxyuJuZ5ZDD3cwshxzuZmY55HA3M8shh7uZWQ453M3McsjhbmaWQw53M7MccribmeXQ\n",
- "gMNd0sGSHpa0QtJ7u607RdKjkv4q6SPVl2lmZpWo5sz9IeAg4M7yhZLeCRwKvBMYA/xIUu7+QpA0\n",
- "OusaquH6s+X6s9PMtVdiwKEbEX+NiL/3sOoA4IqIWB4RC4F5wK4DPU4DG511AVUanXUBVRqddQFV\n",
- "Gp11AVUanXUBVRiddQGDoR5n1JsCj5e9fxzYrA7HMTOzXqy5upWSbgU26WHVqRExo4LjREVVmZlZ\n",
- "VRRRXe5KmgV8JSL+kr7/GkBEfDd9PxM4PSLmdPucA9/MbAAiQn1ts9oz9wqUH+g3wOWSziUZjtkW\n",
- "+NNAijMzs4GpphXyIEmLgN2B30q6GSAi5gJXAXOBm4EToto/D8zMrCJVD8uYmVnjybT/XNK3JD0o\n",
- "6QFJt0vaIst6KiVpiqRH0u/hWkkbZF1TJVZ3I1qjkjQmvTnuUUkTs66nUpIukrRY0kNZ11IpSVtI\n",
- "mpX+N/O/ksZnXVMlJA2VNCfNm7mSvpN1TQMhaYik+yWttqkl65uLvhcR74mInYDrgdMzrqdSvwM6\n",
- "IuI9wN+BUzKup1I93ojWqCQNAX5IcnPcO4HDJe2QbVUVu5ik/ma0HPhyRHSQDMee2Ew//4hYBuyV\n",
- "5s27gb0kfTDjsgbiZJJh79UOu2Qa7hHxUtnb9YBns6plICLi1ohYmb6dA2yeZT2VWs2NaI1qV2Be\n",
- "RCyMiOXAr0hummsaEXEX8FzWdQxERDwdEQ+kX78MPEJyX0vTiIhX0y/XBoYASzMsp2KSNgfGAj9j\n",
- "1UaWN8n6zB1JZ0n6J3Ak8N2s66nCMcBNWReRc5sBi8re+wa5jEjaGtiZ5KSmaUhaQ9IDwGJgVtoA\n",
- "0ky+D3wVWNnXhnUPd0m3Snqoh9cnACLitIjYEriEpPCG0lf96TanAa9HxOUZltqj/tTfRHz1vwFI\n",
- "Wg/4NXByegbfNCJiZTossznw7800z4ykjwPFiLifPs7aoXZ97r2KiA/3c9PLacAz377ql3QUyZ9J\n",
- "+wxKQRWq4OffDJ4Ayi+6b8GqU11YnUlaC7gGuCwirs+6noGKiBck/RbYBZidcTn99QFgf0ljgaHA\n",
- "MEm/iIgjeto4626ZbcveHgDcn1UtAyFpDMmfSAekF2uaWTPcVHYfsK2krSWtTTL76G8yrqllSBJw\n",
- "ITA3In6QdT2VkjRC0vD06wLwYZoocyLi1IjYIiLagcOAO3oLdsh+zP076RDBAyQztX0l43oqNZ3k\n",
- "QvCtaWvSj7IuqBK93YjWqCLiDeAk4BaSboErI+KRbKuqjKQrgD8A20laJOnorGuqwB7A50i6TO5P\n",
- "X83U+TMSuCPNmznAjIi4PeOaqrHaYUrfxGRmlkNZn7mbmVkdONzNzHLI4W5mlkMOdzOzHHK4m5nl\n",
- "kMPdzCx2UQjRAAAAEklEQVSHHO5mZjnkcDczy6H/Az1pcRz7mHjbAAAAAElFTkSuQmCC\n"
+ "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3XmYHFW9xvHvG7Y0yCLEQSRIRoIGAoKoILINIIsxsiiL\n",
+ "yBJwuSqScNVBBK6XcAUVMnJNgigiqwKyI8i+RVAE5LKILEIgkUVIs68dZPndP6rGdIYZMr1Wd/X7\n",
+ "eZ55mK6qrvpNHp63T59z6pQiAjMzy5cRWRdgZmb153A3M8shh7uZWQ453M3McsjhbmaWQw53M7Mc\n",
+ "cribmeWQw92aStJcSa9JWmnA9jskvSXp/enr0ZLOl/SUpOcl3S1pUrpvTHrsSwN+dh3imrtJuknS\n",
+ "K5KuX0R9hw4456uS3pS0Yrq/T9IDkl6UdJ+kvQe8fzFJR0p6PD3mdknLp/u+IOl+SS9IelrSBZLe\n",
+ "V/be0ZIukfSMpCckzZS0WNn+nSTdk573Hkk7Vvavb53E4W7NFsDDwB79GyStCxTSff1+DfwDeD+w\n",
+ "IrA3MG/AuZaPiGXLfs4d4prPAMcCP15kcRE/LD8ncDRwfUQ8mx7yMjAxIpYDJgHTJW1cdoojgE8A\n",
+ "n0iP2QuYn+77E7B5RCwPrA68mtbVbwbwNLAKsD6wBbA/gKQu4Azg2+l5DwLOlDRqUX+TdSaHu2Xh\n",
+ "N8A+Za8nAacDKtv2MeDUiChFxFsRcWdEXFHNxSLi2og4D3iikvdJUlrbaWXnmhoRD6S/3wrcCGyc\n",
+ "Hv9u4EDgqxHxaHrMvRHxWvr7oxFR7D898OaAmsYDZ0fEvyJiHnBFug1gLPByRFyZnusy4BVgjUr+\n",
+ "JuscDnfLws3AcpLGpd0Ou5ME/sBjjpe0e39XzSA0xPZ62Qx4D3D+oBeXCsDHgb+lm9YF3gB2TbtV\n",
+ "/i5p/wHv2VTS88CLJN9KDi7bfSXwRUkFSasCnwYuT/f9FXhD0sS062cnkm8Ef63HH2r543C3rPya\n",
+ "pPW+DXAv8PiA/buStIq/Dzyc9sl/bMAxT0t6ruznQ3WucRJwbkS8OsT+XwB3RsRV6evRwPLAmsAY\n",
+ "YBdgqqRP9b8hIv4YESukx74OTCs731RgHZLgfxT4S0T8Ln3fy8DXgLNJQv0M4GsRUar9z7Q8crhb\n",
+ "FoIk3Pdk8C4ZIuL5iDgkItYBVgbuBC4acJ6VIuLdZT9/r1eBkpYmCefThtg/DVgb2K1sc3/Q/k9E\n",
+ "vBYRdwO/BSYMfH9E/JPkg2uf9HwiabmfCywNjAJWlHR0un8D4JfAZhGxBEl//EmS1qvxT7Wccrhb\n",
+ "JiLiEZKB1U8DFyzi2GeAnwDvS/u1q75sBcfuDDwTEX8YuEPSEcB2wLZpi7rfUF0kQ113CZJBVUjC\n",
+ "/KPAcRHxejqAeyoLPhi2Bm6OiNsBIuI24BbgU5gNwuFuWfoysNVgXQuSjpY0XtLikpYFvgE8GBHP\n",
+ "lR82nItIGiFpJEmYjpC0lKQlFvG2/m8UA891CMlMn20G1EJEPETSlXSYpCUlrUUynvD79L17Slot\n",
+ "/X114CgW9Oc/TTK4+o20T32FtIa70v13AZv1t9QlfYRkTKB/v9lCHO6WmYh4uL8l2r+p7PcCcCHw\n",
+ "HPAQsBqww4BTPD9gTvp/DnGpfUhayMeTBGIJOKF/Z/reTcperwr0MEi4kwTyasDssut+r2z/HiTT\n",
+ "HJ8hCfX/ioj+ufVrATdJehmYBfwZ+G76bxHA54DPkgT9g8BrwLfS/VcBxwAXSHoJOA84KiKuGeJv\n",
+ "tg6nWh/WIelk4DNAMSLWTbdNBb4CPJUedki109jMzKxy9Wi5nwJsP2BbAMdGxEfSHwe7mVkT1Rzu\n",
+ "EXEjyVfngRo9B9nMzIbQyD73yZLuknRSOjhkZmZN0qhw/znQTbI+xhMk09jMzKxJFm/EScvWz0DS\n",
+ "r4BLBh4jqbaRXDOzDhURi+z2bki4S1olIvoXRNoZuHuw44ZTYKuSNDUipmZdR7Vcf7Zcf3bauXYY\n",
+ "fsO45nCXdBbJrdCjJD0KHA70SFqfZNbMHJI1MczMrElqDveI2GOQzSfXel4zM6ue71Ct3qysC6jR\n",
+ "rKwLqNGsrAuo0aysC6jRrKwLqIaEYJO7JZbMupZGq/kO1aovLEU797mbWXuQWALYHNiRZAmLZYF3\n",
+ "kdxBP5fkiV8D//tIBC25nPJws7MhA6pmZlmSWI5kxdEd0v/OBn4HTATuARYD3key7v7q6X83JFnC\n",
+ "eXVgNYnnGTz45wL/iKB8RdCG6+7WhK4upgz3eLfczSwXJEaThPmOJI8+/CNJoF8SwT8rPNcI4L0s\n",
+ "CP/VWfiDYHWSBejmMsQHQATP1/L3lOvu1oTx45ne28vYLbfMcCqkmVmjJf3nfJgFgd4NXAacCOwS\n",
+ "wUvVnjuCt4B/pj83DXHt97Bw2K9Jsr7+GGB1iWBB2A/2AfB0xPCeMdDVxZTeXsZW8jc43M2sbaT9\n",
+ "55uxoP88SFrnBwF/jOD1ZtSRhnIx/fnLIHUKWIG3t/Y3LXu9lDRo6Pf/Pi/9kKFQYGSlNTrczaxl\n",
+ "9PcrFwqMLJWYXywyY+7cuJFk5dkdSfrPHyYJ9B2Avw239dtMaU3PpT93DHZMOi4wsMvno2W/Ly/x\n",
+ "CPCPddZZb41Kn8vicDezllDer9y/7cgj37fZvHkXq1Ta4QaSQD844m0PU29LEbxIcvf+oHfwSywN\n",
+ "vB8Y89hjO3zmhz98bM9DD31m2I+Z9ICqmQ3bYC3rOXPisnqce6ONdMXRR7PdwO3f/e4S19x667+2\n",
+ "qcc12ln6bz/51lvZ3gOqZlY3g7Ws+/pYo7tb1CPgR4wYPQYee9v2pZd+fVHPux2WRn4wNUNa62VN\n",
+ "W1vGzDrDYDM2ensZe/DBTCaZpVIViWWAn40b173qYOFeKtV+M1GjP5hakZcfMLNhGWrGRqFAodpz\n",
+ "SqwN3ArolVcemNTXx+zy/dOm8VCxyMxqz99vqA+mri4m13ruVuWWu5kNS6nE/CG2V9WyltgbOBY4\n",
+ "GDjlkUeejO5uzT/4YCYXChRKJUrFIjPr0bJuxAdTq3O4m9mwFIvM6OtjjfIWcDUta4kCMJNkzvdW\n",
+ "EQtmi/T3K9er5n71/mBqB54tY2bD1j9jo9qWtcSHgHNJpv99vZa7SCsxWJ/7tGk8dO+9TGm3Pvfh\n",
+ "ZqfD3cyaQuKLwHTgMODEZt98VOsHU6twuJtZS0i7YX4KbAnsGlHhrZa2kOFmp2fLmFnDSKwJ/BlY\n",
+ "HviYg715HO5m1hASuwF/Ak4A9khvt7cm8WwZM6sriZHAT4DtgO0juD3jkjqSW+5mVjcSa5C01lcG\n",
+ "Pupgz47D3czqQuLzJP3rp5AMnL6QcUkdzd0yZlYTiaWAY4DPAhMiuC3jkgyHu5nVQKIbOJtkxa8N\n",
+ "6vncUKuNu2XMrCoSOwG3AGcCn3ewtxa33M2sIhJLAj8GPgd8NoJbMi7JBuFwN7Nhk1gRuAR4hqQb\n",
+ "5tmMS7IhuFvGzIZFYhRwLXAzsKODvbU53M1skSS6gOuBy4HeZi/6ZZVzuJvZO5JYBZgFnA8c5mBv\n",
+ "D+5zN7MhSYwGrgNOi+CorOux4XPL3cwGJbE68AeStdcd7G3GLXczexuJD5AMnv40gulZ12OVc8vd\n",
+ "zBaSrsE+C5jmYG9fbrmb2b9JjAOuAaZG8Kus67HqOdzNDACJdYCrgEMiOC3reqw2NXfLSDpZ0jxJ\n",
+ "d5dtW1HS1ZIekHSVpBVqvY6ZNY7EesDVJHPYHew5UI8+91OA7Qds+x5wdUR8kGRQ5nt1uI6ZNYDE\n",
+ "R4ErgSkRnJl1PVYfNYd7RNwIPDdg8w7w70//04Cdar2OmdWfxEbAZcDXIzg363qsfhrV575yRMxL\n",
+ "f59H8sgtM2shEpsAFwL7RXBp1vVYfTV8QDUiQtKgtytLmlr2clZEzGp0PWYGEpsD5wF7R3Bl1vXY\n",
+ "0CT1AD0Vvy+i9mUiJI0BLomIddPX9wM9EfGkpFWA6yNi3ID3RESo5oubWUUktgbOAr4QwXVZ12OV\n",
+ "GW52NuompouBSenvk4CLGnQdM6uAxHYkwb6Lgz3fam65SzoL2AIYRdK//t/A74BzgPcDc4HdIuL5\n",
+ "Ae9zy92siSQmAicDO0VwU9b1WHWGm5116ZaphsPdrHkkdgZ+QfJYvFuzrseql3W3jJm1CIndgJ8D\n",
+ "n3awdw6Hu1mOSewJTAe2i+D2rOux5nG4m+WUxCTgGOBTEdyVdT3WXF44zCyHJL5KMrlhqwj+nnU9\n",
+ "1nwOd7Mm6u7WhK4uphQKjCyVmF8sMmPOnLisnteQ2B84GNgygtn1PLe1D4e7WZN0d2vC+PFM7+1l\n",
+ "bP+2vj7W6O4W9Qp4if8EDgR6IphTj3Nae3Kfu1mTdHUxpTzYAXp7GdvVxeR6nF/iIOAAYAsHu7nl\n",
+ "btYkhQIjh9heqPXcEocB+5AE++O1ns/an8PdrElKJeYPsb1U7TklBEwFdiXpinmi2nNZvrhbxqxJ\n",
+ "ikVm9PUtPMA5bRoPFYvMrOZ8abAfBeyMg90G8PIDZk2UzpaZXChQKJUoFYvMrGYwNQ32acDWwDYR\n",
+ "PF33Yq0leW0Zs5xKg306sDHJnafPZlySNdFws9N97mZtRGIEcDywHsmdpy9kXJK1KIe7WZuQWAw4\n",
+ "EViTpMX+YsYlWQtzuJu1AYnFgVOAVUlWd3w545KsxTnczVqcxBLA6cBKwMQIXs24JGsDDnezFiax\n",
+ "JHAmUAB2iBh8rrzZQA53sxYlsRTJ4yoBPhfBa1nWY+3FNzGZtSCJkcCFwOvArg52q5TD3azFSCwN\n",
+ "XAy8AHwhgn9lXJK1IYe7WQuReBdwKfAksHcEb2RckrUph7tZi5BYFrgceBjYz8FutXC4m7UAieWB\n",
+ "q4B7gK9G8GbGJVmbc7ibZUzi3cA1wF+Ab0TwVsYlWQ443M0yJDEKuA64ATgwgmxW8rPccbibZUSi\n",
+ "C7geuALodbBbPTnczTIgsQowCzgfONTBbvXmO1TNmkxiNElXzGkRHJV1PZZPDnezJpJYkWTw9FcR\n",
+ "HJN1PZZffhKTWZOki4BdBdwWQW/W9Vh78mP2zFpI+mi8U4HlgF08j92q5cfsmbWW/wLWBnoc7NYM\n",
+ "DnezBpP4IvBl4BMRvJJ1PdYZHO5mDSSxKfBTYKsInsy6Huscnudu1iASY4HzSFZ3/FvW9VhnaWjL\n",
+ "XdJc4EXgTeD1iNiwkdczaxXplMdLgcMjuDLreqzzNLpbJoCeiHi2wdcxaxnp4/EuBC6O4ISs67HO\n",
+ "1IxuGU93tI6RTnk8EXgGODjjcqyDNTrcA7hG0m2Svjpw50Yb6Yrubk1ocA1mzfR9YBywl5futSw1\n",
+ "Otw3iYiPAJ8Gvilps/KdRx/NduPHM90Bb3kgsSfwJWCHCF7Nuh7rbA3tc4+IJ9L/PiXpQmBD4Mb+\n",
+ "/aeeCqNGMfbVV5ku6dWImNXIeswaRWIz4H/xlEerM0k9QE+l72tYuEtaGlgsIl6StAywLXBE+TH7\n",
+ "7pv8d+5cHp83z8Fu7UliTeBckq4YT3m0ukobvbP6X0s6fDjva2TLfWXgQkn91zkjIq4a7MBSiVID\n",
+ "6zBrGImVSKY8/ncEg/7/bZaFhoV7RMwB1l/UcdOm8VCxyMxG1WHWKOmUxwuAiyL4Zdb1mJXLdFXI\n",
+ "tdfe+Nknntj0pGefPea7mRRhVqV0yuPpwNLArp4ZY83SFkv+QkwEjgQ28GPGrJ1IHA58hmSVR8+M\n",
+ "saYZbrhnvbbM5cBSwFYZ12E2bBJ7AfvhKY/WwjIN9/Sr7E/AT6Wx9pBOeTwWmOgpj9bKMn8Sk8RI\n",
+ "YA6wjaeRWStLpzzeSLLK49VZ12OdqV26ZYhgPjAT+E7WtZgNJZ3yeBnwfQe7tYPMW+7J76wIzAbW\n",
+ "ieCfmRRkNoR0yuPVwJ8jvBiYZastZsuUFygxA3glgkMyKchsEOmUx18DI4HdPOXRstaO4f4B4Fag\n",
+ "O4KXMinKbACJqSQL323pmTHWCtqmz71fBA8D15GsqmeWuXTK4yQ85dHaUMu03JNtbAScDYyN4I1M\n",
+ "CjMDJDYnef7plhHck3U9Zv3aruUOEMEtwCPA57OuxTqXxAeBc4A9HezWrloq3FN9wEHpQJZZU0mM\n",
+ "Ilnl0VMera21Yrj/HlgW2CLrQqyzlD3Y+vwITsy6HrNatFSf+4J9/AfJINbEJpdlHSr9pvgbYElg\n",
+ "d095tFbVdlMhF97HSGAuySPL7m1qYdaR0imP25MMoPrhMday2nJAtV+6JMHPgG9nXYvln8Q+JFMe\n",
+ "d3SwW160ZMs92c8o4EFgLa++Z40isQXJ8097/C3R2kFbt9wBIngaOBM4IOtaLJ8kPkQy5fGLDnbL\n",
+ "m5ZtuSfHMBb4MzAmgleaU5l1gvSb4c3AjyP4Vdb1mA1X27fcASKYDdxA8tQbs7pIB+wvAs5zsFte\n",
+ "tXTLPTmOjYEzgDUjeLPxlVmeecqjtbtctNwBIvgz8ASwc9a1WC5MBdYA9nGwW561fLinvCSB1Syd\n",
+ "8rg3yQ1ynvJoudYu4X4x8G5g06wLsfYk0UPSSJgYQTHjcswari3CPe1rPxbozboWaz/plMezgT08\n",
+ "5dE6RcsPqC44nqWBOcDmEfy9cZVZnpRNefxRBCdlXY9ZrXIzoNovfRLOz/GSBDZMZVMez3WwW6dp\n",
+ "m5Z78h66gL8DH3K/qb2TdPD9DGBx4AueGWN5kbuWO0Aa6GcD38y6Fmt5RwDdwCQHu3Witmq5J+/j\n",
+ "Q8CNJEsS+KHF9jYSk4DDgU/4G57lTS5b7gDpYOpNJEu0mi0knfJ4DPAZB7t1srZruSfvZVPgFGCc\n",
+ "lySwfhLjgD+QTHm8Lut6zBohty331J+AZ4Adsi7EWoPEe0iev3uIg92sTcM9ggCm4ZuajIWmPJ4T\n",
+ "wclZ12PWCtqyWyZ5P4sBDwB7R3BT/SqzdiIxgmTK4wiS7hjPjLFcy7xbRtL2ku6X9KCkg+t9fi9J\n",
+ "YKkjgDHAvg52swUa0nKXtBjJzUafAh4H/gLsERH3lR1TU8s9OQfLAHOBT0bwYC3nsvYjsS/wfWBj\n",
+ "z4yxTjHc7Fy8QdffEJgdEXPTYn4L7Ajc905vqlQEr0j8AvgWsH89z22tqbtbE7q6mLL44iu9d9y4\n",
+ "D6/13HNLTHnyySsd7GYDNCrcVwUeLXv9GLBRg651HHC/xOERPNWga1gL6O7WhPHjmd7by9hkstT1\n",
+ "9PXR292tR+fMicuyrs+slTSqz71po7QRzAPOA77RrGtaNrq6mJIE+wK9vYzt6mJyVjWZtapGtdwf\n",
+ "B1Yre70aSet9IZKmlr2cFRGzqrzescAsiWl+wk5+LbXUUsvCa2/bXihQyKAcs6aQ1AP0VPq+RoX7\n",
+ "bcCaksYA/wR2B/YYeFBETK3HxSK4T+JWkkeo/bIe57TWIrHCWmt9fB3449v2lUr+QLf8Shu9s/pf\n",
+ "Szp8OO9rSLdMRLwBHABcCdwLnF0+U6ZBpgHfSec9W46kD2q55LHHdp/V18fs8n3TpvFQscjMjEoz\n",
+ "a1ltexPT28+HgFuAIyO4uF7ntWxJLAn8DngK2HfMGG3f1cXkQoFCqUSpWGSmB1Otkww3O3MT7sk5\n",
+ "2Q04IILN63ley0Z6F/JZwBLArhG8kXFJZpnL/A7VjFwArCY1bNqlNUn6TewEYCWSZQUc7GYVyFXL\n",
+ "HWCFFf7nF6NHX7zTqFH/d3+pxPxikRn+2t5e0mCfBmwKbBPBSxmXZNYysr5DNRPd3ZqwySba5qCD\n",
+ "YmVgZYC+Ptbo7hYO+LZyKLAdsIWD3aw6ueqW6epiykEHxQfKt/kml/YicQCwH7BtBM9mXY9Zu8pV\n",
+ "y71QYORg20eOHLFMs2uxyknsBRwMbB7BE1nXY9bOctVyL5WYP9j2efN6NpI4SlrorllrIRI7An3A\n",
+ "dhHMyboes3aXq3AvFpkx2E0uzz8/YjLwLuBOifMktkgH7awFSGwFnAhMjODerOsxy4PczZZJl4Qd\n",
+ "9CYXiWVJlig4AHiDZEXJMyJ4pd512PCk01YvIZnH/oes6zFrdR15E9Pwr42ArYDJJNPtTgOOj+Ch\n",
+ "LOrpVBLrANcAX47g0qzrMWsHnXoT07BEEBFcG8FOwMdIWvE3S/xeYnuvT9N4EmsAVwDfcrCb1V9H\n",
+ "ttwHI1EgWblyMrAM8DPg1AheyLSwHJJYFbgRODqCE7Kux6yduFumSmmXzSdJ+uW3A34LHOeBvvqQ\n",
+ "WAm4ATg9gqOzrses3bhbpkppl82fItgDWAcoAtdKXCuxk5SvewOaSWI5kq6Yix3sZo3llvswpMvO\n",
+ "fp6ky2ZV4HjgpAiezrSwNpJ2e11O8pD0/SOa9yhGszxxy72OIvhXBGdF8Engc8A44EGJkyU2yLi8\n",
+ "liexBHAOyVO5DnCwmzWew71CEfxfBPsBawIPABdK/Elij7SFb2XSmUenAgImRfBmthWZdQZ3y9Qo\n",
+ "7YP/LMkA7Fokz3A9wWuj/Htw+mfA2sCn/fBys9q5W6ZJIngjggsj2BrYBugC7pE4S+KTHb7MwZHA\n",
+ "hsAODnaz5nLLvQEkVgAmkbTmXwJmAr/tpICT+C6wL8kKjx54NqsTz3NvAWl/87Yks2w+DpwM/DyC\n",
+ "f2RaWANJLAUcQvLhtmkEj2dcklmuuFumBUTwVgRXRPAZkhujlgRul7hQYuu8ddlIbA7cAWwAbOZg\n",
+ "N8uOW+5NJrEMsBdJl81iJCtTnh7By5kWVoP0rtNjSL6lTAEu8nRHs8Zwy71FRfBKup7Kh4H9SVan\n",
+ "/IfEdIkPZltdZSQksQ9wD8nYwtrp4LKD3Sxjbrm3gPQJUV8HvkLSrTETuDyCtzIt7B2kH0Q/B1YA\n",
+ "vhbBbRmXZNYRPKDahiRGAruRDMCuSDJH/JQInsu0sDLpgOn3SGr8AfCzCN7ItiqzzuFumTYUwfwI\n",
+ "TieZG/5FkoHJhyVOkFg32+pAoge4C1gPWD+C6Q52s9bklnuLk1gZ+A+SbpsHSQZgL2pmqEqMInl4\n",
+ "9VbA5Ah+16xrm9nC3HLPiQjmRfADYAzJapRTgDkSh0l0NfLa6YDpfiQDps+QDJg62M3agFvubUhi\n",
+ "feCbwC4kD5eeGcFf6nyNccAvSJ5K9bUIbh/O+9IHlE8pFBhZKjG/WGRG/wPKzax2HlDtABIrAl8i\n",
+ "CfoiySybcyN4rYZzjgQOBb4BHEFyR+2wVnLs7taE8eOZ3tvL2P5tfX3MvuceDnTAm9WHu2U6QATP\n",
+ "RtAHjCVZpGsfkjnzP5AYXen5JLYG/kqyiuP6ERxXyRK9XV1MKQ92gN5exnZ1MbnSWsysNg73HIjg\n",
+ "zQguiWBboIdk7vlfJc6R2HxRyxxIdEn8GjgJ+HYEu1SzdEChwMghthcqPZeZ1cbhnjMR3B/BZJIB\n",
+ "2BtI1pe/U+KrEkuXHysxQuIrwN3Ak8D4CH5f7bVLJeYPsb1jVsM0axUO95yK4MUIjiN5gEgvMBF4\n",
+ "RKJP4gMSawN/ILkrdtsIDorglVquWSwyo6+P2eXbpk3joWKRmbWc18wq5wHVDiLRTTJQul+66XCS\n",
+ "p0bV7dF36WyZyYUChVKJUrHITA+mmtVPprNlJE0laRE+lW46JCKuqKZAq7+0e2aJCF7IuhYzq8xw\n",
+ "s3PxBl0/gGMj4tgGnd9qEMGrWddgZo3VyD53t8rNzDLSyHCfLOkuSSdJWqGB1zEzswGq7nOXdDXw\n",
+ "3kF2HQbczIL+9h8Aq0TElwe8P0jugOw3KyJmVVWMmVlOSeohuX+l3+EtsfyApDHAJRGx7oDtHlA1\n",
+ "M6tQpssPSFql7OXOJDfJmJlZkzRqtszRktYnmTUzB/hag65jZmaD8E1MZmZtxKtCmpl1MIe7mVkO\n",
+ "OdzNzHLI4W5mlkMOdzOzHHK4m5nlkMPdzCyHHO5mZjnUqDtUrUWlT0qaUigwslRifrHIDD8pySx/\n",
+ "HO4dpLtbE8aPZ3pvL2P7t/X1sUZ3t3DAm+WLu2U6SFcXU8qDHaC3l7FdXUzOqiYzawyHewcpFBg5\n",
+ "xPZCs2sxs8ZyuHeQUon5Q2wvNbsWM2ssh3sHKRaZ0dfH7PJt06bxULHIzKxqMrPG8JK/HSadLTO5\n",
+ "UKBQKlEqFpnpwVSz9jHc7HS4m5m1Ea/nbmbWwRzuZmY55HA3M8shh7uZWQ453M3McsjhbmaWQw53\n",
+ "M7MccribmeWQw93MLIcc7mZmOeRwNzPLIYe7mVkOOdzNzHLI4W5mlkMOdzOzHHK4m5nlkMPdzCyH\n",
+ "HO5mZjnkcDczy6Gqw13SrpLukfSmpA0G7DtE0oOS7pe0be1lmplZJWppud8N7AzcUL5R0trA7sDa\n",
+ "wPbA8ZJy9w1BUk/WNdTC9WfL9WennWuvRNWhGxH3R8QDg+zaETgrIl6PiLnAbGDDaq/TwnqyLqBG\n",
+ "PVkXUKOerAuoUU/WBdSoJ+sCatCTdQHN0IgW9fuAx8pePwas2oDrmJnZEBZ/p52SrgbeO8iuQyPi\n",
+ "kgquExVVZWZmNVFEbbkr6XrgOxFxe/r6ewAR8eP09RXA4RFxy4D3OfDNzKoQEVrUMe/Ycq9A+YUu\n",
+ "Bs6UdCxJd8yawK3VFGdmZtWpZSrkzpIeBT4BXCrpcoCIuBc4B7gXuBzYP2r9emBmZhWpuVvGzMxa\n",
+ "T6bzzyX9QNJdku6UdK2k1bKsp1KSpkm6L/0bLpC0fNY1VeKdbkRrVZK2T2+Oe1DSwVnXUylJJ0ua\n",
+ "J+nurGuplKTVJF2f/j/zN0lTsq6pEpJGSrolzZt7Jf0o65qqIWkxSXdIesdJLVnfXHRMRKwXEesD\n",
+ "FwGHZ1xPpa4CxkfEesADwCEZ11OpQW9Ea1WSFgOOI7k5bm1gD0lrZVtVxU4hqb8dvQ58KyLGk3TH\n",
+ "frOd/v0jYj6wZZo3Hwa2lLRpxmVV40CSbu937HbJNNwj4qWyl+8Cns6qlmpExNUR8Vb68hZgdJb1\n",
+ "VOodbkRrVRsCsyNibkS8DvyW5Ka5thERNwLPZV1HNSLiyYi4M/39ZeA+kvta2kZEvJr+uiSwGPBs\n",
+ "huVUTNJoYALwKxaeyPI2WbfckXSUpEeAScCPs66nBl8CLsu6iJxbFXi07LVvkMuIpDHAR0gaNW1D\n",
+ "0ghJdwLzgOvTCSDt5H+Bg4C3FnVgw8Nd0tWS7h7k57MAEXFYRLwfOJWk8JayqPrTYw4D/hURZ2ZY\n",
+ "6qCGU38b8eh/C5D0LuA84MC0Bd82IuKttFtmNLB5O60zI2kiUIyIO1hEqx3qN899SBGxzTAPPZMW\n",
+ "bPkuqn6XOaqqAAABOklEQVRJ+5J8Tdq6KQVVqIJ//3bwOFA+6L4aCy91YQ0maQngfOA3EXFR1vVU\n",
+ "KyJekHQp8DFgVsblDNcngR0kTQBGAstJOj0i9hns4Kxny6xZ9nJH4I6saqmGpO1JviLtmA7WtLN2\n",
+ "uKnsNmBNSWMkLUmy+ujFGdfUMSQJOAm4NyJ+mnU9lZI0StIK6e8FYBvaKHMi4tCIWC0iuoEvANcN\n",
+ "FeyQfZ/7j9IugjtJVmr7Tsb1VGomyUDw1enUpOOzLqgSQ92I1qoi4g3gAOBKktkCZ0fEfdlWVRlJ\n",
+ "ZwE3AR+U9Kik/bKuqQKbAHuRzDK5I/1pp5k/qwDXpXlzC3BJRFybcU21eMduSt/EZGaWQ1m33M3M\n",
+ "rAEc7mZmOeRwNzPLIYe7mVkOOdzNzHLI4W5mlkMOdzOzHHK4m5nl0P8DGV+a6aOfOCUAAAAASUVO\n",
+ "RK5CYII=\n"
],
"text/plain": [
- ""
+ ""
]
},
"metadata": {},
@@ -537,7 +549,8 @@
" w = wRidge(X,y,1.0)\n",
" plt.plot(x,X.dot(w))\n",
" plt.title(\"MSE %f\" % MSE(X.dot(w),y))\n",
- " plt.plot(x,y,'yo')"
+ " plt.plot(x,y,'yo')\n",
+ " print \"minimal MSE for n=7\""
]
},
{
@@ -549,7 +562,7 @@
},
{
"cell_type": "code",
- "execution_count": 31,
+ "execution_count": 58,
"metadata": {
"collapsed": false
},
@@ -562,331 +575,350 @@
},
{
"cell_type": "code",
- "execution_count": 32,
+ "execution_count": 59,
"metadata": {
"collapsed": false
},
"outputs": [
{
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "minimal MSE for n=6\n"
+ ]
+ },
+ {
"data": {
"image/png": [
"iVBORw0KGgoAAAANSUhEUgAAAi8AAAEZCAYAAABfH8VpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n",
- "AAALEgAACxIB0t1+/AAAIABJREFUeJzs3XecVNX9//HXGxBBpSkKUgSkiNiiMZafDZOoiAUbxtgT\n",
- "I998TcBYYtREl9WvoolRwZJYYxQbAioaxaARe40dLKACooggCCgown5+f5yzMDvM7M7uzu6dmf08\n",
- "H4957M4t535m9u6dz5xz7jkyM5xzzjnnikWzpANwzjnnnKsNT16cc845V1Q8eXHOOedcUfHkxTnn\n",
- "nHNFxZMX55xzzhUVT16cc845V1Q8eXFIOk/STUnH4ZxzzuXCk5c8kjRL0neSNklb/rqkCklbxOfd\n",
- "JE2QtEDSV5LelnRSXNczbrss7TE0yzGnSjqlPnGb2SgzO7U+ZaTEs6+kJ+Pr+riGbY9Le43fxNe+\n",
- "Y1zfQtI1kuZJ+lLSJEld4rotMrxHFZLOiOsPkvSspMVx/5skbZRy7K6SHozlfiLpf1LW9Yvrvojr\n",
- "J0vqV4v3YGqMZfu05ffH5fvE5+0l3RrjWyrpfUl/SNm+QtLXaa/x7CzHvE3SxbnGWE3sledfna4N\n",
- "kp5I3z/Da1glaUxct5ukKfF9/kLSOEmdczhOX0nfSrojZdl6ksZL+jj1fU7b73JJC+PjspTl1Z5P\n",
- "cZs/SpotaYmkuyW1SVm3fvxbLol/zzPSj+2cyx9PXvLLgI+An1cukLQd0Dquq3QHMBvYAtgYOAGY\n",
- "n1ZWOzNrk/K4r5pjZiWpRe1eQr19DdwM/L6mDc3sztTXCJwGfGhmr8dNTgP2ArYHugCLgWvivnPS\n",
- "9t0OqAAmxH3bAhcBmwNbA12Bv6QcfizwIbAZcBBwqaSBcV074AGgH9AJeBl4sBbvgQHvAydWLlBI\n",
- "aHcHvmDt3+wqYAOgv5m1BQ4FZqaVtX3aeXBFLeKoD9V6B+k4oAVp56SZbZTyd+oMrADGxdXtgb8D\n",
- "PeJjGfCPHA53HeHvkn7+Pw0cD3yevi4mqEMI59P2wCGVSWtN51P8cnE88P8I52Jr4rkYjQR6E/6n\n",
- "9wXOkXRADq/DOVcXZuaPPD2Aj4E/Ai+nLLsCOJ9wIdwiLltG+FDKVEbPuG2zHI53CbCK8GGwDBgT\n",
- "l1cQPvhnEJIBgNHAHGAJ8CqwZ0o5I4E70o5/IiHBWgCcX4f34qfAx7Xc50nggpTnNwCXpzw/CHgv\n",
- "y75lwBPVlH048Fb8faP4GjumHev2LPtuHLfvUJvXAXwCKC77LXB9XLZ3XPY2MKSaciqALXM43jBg\n",
- "JfBdPA8ejMu7ED58vyAk1cNT9tklngdLCB/0V8Tlc+Jxl8XHrjm+5naEhG3X6s5f4CRgZjXl7AQs\n",
- "reFYxwD3xr/5HVm2WfM+pyx7HvhVyvNfAC/kcj4B44GzU57vTvi/axWffwr8NGV9OXB3bf9v/OEP\n",
- "f+T28JqX/HsRaCupv6TmwM8I3/LTt7le0s8Um5IyqPGbr5n9EXgG+I2Fb4wjUlYPAX4EDIjPXwZ2\n",
- "ADoAdwH3SWpZWVSG4vcg1Dz8BLhQ0lYAkvaUtLim2GpLUg9CLcvtKYv/DRwoaXNJGwDHAY9k2FeE\n",
- "ZOuf1RxiH+Cdyl3SfkKohdw2y757A/PMrDav+zNgOlD57fsEqr42COfBJZJOltQ3Szm5nAc3AncS\n",
- "Er02ZjYkNts8BLxOSGJ+AvxO0v5xt9HAVWbWDtgSqKzZ2yv+rKz5eyk2qSyW1K2aMC4lJGfpNYjp\n",
- "TmLd9yHV3qz9O61DUltCYnAGta8dGgC8mfL8LWCbDMfIdD4Z654v6wN9JXUg1PDVWLZzLj88eWkY\n",
- "dxAufvsRPsA+TVs/lJB0XAB8pNAnZue0bRbGD4zKx1bVHC/TRXyUmX1lZt/BmiaaxWZWYWZXEi68\n",
- "W1Wzf7mZfWdmbxEuyj+I5TxrZh2qiaWuTgSeNrPZlQvMbALhw/dTQg3BVkCmfh17Epp/xmcqWNJ+\n",
- "sfwLY7nLgOeAC2JfhZ2AIwhNAen7dgOuBc6sw2u6HThRUn+gvZm9mLZ+OCHp+C0wTdIMSYPStnkt\n",
- "7TzYr5rjpf4df0SoWfo/M1tlZh8TmvOOietXEj54O5rZcjN7KUMZwJomlQ5mNjfjQcO5uztVm1Ey\n",
- "bdeDkJxkTDJjH6ELqL7J8WLgZjP7jBqaTDPYiHAeVVoal6XLdD5NBn4lqYekdkBl36QNUspIL7sN\n",
- "zrkG4clL/hkheTmOtd8yq3wgxKTiPDPbltCn4g1CH4tUm8QPjMrH+zUcM90nqU8knS1pukJH2sWE\n",
- "av6O1ZT5ecrvy4ENq9k2H9apOZF0BeEDYON4/PuBRzPsexIw3syWp6+QtBshQTjSzFL7kxwH9CK8\n",
- "T9cRasc+Tdt3U0Ltz3Vmdm8tX48BE4EfA78hQ22DmX1robP0zsAmhH4g90lqn7LZjmnnwZQcj98D\n",
- "6JKa+ADnET6UAU4h1Ky9K+llSQfV8vUBEGt4rgd+Z2YVqasybH4C8ExqgppSTh9CrdoIM3suy7F+\n",
- "QKhBurqaY1Tna0JfqErt4rJ0mc6nW4G7gamE5r7/xOVzU8pIL3tZLeNzzuXIk5cGYGZzCH0MDiR8\n",
- "gFW37ZfAXwkfNHWp0cj27XPNckl7Eb7NDjWz9rHmZAl16JTZECTtQah2T685GQT8IyZ7Kwk1ILtI\n",
- "2jhl39bAUWT4Nq9w19KDwMlm9mTqulibcIiZbWZmuwObAi+l7NuBkLg8YGaj6vK6zGwFIdn6NSGh\n",
- "rW7bZcAoQpLWqy6HS3s+h9DnKDXxaWtmB8fjzTSzY81sU+ByYHx8L2tbm9EW+CFwr6R5hOZJgLnx\n",
- "75oqY9NerJGZAlxkZndWc6x9CH2y5sRjnQUcKenVHGOdRqxBjHYgrYkq2/lkwUgz62VmWxBqVOea\n",
- "2aexOXFeTWU75/LHk5eGcwrw4/gBVkW8XXMbhVuB2wD/C8xI61ORa2Ixn3CXQ3XaEDr2LpTUUtKF\n",
- "VP2WmIuc4lHQClgvPl0/pW9NNpXfdL9JW/4WcJKktpLWI3RC/tTMFqVscziwyMympsWxLaGq/7dm\n",
- "lqmfTH9JbeL7cTyhie/KuK4t8BjwrJmdn8vrrsb5wD4xoU2P4QJJO8cYWgGnE+6oSq1lq815sGXK\n",
- "85eBZZLOkdRaUnNJ21Y2T0o6PtYsQUhkjdDRdkH8WdM5BYRaRELiuUN8DI6rdmJtIoOkyrt0qtw1\n",
- "J6kroRbj2th3pzo3xte4AyFR+DvwL9b2K6q8ZblVfJr6O4TarzMldYnHPRO4Le0Y2c6nDpJ6x/N7\n",
- "AOELx0VpZf9J4fb3rYFfZSjbOZcnnrw0EDP7yMxeS12U8ntrQhPIYsLtut0Jt8mm+kpVx5z4XZZD\n",
- "jQaOkrRI0tVZtpkcHx8Aswh3SaR+mFpafJm+fRuEWhxJ1VWH70NoZvoX4XWtiMcm7v+OpNRbyVsR\n",
- "+gBl6gdxBuGD9EPCHTODCB8uqU4kc63GmYSmmFtT3sO3U9YfEMtdRLhb54BYC0Y8xs7AL1L2XVpD\n",
- "h9WMzGyemT2fZXUF4bbgBYQmq58AB6U1V7yZdh5cmaWsW4ABsYloYmzCOZjwIf9RPMaNrE1aDwDe\n",
- "iX/Lq4BjYh+n5YS72J6LZe2itWOgZHz9ZvZF5QNYSDhX5pvZ9ymbnQhMyJCg/opQ0zQy9b2uXCnp\n",
- "fEmPxOOsSDnWfEJzzYqUvxuExG85IVF6DPhGsVO8md1A6MT8NiExfihDwpTtfOpIOKe/JjRv3WJm\n",
- "N6esLyOcT7MJd5tdbmb/zvR+Oefqr/I2zsY/sNSd8G1lM8LF7kYzGxObBO4ltNnPAo6O3+6cc845\n",
- "5xJNXjoDnc3sDYWRT/8LHEYYe2Ghmf1ZYbTRDmZ2biJBOuecc67gJNZsZGafm9kb8fevgXcJo6Ae\n",
- "ytomhH8SEhrnnHPOOaBA+rxI6gnsSLjbo1Nsz4bQCbFTQmE555xzrgAlnrzEJqMJwOnxdtE1LLRp\n",
- "JdOu5ZxzzrmC1NiT9lURb3+dQJifpHKQtvmSOpvZ55I2J9xlkr6fJzTOOVcHZlav8Z38+usaW6Zz\n",
- "NrHkRZIIt3dON7PUW3wnEcb9uDz+TB95Fqj/P2BjkDTSzEYmHUdNPM788jjzqxjiLIYYIX+JRzFc\n",
- "f11pyHbOJlnzsgdhivm3JL0el50HXAaMk3QK8VbpZMJzzjnnXCFKLHkxs2fJ3ufmp40Zi3POOeeK\n",
- "R+Iddkvc1KQDyNHUpAPI0dSkA8jR1KQDyNHUpAPI0dSkA8jB1KQDcK4pSWyQuvqQZN7m6pxztZOP\n",
- "a6dff/MnTpp7k5n1TzqWTCS9A5xmZk/nc9taxpDxfPPkxTnnmghPXpqGOHbaR0CLOM9Z0cp2vnmz\n",
- "kXPOuZIjKa99OvNdXiPJmmRKat6YgeSbJy/OOVdgJEnqNSoOKeFyJGmWpHMkvQUsk9RM0m6Sno+z\n",
- "pL8haZ+U7XtJejrOGj9F0nWS7ojrekqqkPRLSbOBx+PyX0qaLmmRpMmVs5bHdVdJmi9piaS3JG0T\n",
- "lw+WNC0eZ66ks+LygZI+Sdl/a0lTY6zvSDokZd1tMb6HYzkvStoyy1tR2XTzVdx2N0knS3pO0pWS\n",
- "FgJlkraU9B9JCyUtkDRWUru09/PH8feRksZJ+mcs8x1JP6zjtjtJej2uGyfpXkkX1+Zv7cmLc84V\n",
- "nN5HwKDToPfhSUdShI4BDgTaA5sDDwMXmVkH4GxggqRN4rZ3AS8CGwMjCcN3pPel2BvoDwySNIQw\n",
- "pMfhQEfgGeBuAEkHAHsBfc2sHTAU+DKWcQswzMzaAtsA/0kPOg7a+hAwGdgUGA7cKalfymY/i3F2\n",
- "AGYCl2R5D/aKP9uZWVszezE+3wX4ENgMuJRQM3NJfJ+2BrrH8iulvxeHxNfbjjAm27W13VZSS+B+\n",
- "4Nb4Ou4mzGFYqz4sxVgN5pxzJUnqMgzang4DW8D1beHUUVL/i2HpaLPPbkw6vlyoPE8D4ZXVqV+N\n",
- "AWPM7FMASccDj5jZZAAze1zSq8BBkqYCOwP7mtkq4DlJk1i3qWWkma2I5f0aGGVm78fno4DzY+3L\n",
- "SqANsLWkVyq3iVYC20h628yWAK+zrt2ADc3ssvj8SUkPAz8HyuOyiWb2ajz2ncCVWd6HbO/dZ2Z2\n",
- "Xfz9W0Ii82F8vlDSVcCFWfYFeKbyvZQ0FvhdHbbdDWhuZtfE5/dLermacjLy5MU55wrGvJug9SJo\n",
- "/tfw+dO8Faw6E+ZNTDqyXNUx6cinT1J+7wEMTW1+IXzu/QfoAiwys2/T9u1eQ3mjJf01bZsuZvak\n",
- "pGuB64AekiYCZ8c5+44E/gRcFpu0zk2pDVlTRtqxAGbH5RASs/kp61YAG1E7VcqX1AkYDexJSLya\n",
- "AYuq2T/1+MuBVpKaZekUnHFbwuv5NENctTpvvNnIOecKRJiMVgbN2sPR00Ed4uLiuy00Oanv1RzC\n",
- "3HkdUh5tzOzPwDxgY0mtU7bfgnWllzcsrbwNKxMRM7vGzHYGBgD9gN/H5a+a2WGE5qAHgHEZjvMZ\n",
- "0D2tn1MP1v2gz0W28yV9+aXAamDb2NR1Ag2fF8wDuqYt2yJDbNXy5MU55wpKy74w5Rdw37bw+Mnh\n",
- "uaujscAhkvaX1FxSq9hJtquZzQZeBUZKWk/S7sDBVP8h+ndCM9EAAEntJA2Nv+8sadfYd2U5oVlm\n",
- "dSz7OEntzGw1sIyQMKR7Ke53TtxnYIznnri+NjUTC4AKoHcN220EfAMsldSVmGw1sBcI78tvJbWI\n",
- "/Yh+VNtCPHlxzrkCYjb9MrOZE83Mws/plycdU7Eys7nAEOB84AtCzclZrP3sOw7YndCx9mLgXkL/\n",
- "lDVFpJX3AGHS4HskLQHeBg6Iq9sCNxKaXWYBC4G/xHXHAx/HfYbF41Y5hpmtJHRyPZCQfFwLnGBm\n",
- "H6Rsl55YZUy0zGw5oSPuc/GuqF2z7F8O7AQsIXQWnpCtzNocv7pt4+s8AjgFWEx4Lx6m6vteIx+k\n",
- "zjnnmoh8XDtL+for6V5gupmV17ixyxtJLwHXm9k/M6zzQeqcc865SrGpp7fCeDAHAocS+qS4BiRp\n",
- "b0mdY7PRScC2hFvEc+Z3GznnnGuqOgMTgU0Id7z82szeTDakJmErQqflDQm3ah9lZvOr36UqbzZy\n",
- "zrkmwpuNXLHJdr55zYtzztWROmkwbRlBS1qxkm9Zyhibb48kHZdzpc6TF+ecqwN10mC6MZpD6bNm\n",
- "4SR6q5PwBMa5huUddp1z9aZOGqy+mqxtNFV9NVmdNDjpmBpcW06vkrgAHEof2jI8oYicazK85sW5\n",
- "JiafTR0ql3iIYfTiIg5kszUrJrOLhmgSO/Ea8DVhIKysP63M1hnjIdc4Va5mwPpA6/hoVc+fuW3b\n",
- "lfUzviktaZ1xuXMubzx5ca4JqW9Th8q1PmFQqz3jYw9asQH7pX1gD6IDD7MXO7GUMIrnhmk/q/yu\n",
- "ckFqUjOD5vSla5VypzBQJ2g+faigajLREviOMNfLt9X+NFYwYdPtOHLB02jNukVZ9qm+vE95gLUD\n",
- "lK21khU1vY/Oufrx5MW5pqQtIzI2dYxlOJCpVqM9YQTSymTlh8AHwLPAncBpLOZOYJ91jrWcT6zM\n",
- "RuQSlsrVktQE5w1uZWhanPuxPuOYQx9Oompy8Z2V5XbbpNTnSNjvMN6Z8n9mM+s12aGu1xgm0Tst\n",
- "EfyQpVxTzW7OrSFpL+AmM+ufdCzFxpMX55qSlrTKsrw1gMrVnbWJyp7AlsDLwHOE4cZftDJbmrqr\n",
- "xupbMqlFDURsNlpJGC4cjVO2ocJXW5l9lGu5a2JUl2HQ9nQY2AKubwunjpL6XwxLR5t9dmNtywOw\n",
- "+faIOgnGMpyWtGYlK1jKNd5Z1+XKzJ4B8p64SOoJfAS0yDLjc23Kug34xMwuqH9k+ePJi3NNyUoy\n",
- "Jxpt6KdyzSY0xTxDqFm5DXjDyuz7astcSv5rILLFWecmmXk3QetF0PyvYX675q1g1Zkwr161LzFR\n",
- "8WSlAElqYWarCrW8RlKy4/H43UbOFThJknqNklT/C9FSxvAwc6ose4yldOBe4KdAJyuzI63MrrIy\n",
- "e6XGxIX4AT6X0xnLZMbxFGOZzFxG1KsGIiREM6ssq0dCZGYGMmjWHo6eDuoQFxffKJ0uK0mzJJ0j\n",
- "6S1gWRz2fzdJz0taLOkNSfukbN9L0tOSlkqaIuk6SXfEdT0lVUj6paTZwONx+S8lTY8THk6WtEVK\n",
- "eVdJmi9piaS3JG0Tlw+WNC0eZ66ks+LygZI+Sdl/a0lTY6zvSDokZd1tMb6HYzkvStoyy1vxdPz5\n",
- "laRlcWLGWscuaRhwLGGm62WSHqzP3yevzKzoHsRrkT/80RQe0PtI+PUS6H1EvcoZSSdG8jdO4it2\n",
- "4l224zn68CibMTjp15gx3s0YTB8eZQBT8xEnbH0u9D4CUPi59R+Sfo2Nfy5hhVBGA76+WcBrQFfC\n",
- "HWhdCbM7D4rrfxqfbxKfvwD8mdAKsQdhduXb47qeQAWhBrKyc/gQYAZhePtmwB+B5+L2BwCvAm3j\n",
- "862AzvH3ecAe8fd2wI7x94GEJhmA9YCZwLkxnn2BpUC/uP62GPvOQHNgLHB3lvehR4y9Wcqyusb+\n",
- "D+CiQjtnvdnIuQKVr34aKldr4AzgTOAOetHbbrMvGyzwPMl3k4zZ9MtSntaruchlJ5GX2iyzOjV5\n",
- "GDDGzD4Nseh44BEzmxzKtMclvQocJGkqIRHY10Jz0HOSJrFuU8tIM1sRy/s1MMrM3o/PRwHnxxqM\n",
- "lUAbYGtJr1RuE60EtpH0tpktAV7PEPtuwIZmVnmePinpYeDnQOUs1xPN7NV47DuBK7O8D5neu7rG\n",
- "nq28RHmzkXMFa95N8H1Z6J+xpp/GhWF5zVSuZirXCcD7hNubd7MyO8PKCj9xccXLDOXjUY8QPkn5\n",
- "vQcwNDbDLJa0mFDD0hnoAiwys2+z7JutvNEpZVX+L3UxsyeBa4HrgPmSbpDUJq4/EhgMzIrNQrtl\n",
- "OE6XDMefHZdDSMxSJy9cQbg7L1d1jb0gefLiXIEyszr301C59iVUA/8G+LmV2VFWZjNr2M25UpD6\n",
- "/zEHuMPMOqQ82pjZnwlNORtLSh2jaAvWlV7esLTyNjSzFwHM7Boz2xkYAPQDfh+Xv2pmhwGbAg8Q\n",
- "ZlRO9xnQPa1vWw/g09q8+Awx1yv2LGUlLtHkRdKtsYPQ2ynLNo4dpz6Q9G9J7ZOM0blktewLU34B\n",
- "920Lj58cnmencvVXuSYBtwKXA7tbmT3XGJE6V4DGAodI2l9Sc0mtYifZrmY2m5Dgj5S0nqTdgYOp\n",
- "/sP674SmlgEAktpJGhp/31nSrpLWA5YTxiBaHcs+TlI7M1sNLANWZyj7pbjfOXGfgTGee+L62tRG\n",
- "LSD0eeldn9jjfvMJQyYUlKRrXv4BDEpbdi4wxcz6AU/E5841SWbTLzObOdHMLPycfnmm7VSuzVSu\n",
- "6wi3OT8NbG1ldm+ug7c5V4rMbC6ho+r5wBeE2oezWPvZdxxhEMYvgYuBewn9P9YUkVbeA4QvBfdI\n",
- "WgK8zdpRltsCNxJGbJ5F6Fz7l7jueODjuM+weNwqxzCzlcAhwIGE5ONa4AQz+yBlu/T/54z/32a2\n",
- "nDAu03OxmWiXesR+CzAgllMwfcWUQw10wwYQBtN5yMy2i8/fA/Yxs/mSOgNTLW30QUlmZgXXgci5\n",
- "xhY7454OnE0Y8fZiK7OFyUblClU+rp2lfP2VdC8w3czKa9zYNYps51sh3m3UycwqOyXNBzolGYxz\n",
- "hShORvhz4FJC1ffuVmYzko3KueIiaWfCqM4fE2ohDiX8T7kCV4jJyxpmZpK82tu5FCrXPsBfCW3a\n",
- "x1uZPZNwSM4Vq86E2+Y3Idzp82szezPZkFwuCjF5mS+ps5l9LmlzQjvlOiSNTHk61cymNkZwzjU2\n",
- "id2BeYzU+oQBtXYAzgPutbL6zVviSlvs9Dkw4TAKlpk9DDycdByu9gqxz8ufgS/N7HJJ5wLtzezc\n",
- "tH1Kts3VuUoSmwNXo9W702LFpvR6shm9/30b/R843a78JPPcP85Vw/u8uGKT7XxLNHmRdDewD9CR\n",
- "0L/lQuBBwj3wWxB6PR9tZl+l7ef/PK7gqJMG05YRtKQVK/mWpYypy/w+Es2A/wG7iH4PvcXQY3bg\n",
- "+9b38be3ZrCs6ymE5qIxwJ1mLM/363Cly5MXV2wKMnmpK//ncYVGnTSYboxOm1l5JnM5vTYJjMQO\n",
- "YDew0bz2HH9gGzq/9QrwByurHNIbAT8BRhBu8bwVuN6M2Xl9Qa4kefLiik228y3pcV6cKw1tGVEl\n",
- "cQE4lD60ZXguu0tsKPEXmq18kgPO2owzuy+j81vHWpkdVpm4AMQ5yR4341DCXCjrAa9JTJDYJyY3\n",
- "zjlX0jx5cS4fWtIqy/LWGZenkDiYZivfp8+jR3NGj2/Y/ao/0axiVyuzp6rbz4wPzTiTMIT4E8AN\n",
- "wOsSv5RqPq5zzhUrT16cy4eVZO5Au5IV2XaR6Kr1lk9iw/ljOfaQNhw/+HrafN7Pyuyu2txFZMbX\n",
- "ZlxPmJPkHOAIYLbEpRLda/lKnCsZkm6TdHHScbj88+TFuXxYyhgmUXXiw0l8yFKuSd9UorlafnMG\n",
- "633zPrtd/RNG9L2bPv/uY2V2uZVZ1mSnJmZUmPFvMw4mzJy7AfCGxDiJPb1JyTVBmYbUzyjO9nxK\n",
- "XQ+Ur0RJUk9JFZL887kahTjOi3NFx+bbI+okGMtwWtKalaxgKdekd9ZV8+93ZIPF49n4wy4MOv15\n",
- "ur3yGyuz9/IejzED+J3EBcBJhPlJvpEYA9xjlqWmyLl6CDMi97wUZp2fy+znDVVGepE5bldod6/4\n",
- "l43qWOwBWEyPEHbycfjDH7k+wDai4/R7aL3wew4cPosLm+/byMdvBjYI7BGw+WD/B9Y16ffFH437\n",
- "yMe1s7oyoPeR8Osl0PuIupdf9zKAHYHXgKWE2ZjvBi6O6zoQBqT7gjAB4UNA17juEmAVsIIw6/OY\n",
- "uHw0YTLHJYRpOPbMctxhhAkdv4v7PxiXdwEmxGN+BAxP2WeXWOYS4HPgirh8DmE4hGXxsWvS500h\n",
- "nrOJB5bPF+MPfxTigy2e+h82mP8N2971NcN2+l9G0izReLCtwMaALQK7B+z/gSnp98kfjfG3xxqi\n",
- "DNh8GGw1DU55Hyos/NxqGmw+LPdy61cG0BKYTZiotDlwZEwoLorrNwYOB1oBGxHGE7s/Zf8ngV+m\n",
- "lXlcTHqaAWcC84CWWY7/j8pjxefNgP8CfyK0cvQCPgT2j+tfAI6Lv29QmaQQOuBXQLLXiUJ5ZDtn\n",
- "vU3NuQaiH9y+nbq+MpOvN7+OgeV3cdSxm9oN//1b0kP6m/G+GSOAnoQL6O3AKxInSqyfZGyuWM27\n",
- "Cb4vg+atQmtH81aw6sKwvNHK2A1oYWajzWy1mU0AXqlcaWaLzOx+M/vWzL4mTMC4T1oZVZpqzOxO\n",
- "M1tsZhVmdiWwPrBVNTGk7v8joKOZ/Z+ZrTKzj4GbgWPi+pVAX0kdzWy5mb2UKQaXmScvzuWZDj9x\n",
- "A+1w+wN8MPhNNp22iEN/1dP+dd2p9emM2xDMWGrGaKAfUEb4ljlbojxOTeBcTszMQAbN2sPR00Ed\n",
- "4uKc+5HkoYwuwKdpy2YTkwFJG0i6QdIsSUuAp4B2oY/N2jBSd5Z0tqTpkr6StBhoRxgRPhc9gC6S\n",
- "Flc+CHOSbRbXn0L433tX0suSDsqxXId32HUub1Qu8dLwc/jv2RfRfNUyfnjTQfbMeY/CyUmHVi0z\n",
- "KoB/Af+S2Br4LTBN4lFgjBkvVVuAcwC07AtTfgEf3g+9Dw/PG7WMeUDXtGU9YM1dgGcRkoVdzOwL\n",
- "ST8g9I8RGe5KkrQX8Hvgx2Y2LS5bRPaakfQkaw7wsZn1y7ix2Uzg2FjukcB4SRtnKMdl4MmLc3mg\n",
- "X+yzO6/98z5mDO7EFs9dwftDzrfPdiq6i5AZ7wK/kfgj8AvgbokFhLmU7jNjZaIBuoJlNv2ylKcT\n",
- "EyjjeWCVpBHA34BDCE03T8T1GxE65C6JSUJZ2v7zgd4pz9sQOvEulNQSOBdoW83x5wNbpjx/GVgm\n",
- "6RzgGkIz0dZAKzN7VdLxwGNmtoDQadcIfV0WxJ+9gRm5v/ymxZuNnKsHnd9mEw0641Em3PUsC7ee\n",
- "zYZfdLUF/UsYAAAgAElEQVT3hpxnVtzfnsz4yoyrgL7A/xGqj2ZLlEl0TjQ45zIws+8JAzSeDHwJ\n",
- "HE2406fS1UBrYCEh0XmUqrUco4GjJC2SdDUwOT4+IEwSvIJQm5LNLcCA2EQ00cwqgIOBHxDuNFoA\n",
- "3MjaBOgA4B1Jy4CrgGPM7DszW064++m5WNYudXg7Sl7RTsxIHx6r66y9ztWXytWC2XudyzPnXcDn\n",
- "O3zDhgtPsM+3/1fScTUkiW0ITUrHEG45HWO2tkOkK3w+MaMrNqU3MePxHEA3RquTBicdiitOkiT1\n",
- "GpXWYa/m/c5r/xOmXjiHuyZdyFc9b+TrLpuXeuICYMY0M/6XUDX+BjBO4gWJn0u0TDg851wTUrzJ\n",
- "C9Rq1l7n1tX7CBh0WugYWDOVq4eOP/Bxbnn2Ef576gK+32AbW7D1cDO+a+hIC4kZi834K9AHuBw4\n",
- "FfhY4k/SmjspnHOuwRR38gI5zdrrXCqpyzCp/zQYeClc3xYGjpL6T5O6DMu4fbk20JndL+Phv73H\n",
- "feN2ZWm3/2FZtx/Y6pZNujOdGavNeMCMHwODgC2A9yVuk/hhwuE550pY8d9t1JJNkg7BFZt5N0Hr\n",
- "RdD8rymDYZ0J86rc3aByiYpmQ3nnuOt49OoNQRNZ2Wa4GYsSCrxgmfE2MEziPML4FRMlPiHcpXS/\n",
- "Gd8nGqBzrqQUd83LQ8xhe7qrXLsmHYorHrkMhqVy7cCC/i9w+5SbefhvX7Oi4/62fJPjPHGpnhlf\n",
- "mvFnwm2eVwKnEZqUzpfYNNnonHOlopjvNprMUq7hNFoA1wE7W5nNTzo2VxykAefCyg9SB8Mym365\n",
- "yrUJ37e6hBfOPI6n/yQqWoyiYr2/+PgmdSexAzCcMNfM/YS7lN5INqqmye82csUm2/lWtMlL6otR\n",
- "uS4CBgI/sTLz6mlXaypXC+DXzN7zIibcVcE3m73J6vWHmfFh0rGVComOwK+A3wAfE5qUHjBjVaKB\n",
- "NSGevLhiU3q3Slc1kjB1+BUJx+GKkMq1L8s3eZPxd5/LP/+ziqXdf8vq9X/qiUt+mbHQjMsIs+uO\n",
- "AUYAH0mcK3nfNedc7koieYmz9B4HDFa5Tkg6HlccVK6eGtlsPG+ceC9Xztmcd372MBXrbWXGPcU+\n",
- "Qm4hM2OVGePN2Bs4jDBL70yJmyW2Tzg8V0Ik3Sbp4qTjyJWk4yQ9lu9tS1FJNButWV6ubYEngQOs\n",
- "zF5r/MhcMVC5NgD+wPztTmf8PV+woP9KaDbMjOeTjq2piuPDnEro4DuDMFT7Q96klF9NrdlI0j+A\n",
- "T8zswhy2nQrcYWa31PFYt8VjXVCX/V1mpd5sBICV2TuE9vQJKleu05a7JkLlkg4/+SweHzWPq2ad\n",
- "zt9fW8GCAbdAsx09cUmWGV+YcQnQkzCp3tmE2pjfS2ycaHAuJ+qkweqrydpGU9VXk+sy+nk+yshU\n",
- "bI7bNeg3eUnFPzRJASmp5AXAymwcMA64O3bCdE2YhCS2V8f3b+Dqj77m8VGjeP+Qx1jSYzDWoqsZ\n",
- "l/sYJIXDjO/NuNeMPYCjgG2BDyVukNg24fBcFuqkwXRjNMdzAEezT12mb8lLGdKOkl6TtFTSPUCr\n",
- "lHUdJD0s6Ys4+eJDkrrGdZcAewHXSlomaUxcPlrSHElLJL0qac8sxx0GHAucE/d/MC6fJekcSW8R\n",
- "ZphuLulcSTNjjNMkHZZSzsmSnkl5XiHpfyR9ECdpvLaabfeX9L6kryRdJ+kpSafk+t4Vm5JLXqI/\n",
- "xp+XJBqFS0RMWH4gcQla9QGtFz5Ln8eOZ8/LrmHgyA3si22ONuN5MyqSjtVlZ8arZpwE9AfmAv+W\n",
- "eEJiiETzhMNzqdoygkPpU2VZbadvqWcZkloCDwD/BDoA9xFuz6+sURFh5uct4mMFcC2Amf0ReAb4\n",
- "jZm1MbMRcZ+XgR1ieXcB98XjVGFmNwJ3ApfH/YekrD4GOBBob2argZnAnmbWFigHxkrqVM1LOwjY\n",
- "GdgeOFrSARlee8f4ev8AbAy8D+xOA9cmJakkkxcrs1WEE+ZolevopONxDS8mLDtJjAI+AJtIr8d3\n",
- "4Zd7bcI5m/2TA0/vbg/dcK49dIP3oSgyZsw342JCk9LNwLmEJqWzJDokGpwLWq6t4Uhbnvv0LfUv\n",
- "YzeghZmNNrPVZjYB1s56bmaLzOx+M/vWzL4GLgX2SSujShOTmd1pZovNrMLMrgTWJ3Qwzya9icqA\n",
- "MWb2qZl9F8scb2afx9/HEfp4VTfQ6mVmttTMPiH06fxBhm0GA++Y2QMx1jHA59WUWfRKMnkBsDL7\n",
- "EjgCuC525HUlJiYsP5K4nPBtZhwAA8uuoKz5N5y0XzO6v7i3jawYbmXmI+MWOTNWmnG3GbsDPyNc\n",
- "xD+S+JvEgITDa9pW8m2W5SsasYwuwKdpy2YTEwpJG0i6ITblLAGeAtqlzSpfpaZC0tmSpsemmMVA\n",
- "O6C2/Sk/SSvzREmvx2agxYSm0eqGCkhNQpYDG2bYpguhdjJV+vOSUrLJC4CV2evAmcD9Klf7pONx\n",
- "9RcTll0lriAMdHYnsAo4kj+1+ikj1ZeBF52LbCTw09iJ25UYM1424wRgADAfeEJiisQh3qSUgKWM\n",
- "YRIzqyybxIcs5ZpGLGMe0DVtWQ/WJiRnAf2AXcysHaHWRaytLUlPXPYCfg8MNbP2ZtYBWEL2DsDZ\n",
- "mmjWTjsi9QBuJNxYsnEs851qyszVZ0C3lOMo9XkpKsgOrZIGAVcDzYGbzezyupZlZXaHyrUzcKfK\n",
- "dUgcE8YVEYlmhGrVoYROnN8Q2ncPBd5mpFoT2np/SzhvTrAyy/0bnytaZswDRsbmwqHAhcDVEtcA\n",
- "/zBjSaIBNhE23x5RJ8FYhtOS1qxkBUu5xubbI41YxvPAKkkjCHesHQL8CHgirt+I0M9liaSNgbK0\n",
- "/ecT5uSq1IbwxWhh7OdyLtC2muPPB7asIcYNCcnMQqCZpBOhVh3RU5OtVI8QOhsPAf4F/BroXIty\n",
- "i07B1bxIak7oRDWI8K3q55K2rmexZxNO3JH1LMc1EolmEntKXE3LiZ/Tde9/06fvEWzZfg4dm59l\n",
- "xoWM1NuM1NHAu4R26B2tzC72xKXpMeM7M8YCuxAGrNyFMCHktRL9k42uabD59ojNsANtmg20GXZg\n",
- "bRKXfJRhZt8TugqcDHwJHA1MSNnkaqA1IXF4HniUqrUlo4Gj4p1IVwOT4+MDYBYh8ZlTTQi3AANi\n",
- "c9DETBuY2XTgr8ALhOagbYFnUzdJiym9Nid1/ZrfzWwhIXn/c3x9WwOvAt9VE29RK7hB6iTtDpSZ\n",
- "2aD4/FwAM7ssZZtaD5KkcnUi/DF/a2X2YB5DdnkSq/v3IPwTHgkspPWf32SrC/bmsJVbrNlwEjNp\n",
- "wdUM5mhCG/QIK7OnEwnaFSyJLoRvoMOANwhTEkxuyneZNbVB6poqSc0IfW2ONbOnko6nPoppkLqu\n",
- "VO3gNJd12zFrLc44fRRwk8pVXW9x14gkmkvsK3Ed4W9d2Ut+XzO2p+sfNq2SuEC4fbIlVwJ3Az/0\n",
- "xMVlYsZnZlxIuEvpLuBi4H2JYYkG5lwDiOO8tJe0PnB+XPxikjE1pELs85JTVZCkkSlPp5rZ1BoL\n",
- "LrOXVK7zgQdUrl2tzJbWLURXHxItCJ3ljiJU884FxgN7mzGjysbZbp/8ileszP7esJG6UmDGt8Dt\n",
- "EncQxr64X+I/ZmmdQ0uQpIHAwITDcI1jd0KS3hKYBhxWeXt2KSrEZqPdgJEpzUbnARWpnXbrW22p\n",
- "ct0AbAocxfUMoi0jaEkrVvItSxlTl7ZaVz2J9QgX0aGEyfhmEzrdTqhu9mZtrac4hr3XWTGWyTbD\n",
- "DmyYaF0pk7gemG1GnW8EKFbebOSKTbbzrRBrXl4F+krqSbj962fAz/N8jBHAVF7jVrqxR5VRHSfR\n",
- "W52EJzD1FxOWHxMSliHAR4SEZRczZmXdr1zrEUaVPJVd2YnHWMIBtFuzQW1vwXSuqvHA5fHhnCtC\n",
- "BVfzAiDpQNbeKn2LmY1KW1//bw/l6sIUPmI/1l9npX+rrzOJlsBPCU1ChxJ66o8n1LDMrnbfcm0J\n",
- "/Ipwt8BHwE3AfVzPQNrW/RZM51LFZst5wM41nZOlxmteXLHJdr4VZPJSk3z982hHvc5hGYZaHsdT\n",
- "Ns0G1rf8pkJifWA/Qg3LIcB0Qg3LRLOqo0uus2+51ifUypxKGDF1LHCTldn0Bg3aNWkSNwPTzbgy\n",
- "6VgakycvrtgUU7NR4/ma+RmX12ZI6yZKohVwAKGG5WDgLUINy/lm6wzRve7+4Y6vU4ETCSNM3gTc\n",
- "b2WWeYhw5/JrPHABNK3kJV8kFd+3XldSmnbNS+UU7Kl9Xv7FZ6zkQg7ndiuz7+t7jFIi0ZoweOBQ\n",
- "wkRgrxNqWO6PI51Wv3+5WhPGbzmVMKjcbcAtVmYzqtvPuXyLzZufA9vlkmyXCq81caWiSScvEBOY\n",
- "dvyODvQBWtKHRfSjHbA5oV18FmEOncpH5fPPrMxW5yOGQiaxAWE696GExOW/rE1YMtdcpZdRru0I\n",
- "CcuxhA7ZNwEPWZmtbJCgncuBxD+BV8y4NulYGosnL65UNPnkJesxwh0v3YFehEGueqU8ehJmAf2E\n",
- "dZOayscXVlaEby4gsSHhbp+jgP2BlwnV7PebsSCnMsq1IeFOsVMJ7+OtwK1WZrMaImbnakviUOAM\n",
- "M/ZNOpbG4smLKxWevNQ1htAE0oPMiU0vYAOqJjTpvy8upORGog0hYRlKuFvoBULC8oAZC2vcv1wC\n",
- "+gL7xsf+hDk7bgIetTJb1UChO1cnsd/W50A/M75IOp7GUAjXTufywZOXBqJytaFqYpP6ey/CSMLZ\n",
- "EpuPrcy+bvAYRVvC3UFHEcZjeY7QJPSgGYuq3TckK70JicrA+FgNPAlMBR6zMvusgUJ3Li8k7gae\n",
- "NOPGpGNpDMVw7XQuF568JCB+8Hcgc2LTMz6+IUtiA8yu6105Eu0I468MJSQcTxFqWCaZsbiGmHvF\n",
- "fSoTlmaEZKUyYfmokGqTnKuJxFHAqWYckHQsjaHYr53OVfLkpQDFRKETmRObXoQ+JF+SuSPxx8An\n",
- "qc00Eh1Ym7DsTUg27gMeMmNJNXH0YG2isi9hzozKROVJYGZ6sqJOGuzTLbhiEft3fQb0qqm2sRSU\n",
- "+rXTNR2evBQhlas5YabtnmSuvenENx3n88ZJ3/DOMRvxxbab0u6Td+j43sNse8/dbH/XDCuzigzl\n",
- "dqdqzcqGrE1UpgLvV1ezkvHW80nMZC6newLjCpXEBEIif1vSsTS0pn7tdKXDk5cSItEROAytHgr8\n",
- "P9p8+jr9H3iPvS9dwkbzu7I2yekAzGFtjU1zQrLSjpCkTCUkLO/WphlIfTWZ4zNUv/t0C66ASRwL\n",
- "HGvGwUnH0tD82ulKRdMeYbcESGwGHE7odLsL8BjW/GbgSFuyxddhDsoRVfcp1waEO6Uqk5lmwGhg\n",
- "WqYamZy1pFWW5a3rXKZzDe9h4G8Sbc1YmnQwzrma1Zi8SNrEzL5sjGBcbiQ6AUcQEpYfAo8CfweG\n",
- "mLG8pv2tzJYD78ZH/qwkcydin27BFTAzlko8TZjm4q6k43HO1SyXmpcXJb0B/AN41IqxnSkB0jed\n",
- "4Yzx8PcnoVkzQu2G0n7muix1XQ9ge+AR4BrgMbMCSQ6WMoZJ9E7r8/IhS7kmwaicy8UEwpcBT16c\n",
- "KwI19nmR1IwwaNkvgR8B44B/mNkHDR9e1pgKvt1WOuAU6Hcd9Lsfhr9DGNelIsPP2i5bAPzHLEst\n",
- "R8Li3UbDaUlrVrKCpVzjnXVdoZPYmNAHrKsZDT7GUlKK4drpXC5q1WFX0o+BsYS7UN4AzjOz5xso\n",
- "turiKNh/QKnLMGh7OuzZAm7qB6d+AM+ugqWjzT5rEgNhOVeMJB4DbjbjvqRjaSiFfO10rjZy6fPS\n",
- "ETgOOBGYD/wWeAjYgTC4Wc8GjK8IzbsJWi+C5n8NrT3NW8GqM2HexKQjc85Vazxh1vOSTV6cKxXN\n",
- "ctjmecIttEPMbLCZTTSz783sVUInUZci9AmSQbP2cPR0UIe42PsKOVfYHgAGSX53nHOFLpcOu/3N\n",
- "Mt8+a2aX5TmeEtGyL0z5BXx4P/Q+PDwvPD4arnNrmbFA4nXCpKIPJh2Pcy47H6SuifLRcJ1bl8Rv\n",
- "gF3NODHpWBqCXztdqcil2cgVCEmSeo2SVP+LT1tGVElcAA6lD20ZXu+ynSte9wMHS7RMOhDnXHY1\n",
- "Ji+S9sywbI+GCcdVr/cRMOi00BRVTz4arnPrMOMzwuCNP0k6FudcdrnUvGQaYOzafAfispO6DJP6\n",
- "T4OBl8L1bWHgKKn/tHBbdh35aLjOZVN515FzrkBl7bAraXfg/wGbSjqTcN8vQBu8uamRNcDt1z4a\n",
- "rnPZTATOl/i1GauSDsY5t67q7jZqSUhUmseflZYShtF2jcTMTOqTcvv1xt2p5+3XNt8eUSfBWB8N\n",
- "17lUZsyW+BjYB3gi6Xicc+vKZXqAHmY2u5HiyUlT7DEvDTgXVn6Qevu12fTLk47LuVIk8Qegpxn/\n",
- "m3Qs+dQUr52uNOWSvDyZYbGZ2Y8bJqSa+T+gc64hSfQBniXMdbQ66Xjyxa+drlTkMkjd71N+b0Xo\n",
- "yObtwM65kmXGTInPCf3+nkk6HudcVXUapE7SK2b2owaIJ9fj+7cH51yDkrgA6GjG6UnHki9+7XSl\n",
- "IpdxXjZOeXSUNAhoW5+DShoqaZqk1ZJ2Slt3nqQZkt6TtH99juOcc/UwHjhC8rsrnSs0uTQbvQZU\n",
- "Vs+sAmYBp9TzuG8DhwM3pC6UNAD4GTAA6Ao8LqlftrmVnHOuoZjxrsQyYBfgxaTjcc6tVWPyYmY9\n",
- "831QM3sPIMMo90OAu83se2CWpJn4hcM5l5wJhH5+fg1yroDk0mzUWtJZku6XNFHSGZIyDy1ff12A\n",
- "uSnP5xJqYJxzLgnjgSMlvJ+IcwUkl2aj2wkD040hDO96LHAHMLS6nSRNATpnWHW+mT1Uixgz9iiW\n",
- "NDLl6VQzm1qLMp1zLhdvARXAjoQm9KIiaSAwMOEwnMu7XJKXbcxsQMrz/0iaXtNOZrZfHeL5FOie\n",
- "8rxbXJap/JF1KN8553Jmhklrmo6KLnmJX+qmVj6XVJZYMM7lUS696F+L8xwBIGk34L95jCG1OnYS\n",
- "cIyklpJ6AX2Bl/N4LOecq63xwFHedORc4cil5mVn4DlJnxCacLYA3pf0NmGk3e1re1BJhxOaoToC\n",
- "/5L0upkdaGbTJY0DphPubDqtPvP3OOdcHrxKGKBzG+CdhGNxzpHj3EawzjcOq1xmZrMaJLLqY/KB\n",
- "lpxzjUbiSmCJGeVJx1Iffu10pSKX5OUOMzuhpmWNyf8BnXONSWIP4O9mbJd0LPXh105XKnLp87Jt\n",
- "6hNJLYAfNkw4zjlXkF4ANpHol3QgzrlqkhdJ50taBmwnaVnlA/iC0LHWOeeaBDMqgImEu46ccwnL\n",
- "pdnoMjM7t5HiyYlXfTrnGpvEvsAVZsVb8+zXTlcqckle9iHDQHFm9nRDBVUT/wd0zjU2iRbAZ8Cu\n",
- "ZnycdDx14ddOVypySV4eZm3y0oow19B/zezHDRxbdTH5P6BzrtFJ3Ah8YMYVScdSF37tdKWixuRl\n",
- "nR2k7sBoMzuiYULKKQb/B3TONTqJA4CRZuxe48YFyK+drlTkcrdRurnA1vkOxDnnisB/gH4S3ZIO\n",
- "xLmmrMYRdiVdk/K0GfAD8js9gHPOFQUzvpd4CDiCMEq4cy4BufR5OZm1fV5WAx+b2XMNHFe1vOrT\n",
- "OZcUiYOB35uxT9Kx1JZfO12pyCV5aQ30ISQwM83s28YIrDr+D+icS4rE+sDnwNZmfJ50PLXh105X\n",
- "KqobpG49SX8GPgH+CdwOzJX0F0nrNVaAzjlXSMz4DngUOCzpWJxrqqrrsPsXYGOgl5ntZGY7AVsC\n",
- "7aE4bxN0zrk8GY+PtutcYrI2G0maCfQzs4q05c2B982sTyPEl5FXfTrnkiSxATAP2NKML5OOJ1d+\n",
- "7XSlorqal4r0xAXAzFYD6yx3zrmmwozlwBRgSNKxONcUVZe8vCvppPSFkk4A3mu4kJxzriiMB45K\n",
- "OgjnmqLqmo26EWZRXcHacV1+CGwAHG5mcxslwsyxedWncy5REm2AT4EtzPgq6Xhy4ddOVyqqvVVa\n",
- "koAfA9sQbpWebmZPNFJsWfk/oHOuEEg8CNxnxtikY8mFXztdqaj13EaFwP8BnXOFQOJE4Aiz4rht\n",
- "2q+drlR48uKcc3Uk0QGYDXQ1Y1nS8dTEr52uVNRlYkbnnHOAGYuB54DBScfiXFPiyYtzztXPBHzA\n",
- "OucalTcbOedcPUh0BGYCXeL4LwXLr52uVHjNi3PO1YMZCwnDSRyQdCzONRWevDjnXP1505Fzjcib\n",
- "jZxzrp4kNgemA53jrNMFya+drlR4zYtzztWTGfOAd4CfJh2Lc02BJy/OOZcf3nTkXCNJJHmR9BdJ\n",
- "70p6U9JESe1S1p0naYak9yTtn0R8zjlXBxOBIRLrJR2Ic6UuqZqXfwPbmNkOwAfAeQCSBgA/AwYA\n",
- "g4DrJXntkHOu4Jkxh3DL9MCEQ3Gu5CWSGJjZFDOriE9fArrF34cAd5vZ92Y2i3Ah2CWBEJ1zri7G\n",
- "401HzjW4QqjV+CXwSPy9CzA3Zd1coGujR+Scc3UzAThconnSgThXylo0VMGSpgCdM6w638weitv8\n",
- "EVhpZndVU1TGe7kljUx5OtXMptYxVOecywszPpL4DNgTeCrpeCQNxJuxXAlqsOTFzParbr2kkwmT\n",
- "mf0kZfGnQPeU593iskzlj6xfhM451yDGA0dRAMlL/FI3tfK5pLLEgnEuj5K622gQ8HtgiJl9m7Jq\n",
- "EnCMpJaSegF9gZeTiNE55+poAnCEVBDN8s6VpAareanBNUBLYIokgBfM7DQzmy5pHGGkylXAaVaM\n",
- "QwA755osM96TWAzsCryQdDzOlSKfHsA55/JMohzYyIyzko4llV87Xanwak3nnMu/CcCREp4oONcA\n",
- "PHlxzrn8extYCfww6UCcK0WevDjnXJ6ZYfhcR841GE9enHOuYUwAjvKmI+fyz5MX55xrGP8F1gO2\n",
- "SzoQ50qNJy/OOdcAvOnIuYbjyYtzzjWcytF2nXN55MmLc841nJeA9hL9kw7EuVLiyYtzzjUQMyqA\n",
- "iXjTkXN55cmLc841LG86ci7PPHlxzrmG9SzQRaJ30oE4Vyo8eXHOuQZkxmrgfrzpyLm88eTFOeca\n",
- "nt8y7VweefLinHMNbyrQW2KLpANxrhR48uKccw3MjO+BScARScfiXCnw5MU55xqHNx05lycys6Rj\n",
- "qDVJZmY+2ZlzrmhIrA98DgwwY14yMfi105UGr3lxzrlGYMZ3wL+Aw5OOxbli58mLc841Hm86ci4P\n",
- "vNnIOecaiURrQtNRHzMWNP7x/drpSoPXvDjnXCMxYwXwGDAk6VicK2aevDjnXOOagM915Fy9eLOR\n",
- "c841Iok2wKdADzMWN+6x/drpSoPXvDjnXCMyYxnwH+CQpGNxrlh58uKcc41vPN505FydebORc841\n",
- "Mon2wBygmxlLG++4fu10pcFrXpxzrpGZ8RXwLHBQ0rE4V4w8eXHOuWSMxwesc65OEkleJF0s6U1J\n",
- "b0h6QlL3lHXnSZoh6T1J+ycRn3PONYIHgf0kNkw6EOeKTSJ9XiS1MbNl8ffhwA5m9itJA4C7gB8B\n",
- "XYHHgX5mVpG2v7fbOueKnsQU4O9mTGic4/m105WGRGpeKhOXaCNgYfx9CHC3mX1vZrOAmcAujRye\n",
- "c841Fp/ryLk6aJHUgSVdApwArGBtgtIFeDFls7mEGhjnnCtFDwCXSbQy49ukg3GuWDRYzYukKZLe\n",
- "zvA4BMDM/mhmWwD/AK6upqjiu5fbOedyYMbnwJvAfknH4lwxabCaFzPL9Z/xLuCR+PunQPeUdd3i\n",
- "snVIGpnydKqZTa1liM45Vwgqm44eynfBkgYCA/NdrnNJS6rDbl8zmxF/Hw7sYmYnpHTY3YW1HXb7\n",
- "WFqQ3unMOVcqJLoBbwGdzVjZsMfya6crDUn1eRklaStgNfAh8L8AZjZd0jhgOrAKOC09cXHOuVJi\n",
- "xlyJ94F9gceSjse5YuDTAzjnXMIkzgb6mTGsYY/j105XGjx5cc65hEn0Al4CupixquGO49dOVxp8\n",
- "egDnnEuYGR8DnwB7JR2Lc8XAkxfnnCsME4Cjkg7CuWLgzUbOOVcAJPoBU4FuZlTUsHkdj+HXTlca\n",
- "vObFOecKgBkfAF8Cuycdi3OFzpMX55wrHOPxpiPnauTJi3POFY4JwJES3rTjXDU8eXHOucIxjTBZ\n",
- "7Y+SDsS5/9/evYZaVtZxHP/+HBUr7SKVmQ7ZxaAxvGRYacGRMETCYZBQIyqD3pQ1lJSNA/kiQiso\n",
- "I/FFZUaIl8q01FLHGwrCmDDjWDPjBZxSM02sMMLy8u/FXhPbM2efc2Y8M89ac74fGM7aa2/W+Z0z\n",
- "7M3vPM9az+ozy4sk9UQVxWjq6JTWWaQ+s7xIUr84dSTNwfIiSf2yDlgCHNE6iNRXlhdJ6hGnjqS5\n",
- "WV4kqX+uAla0DiH1lSvsSlLPJOwB7F/FUwt7XD87tXuwvEjSIuFnp3YXThtJkqRBsbxIkqRBsbxI\n",
- "kqRBsbxIkqRBsbxIkqRBsbxIkqRBsbxIkqRBsbxIkqRBsbxIkqRBsbxIkqRBsbxIkqRBsbxIkqRB\n",
- "sbxIkqRBaVpekpyV5MUk+4/tW5XkwSSbk3ykZT5JktQ/zcpLkqXACcCfxvYtA04FlgEnAhclGezo\n",
- "UJKp1hnmw5wLy5wLawg5h5BR2p20LAbfBb46bd9y4PKqeq6qtgAPAcfs6mALaKp1gHmaah1gnqZa\n",
- "B5inqdYB5mmqdYB5mmodYB6mWgeQFpMm5SXJcuDRqtow7ak3A4+OPX4UOGiXBZMkSb235846cJI1\n",
- "wJtmeGo1sAoYP58lsxyqFjKXJEkatlTt2m6Q5N3ALcC/u10HA48B7wPOAKiq87vX3gCcW1Vrpx3D\n",
- "QiNJO6CqZvtjURqEXV5etgmQPAwcXVVPdyfsXsboPJeDgJuBd1TrkJIkqTd22rTRdvh/MamqjUl+\n",
- "DoqXzhsAAAVBSURBVGwEngc+Z3GRJEnjmo+8SJIkbY8hr6HyjST3Jlmf5JZu3ZjeSfKdJJu6rL9K\n",
- "8prWmWaS5GNJ/pjkhSTvaZ1nuiQndgsXPpjk7NZ5ZpLkJ0meSHJf6yyTJFma5Lbu//oPSb7YOtNM\n",
- "kuyTZG33/t6Y5LzWmWaTZEmSdUmubZ1lkiRbkmzoct7dOo/0cgy2vADfrqojqupI4Brg3NaBJrgJ\n",
- "OKyqjgAeYHSlVR/dB6wA7mgdZLokS4ALGS1cuAw4Pcm72qaa0SWMMvbZc8CXquow4P3A5/v4u6yq\n",
- "Z4Hju/f34cDxST7YONZsVjKa7u7zUHYBU1V1VFUNef0sabjlpaqeGXu4L/BUqyyzqao1VfVi93At\n",
- "o6ureqeqNlfVA61zTHAM8FBVbamq54ArGC1o2CtVdSfw99Y5ZlNVf62q9d32v4BNjNZX6p2q2npF\n",
- "4t7AEuDphnEmSnIwcBLwY2Zf9qEP+p5PmpfBlheAJN9M8mfgU8D5rfPMw2eA37YOMUAHAY+MPXbx\n",
- "wgWQ5BDgKEaluneS7JFkPfAEcFtVbWydaYLvAV8BXpzrhY0VcHOSe5J8tnUY6eXow9VGE82y0N05\n",
- "VXVtVa0GVif5GqMPkDN2acDOXDm716wG/ltVl+3ScGPmk7On+jwUP0hJ9gV+CazsRmB6pxuxPLI7\n",
- "T+zGJFNVdXvjWC+R5KPAk1W1bgD3Nzquqh5P8gZgTZLN3WihNDi9Li9VdcI8X3oZDUc05sqZ5NOM\n",
- "hpU/vEsCTbAdv8++eQwYPyF7KS+9jYS2Q5K9gKuAS6vqmtZ55lJV/0xyPfBe4PbGcaY7Fjg5yUnA\n",
- "PsCrk/ysqj7ZONc2qurx7uvfklzNaDrW8qJBGuy0UZJDxx4uB9a1yjKbJCcyGlJe3p2EOAR9mxe/\n",
- "Bzg0ySFJ9mZ05/HfNM40SEkCXAxsrKoLWueZJMnrk7y2234FozvQ9+49XlXnVNXSqnorcBpwax+L\n",
- "S5JXJtmv234Vo9uz9PaqOGkugy0vwHlJ7uvmxKeAsxrnmeQHjE4oXtNdonhR60AzSbIiySOMrkC5\n",
- "PsnvWmfaqqqeB84EbmR0RceVVbWpbaptJbkcuAt4Z5JHkjSZxpzDccAnGF29s67718crpA4Ebu3e\n",
- "32uBa6vqlsaZ5qOvU5wHAHeO/T6vq6qbGmeSdpiL1EmSpEEZ8siLJElahCwvkiRpUCwvkiRpUCwv\n",
- "kiRpUCwvkiRpUCwvkiRpUCwv0jRJFny5/CRvSXL6Qh9XkhYjy4u0rZ2x+NFbgY/vhONK0qJjeZEm\n",
- "SDKV5PYkv0iyKcmlY89tSfKtJBuSrE3y9m7/T5OcMva6Z7rN84EPdSvarpz2fVYkubnbPjDJ/Une\n",
- "uPN/QkkaJsuLNLsjgZXAMuBtSY7t9hfwj6o6HLgQuGBs/0zOBu6sqqOq6vvjT1TV1cDjSc4Efgh8\n",
- "vaqeXOCfQ5J2G5YXaXZ3V9VfanQfjfXAIWPPXd59vQL4wBzHmetml18AVgHPVtWVOxJUkhYLy4s0\n",
- "u/+Mbb8A7DnhdVtHXJ6ne18l2QPYe57fZ2l3/AO6Oz9LkiawvEg77tSxr3d121uAo7vtk4G9uu1n\n",
- "gP1mOkiSPYGLgdOAzcCXd0JWSdptTPorUlrMasL2dK9Lci/wLLD1MugfAb9Osh64Adh62fW9wAvd\n",
- "/kumnfeyCrijqu5KsgH4fZLrqur+hfhhJGl3k9FUvqTtkeRh4Oiqerp1FklabJw2knaMrV+SGnHk\n",
- "RZIkDYojL5IkaVAsL5IkaVAsL5IkaVAsL5IkaVAsL5IkaVAsL5IkaVD+Bwn7vQevE1gaAAAAAElF\n",
- "TkSuQmCC\n"
+ "AAALEgAACxIB0t1+/AAAIABJREFUeJzs3XeYnGX59vHvmYSQUBJCC4ReQgeFH1KUEgtCQu8ICSBo\n",
+ "BISIdFCZjEiTVzA0FaQJSAcFhCgtgiggiiKE3ksIICXBJATI+f5x35tMJjub2d3ZnZ3d63Mcc+zO\n",
+ "U+7nmtnZmWvuKtuEEEIIITSKXvUOIIQQQgihNSJ5CSGEEEJDieQlhBBCCA0lkpcQQgghNJRIXkII\n",
+ "IYTQUCJ5CSGEEEJDieQlzJekEyVdXO84QgghBIjkpVNJelnSx5KWKNv+mKRZklbM95eXdJOkdyR9\n",
+ "IOk/kg7I+1bOx04tu+1Z4ZoTJB3cnrhtn2772+0poySeL0u6Lz+ul6o4fiFJF5Y8F38u27+RpPvz\n",
+ "c/CWpDEl++6T9LakKZKekvTtkn1flvS4pPclvSfpT5LWKSv7a5L+KekjSa+VPseStpD0d0kfSnqh\n",
+ "tOwqHtOE/DfcoGz7LXn71vn+YpIulTQpP4ZnJB1fcvysHFvp6+CYCte8XNIp1cbYQuxNr7+q3zsk\n",
+ "/bIsxhmSplQ4dglJD0p6Nz+3j0napeyYH+W/xwf5b7xOM+UMzde5smz7tyQ9l+O4U9KyJfsWk3SF\n",
+ "pMn5VijZt2Iz/3OzJH2/2uchhFA7kbx0LgMvAt9o2iBpfaB/3tfkSuAVYEVgcWAUMLmsrIG2Fy25\n",
+ "3dDCNSuS1Kd1D6HdPgJ+DRxb5fEXAYsBawGDgCObdkhaErgT+AXpeVoN+FPJuWOA5WwPAA4AzpO0\n",
+ "Zt73JDDc9iBgMPAYcGlJ2esAVwMnAgOADYB/5H29gVuAi2wPBPYGzi5PRlpg4Blg/5LrLQFsDrzN\n",
+ "nL/ZOcBCwFr5MewEPF9W1gZlr4P/V2UM7aVqD7R9SGmMwDXA9RUO/wg4CFg6P7djgeslLQIgaSfg\n",
+ "EGBL0t/8b6T/l3IXAI9Q8vqXNAw4lfQ8Lg68lGNpcg7QD1gJ2AQYJenA/BheLXsM6wOzgJuqfR5C\n",
+ "CLUTyUvnu4qSDy3Sh+pvmPvDYGPgctvTbc+y/S/b41t7IUmnkt7kz8/fFM/N22dJOkzSc6QPUSSN\n",
+ "k/Rq/rb7qKQtSsoZ2/QNtuSb9/6SXsk1IidVG5Ptv9u+mvTBMb/41wJ2BEbb/q+Tx0oOOQoYb/sa\n",
+ "25/Y/p/tp0uu9R/bn5Qc/xEwJe972/YbeXsv0gfRpJJjfwj80vYf89/gfdsv5n2DgSXIH5q2HwWe\n",
+ "Atau9nkAfgvsLanp7/4N4GagNN6NgWtsf5iv84ztVn9YShoN7Ascl18Hv8/bhyjV8L0t6UVJR5Sc\n",
+ "s0l+HXyoVKPVlBTdn39+kMvatJWxLAzsDlzR3H7bH+fH2VS7Mwt4F5iZD1kX+Ivtl23PIiWY5TVm\n",
+ "+wDvA/cw9//VDsANtp/Kr4tTgK0krVKy/yzbM2y/AlxCSqSacwDwZ9uvtubxhxBqI5KXzvcQMEDS\n",
+ "Wvkb/N6khKb8mAsl7a3clNSM+X7ztf0D4AHgu/kb45iS3TsDX2DOG/8jwOdItRu/BW6Q1LepqGaK\n",
+ "/xKwBvBV4OSmGo3cnPL+/GKr0iakGqgf5yTpcUm7lezfFHg/NzNMlnSrpBVKC5B0u6TpwATgINuT\n",
+ "SvatmGOdBmwPfKusbOVrvinpSkmD8r5JwOPAQZJ6S/oi6dv6X1rx2N4EJgLb5vujSElsqYeAUyUd\n",
+ "KGlohXKqeR1cRPqQPzO/DnbOicFtpBqnIaS/45GSvp5PGweck2s/VgWaava2zD+bav4ebnoeJS0/\n",
+ "v1hIicvbth9o6SBJjwPTgcuBXW03JS/3AJvnZqEFSEnEnSXnDQCKwPeZ97lx2bam97/1Si9dtr90\n",
+ "X9M1RPoC0mwCFkLoeJG81MeVpDe/bUgfYG+U7d+TlHT8CHgxt/tvXHbMu/kDo+m2JpU19wF3uu0P\n",
+ "bH8MYPvqXLswy/bZwILAmi2cX8zfkh8H/g18Ppfzl9wUUwvLkz48PgCWBQ4Hrih5rCuQPrzGkJrY\n",
+ "ypsBsL0DsAjp+b68NBnMTQGDgCXzY7i05NQVgJHAbsBQUtPeefk8A6NJH5IzgD8DJ5XU5FTrN8D+\n",
+ "uYZpMdsPle0/gpR0HA48mftqbFd2zD/LXgfbtHC90r/jF4Albf/E9qe2XyI15+2T988Ehkpa0vY0\n",
+ "2w83UwYw53m0/XoVj7mpprFFtjcAFiU1G93U1Gxk+xFS0vAMKencnVQD1+QU4Ne232TepHs8sKek\n",
+ "9SX1B07OxyxUsv94SYtIWp1U69K/mfC2AJYGbpzvow0hdIhIXjqfScnLfjTfZEROKk60vR6pieJf\n",
+ "wO/Kylkif2A03Z6ZzzXLvVZ6R9IxkiYqdYJ8HxhI+lCv5K2S36cBC7dwbFtNJzWjNH3A3g/cx5za\n",
+ "imnAzbb/kZOwIvBFSYuWFmL7M9s3Ag8Du5ZfxPb7wDHAjvmbe1PZl9l+3vb/gNOAEQCSlgNuB/a1\n",
+ "vQCpKeN4SSNa8dhMaib6CvBdmvlAz80Xp9vemNRMdT2pRmyxksM2LHsd3FXl9VcChpQmPqT+PUvn\n",
+ "/QeTataekvSIpO1b8dialRPHrakieQGwPdP2ecBU0vOEpMNJtUTLkxLsHwP3Suov6fN538+bLllW\n",
+ "3j3kZIiU6L6Uy25KusaQktHnSH2afsu8Xywg/d/eaHtaNY8jhFB7kbzUQW4nfxEYTvoAa+nY/wI/\n",
+ "I33QtKVGo1KH3dKOjFuSOtDuaXuxXBvxIa3olNlBHs8/m6v+L91frQWA/7WwbxbwcRVlfxF4vSlR\n",
+ "sP0s8AfS37NqtqeTmjwOoflOp6XHTgVOJyWJq7R0bKUiyu6/CrxUlvgMyDVV5KRtX9tLAWcCN+ba\n",
+ "ivYsQz+K3F+llef1ISWTANuR+gG9mWsJryA1da5DSoxWBl6VNAk4Gthd0qNNBdm+0PYatpch/e/1\n",
+ "AZ7I+963PdL2srbXB3qTEt7Z8nOwB9FkFEJdRfJSPwcDX8kfYHORdKakdSX1ybUIhwLP5RqC2YdV\n",
+ "eZ3JpFE4LVkU+JTUFNVX0smkETatUVU8SvqRkgVJWrCkb025P5M+ZE/Mz8WXgGHAH/P+y4BdJX0u\n",
+ "93/4EfCA7amS1pQ0PH8jX0DSSFIH2D/lOHaVtIakXpKWAs4G7mhqRstlf1PSKpIWAk4g9RGBNFJp\n",
+ "TaXh1pK0Gqmz57+re6rmchKwdXMdP5WGBG+c/yb9gO+ROqKW1rK15nWwasn9R4Cpko7Lz1FvSes1\n",
+ "NU9KGpmfF0iJrEnJ3Tv55/xeU83Zn9SHpSJJmyr1m+qb4zqeNAKoqUntcWAvSUvnv90oUgLyHGlk\n",
+ "2qqkvlufB35JSiq3zWUvmB+jci3QRcDPmzpES1pVaah2b0nDgW8DPykLcVfgPdsT2vD4Qwg1EslL\n",
+ "ndh+0fY/SzeV/N6fVG39PvACqf/FTmVFNI32aLodSfPGAXsozWXy8wrHjM+3Z4GXSc01pR+mLouv\n",
+ "uW/fhlSLI2lqhetA+nY8jfShskK+1uyRVJKekPQNANufkjoWjyD1e/kVMCrXdGD7PtKH/x+Y8+G8\n",
+ "b1NRQCFvf4vUGXf7kiRhuXzdKcA/Sc/1AbMfjH0ZqXnj4ZLnZEzeN5GUUF5A+mCfQGpG+HULj7tZ\n",
+ "tifZ/muF3bNISdQ7pOaLr+bHUNpc8e+y18HZFcq6BFgnNxHdnEfq7ED6kH8xX+Mi5iSt2wJP5L/l\n",
+ "OcA+uY/TNNJw4wdzWZtozhwoFTvsStqc1DF4niH9ku6QdEK+uyBwPmmE0avAVsB2tj/K+39CSt4e\n",
+ "J/3NvgfsbnuK0+i8t/NtMml02fRcewkpCbqa1FT0MPAgKeFt8n+53Cn5Me5r+6mycPdnPrVkIYSO\n",
+ "p9T3sA4XTqNCfkNqYzdpzoxzJS0OXEdqk38Z2Mv2B3UJMoQQQghdTj2Tl2WAZWz/K48k+AewC/BN\n",
+ "4F3bP81VxoNsn9BSWSGEEELoOerWbGT7Ldv/yr9/RJrkazlS80hTZ7grSAlNCCGEEALQRfq8SFoZ\n",
+ "2JDUDj04t1dD6q8wuE5hhRBCCKELqnvykpuMbgK+l4eDzpYnA6tPu1YIIYQQuqTOXpRvLnl4603A\n",
+ "lbabJmGbLGkZ228prfj6djPnRUITQghtYLtd8zfF+2/obM29ZuuWvEgSafjmRNulQ3hvJQ1ZPTP/\n",
+ "LJ9ZFmj/P2BnkDTW9th6xzE/EWdtRZy11QhxNkKMULvEoxHef0P3UOk1W8+aly+R1o55XFLTSsEn\n",
+ "AmcA10s6mDxUuj7hhRBCCKErqlvyYvsvVO5z87XOjCWEEEIIjaPuHXa7uQn1DqBKE+odQJUm1DuA\n",
+ "Kk2odwBVmlDvAKo0od4BVGFCvQMIoSep2yR17SHJ0eYaQgitU4v3znj/rZ28KO7FtteqdyzNkfQE\n",
+ "cJjt+2t5bCtjaPb1FslLCCH0EJG89Ax57rQXgT55HbOGVen1Fs1GIYQQuh1JNe3TWevyOknFJFNS\n",
+ "784MpNYieQkhhNAtSHpZ0nGSHgemSuolaTNJf82roP9L0tYlx68i6X5JUyTdJekCSVfmfStLmiXp\n",
+ "IEmvAHfn7QdJmijpPUnjJa1YUt45kiZL+lDS45LWzdtHSHoyX+d1SUfn7cMkvVZy/tqSJuRYn5C0\n",
+ "Y8m+y3N8t+dyHpK0aoWnoqnp5oN87GaSDpT0oKSzJb0LFCStKuleSe9KekfSVZIGlj2fX8m/j5V0\n",
+ "vaQrcplPSPq/Nh67kaTH8r7rJV0n6ZTW/K0jeQkhhNCd7AMMBxYDlgVuB35sexBwDHCTpCXysb8F\n",
+ "HgIWB8aSpu8o70uxFbAWsJ2knUlTeuwKLAk8AFwDIGlbYEtgqO2BwJ7Af3MZlwCjbQ8A1gXuLQ86\n",
+ "T9p6GzAeWAo4Arha0holh+2d4xwEPA+cWuE52DL/HGh7gO2H8v1NgBeApYHTSDUzp+bnaW1ghVx+\n",
+ "k/LnYsf8eAeS5mQ7v7XHSuoL3AJcmh/HNaQ1DFvVh6URq8FCCCF0USrWaCK8Qpv61Rg41/YbAJJG\n",
+ "AnfYHg9g+25JjwLbS5oAbAx82fanwIOSbmXeppaxtqfn8g4BTrf9TL5/OnBSrn2ZCSwKrC3p703H\n",
+ "ZDOBdSX9x/aHwGPMazNgYdtn5Pv3Sbod+AZQzNtutv1ovvbVwNkVnodKz92bti/Iv88gJTIv5Pvv\n",
+ "SjoHOLnCuQAPND2Xkq4CjmzDsZsBvW2fl+/fIumRFsppViQvIYQQaqaNSUctvVby+0rAnqXNL6TP\n",
+ "vXuBIcB7tmeUnbvCfMobJ+lnZccMsX2fpPOBC4CVJN0MHJPX7Nsd+CFwRm7SOqGkNmR2GWXXAngl\n",
+ "b4eUmE0u2TcdWITWmat8SYOBccAWpMSrF/BeC+eXXn8a0E9Srwqdgps9lvR43mgmrla9bqLZKIQQ\n",
+ "QndSWvPzKmntvEElt0Vt/xSYBCwuqX/J8Ssyr/LyRpeVt3BTImL7PNsbA+sAawDH5u2P2t6F1Bz0\n",
+ "O+D6Zq7zJrCCpNIP8ZWY94O+GpVqv8q3nwZ8BqyXm7pG0fF5wSRgubJtKzYTW4sieQkhhNBdXQXs\n",
+ "KOnrknpL6pc7yS5n+xXgUWCspAUkbQ7sQMsfor8kNROtAyBpoKQ98+8bS9o0912ZRmqW+SyXvZ+k\n",
+ "gbY/A6aSEoZyD+fzjsvnDMvxXJv3t6Zm4h1gFrDafI5bBPgfMEXScuRkq4P9jfS8HC6pT+5H9IXW\n",
+ "FhLJSwghhG7J9uvAzsBJwNukmpOjmfPZtx+wOalj7SnAdaT+KbOLKCvvd6RFg6+V9CHwH2DbvHsA\n",
+ "cBGp2eVl4F3grLxvJPBSPmd0vu5c17A9k9TJdTgp+TgfGGX72ZLjyhOrZhMt29NIHXEfzKOiNq1w\n",
+ "fhHYCPiQ1Fn4pkpltub6LR2bH+duwMHA+6Tn4nbmft7nKyapCyGEHqIW753d+f1X0nXARNvF+R4c\n",
+ "akbSw8CFtq9oZl9MUhdCCCE0yU09qynNBzMc2InUJyV0IElbSVomNxsdAKxHGiJetRhtFEIIoada\n",
+ "BrgZWII04uUQ2/+ub0g9wpqkTssLk4Zq72F7csunzC2ajUIIoYeIZqPQaKLZKIQQGoQkSaucXjZs\n",
+ "NoSQRfISQghdzmq7wXaHwWq71juSELqiSF5CCKGLkIaMltZ6EoadBhcOgGGnS2s9KQ0ZXe/YQuhK\n",
+ "osNuCCF0GZMuhv7vQe+fpTnJeveDT4+CSTfXO7IQupKoeQkhhC7CtkGGXovBXhNBg/LmxhtZEUIH\n",
+ "iuQlhBC6lL5D4a5vwg3rwd0HpvuhO5K0paSn6x1HI4qh0iGE0EPEUOmeQdLKwItAnworPremrMuB\n",
+ "12z/qP2Rten6MVQ6hBBCzyCppn06a11eJ+m2SWYkLyGEELoFSS9LOk7S48DUPO3/ZpL+Kul9Sf+S\n",
+ "tHXJ8atIul/SFEl3SbpA0pV538qSZkk6SNIrwN15+0GSJuYFD8dLWrGkvHMkTZb0oaTHJa2bt4+Q\n",
+ "9GS+zuuSjs7bh0l6reT8tSVNyLE+IWnHkn2X5/huz+U8JGnVCk/F/fnnB5Km5oUZWx27pNHAvqSV\n",
+ "rqdK+n17/j61FMlLCCGE7mQf0srMiwHLklYs/rHtQcAxwE2SlsjH/hZ4CFgcGEta/bm8L8VWwFrA\n",
+ "dpJ2Bk4EdgWWBB4ArgGQtC2wJTDU9kBgT9Jq1QCXAKNtDwDWBe4tD1rSAqSVnccDSwFHAFdLWqPk\n",
+ "sL1znIOA50krRzdny/xzoO1FbT/clthtXwRcDZyZy9m5wvU6XSQvIYQQakbCtbi18fIGzrX9hu2P\n",
+ "ScnIHbbHA9i+G3gU2D7XOmwMnGz7U9sPArcyb1PLWNvTbc8ADgFOt/1M7ktyOvD5XNZMYFFgbUm9\n",
+ "8jFv5TJmAutKGmD7Q9uPNRP7ZsDCts/I8dxHSry+UXLMzbYftf0ZKan4fIXnobnmorbGXqm8uork\n",
+ "JYQQQs3YqBa3doTwWsnvKwF75maY9yW9D3yJtCDjEOC9nJQ0d26l8saVlNVUszIkJxvnAxcAkyX9\n",
+ "StKief/uwAjg5dwstFkz1xnSzPVfydshJWalixdOBxZpppxK2hp7lxTJSwghhO6ktNbmVeBK24NK\n",
+ "bova/ikwCVhcUv+S41dkXuXljS4rb2HbDwHYPs/2xsA6wBrAsXn7o7Z3ITUH/Y60onK5N4EVytaz\n",
+ "Wgl4ozUPvpmY2xV7hbLqrq7Ji6RLcweh/5RsG5s7ND2Wb9vVM8YQQggN6ypgR0lfl9RbUr/cSXY5\n",
+ "26+QmpDGSlpA0ubADrT8Yf1L4CRJ6wBIGihpz/z7xpI2zX1XpgEzgM9y2ftJGpibe6YCnzVT9sP5\n",
+ "vOPyOcNyPNfm/a2pjXoHmAWs1p7Y83mTgUodg+um3jUvlwHlyYmBs21vmG/j6xBXCCGEBmf7dWBn\n",
+ "4CTgbVLtw9HM+ezbD9ic1IRyCnAdqf/H7CLKyvsdcCZwraQPgf8A2+bdA4CLgPeAl4F3gbPyvpHA\n",
+ "S/mc0fm6c13D9kxgR1Jn43dIzTijbD9bclx5YtVsomV7Gqkz74O5mWiTdsR+CbBOLqfLLFNR90nq\n",
+ "lCbTuc32+vl+AfjI9s9aOCcmSQohhFaqxXtnd37/lXQdMNF2sd6xhKTS663eNS+VHCHp35IukbRY\n",
+ "vYMJIYTQ/eTmktWU5oMZDuxE6pMSuriumLz8AliFNARsElCxBiaEEKolsZbEZRJTJM6SiC9GYRng\n",
+ "PlI/lHOAQ2z/u74hhWp0uemObb/d9LukX5Mm7ZmHpLEldyfYntCxkYUQGpHEhqQ+D1sD5wKbAEcB\n",
+ "z0j8GPiVzad1DLHD5E6fw+ocRpdl+3bSXCqhwXTFPi/L2p6Uf/8+8AXb+5ad023bXEMItSGxBSlp\n",
+ "+Rzw/4CLbT4q2b8BqWZ3OdLMq3faXXNYaK1En5fQaCq93uqavEi6hvRtaEnScKwC6VvC50m9qF8C\n",
+ "vmN7ctl58c8TQpiHhICvk5KW5UmjK66w+biF40eQkpvXgKNt/tPcsd1BJC+h0XTJ5KWt4p8nhFBK\n",
+ "ohewCylp6QecBlxfbXOQxAKkIawnA78HTrZ5q+WzGk8kL6HRRPISQmgYKmplYBvSHBxTgNfLbm+6\n",
+ "4Jk56fgGcALwEWlui9tsZrXpumIQ8APgQFKT0s9tprfnsXQlkbyERhPJSwihy1JRA4EvkxKWbUgr\n",
+ "At9NWvl2IVIT0HL55/J80m8Z/jF6Og8e14+FJ09hkwse5POXP0SvWaUJzhsuuE2Jh8RqpCanjUkr\n",
+ "8V7bXH8YDdYIBjCGvvRjJjOYwrme7Dvacs3OEMlLaDSRvIQQugwVtQCwKXOSlfWBh4A/AXcBj7vg\n",
+ "eWpPJBYFvgM+igWmPcGGl17LiDEf0JTUzH1bjjQEtrzWZq6bC/6o/Dol19sSOBv4FDjK5m+z9w3W\n",
+ "CJZnHDux+uwTbuV5Xud7XTWB6WnJi6TLgdds/6jesYS2ieQlhFA3Kkqkxd6akpWtSR3y78q3v7RU\n",
+ "SyKxODAG+C6pRuYMmxbn41BRvUiDAZpLbEpvM2kpwflw+Tc455UdoNdpwIPACTYva6jGM3L29Opz\n",
+ "XMV4P+fh1Twvna0HJi+XkZKXk6s4dgJpEcdL2nity6lBopRH4L4I9LHnTeB7mkqvty43z0sIofE0\n",
+ "13zCYfwd+CpzEhaREpVrgW+7MGdOp4rlimVJc7IcBNwCfNHmuWpiyjU3b+fbP5stPyVVg5g3ofni\n",
+ "7N8Hvr4CY3uLmQu/wT2nfoHHDnpaa9/zDwb2Htzs+np96T/vxp4hrYi88mnw8klu4zfjWpRRXmSV\n",
+ "x3W1b/INkSDWSyQvIYR2abb55C6G8RKfsgr3kZqCzgKecaG6DyOJVYBjgX2AK4HP27xW69hzPO/l\n",
+ "2+MV4ylqAH3/tzzDj1yeda9fj7vOHMlHW64CE+Y9eGb36eDbeqvtBtscBnf9HWjjIn5tL0PShqSF\n",
+ "BFcH7qAkIZE0iPRa2oT02fcgaUbdNySdCmwJbCbp58BltsdIGgfsCgwEngOOtP2XZq47GtgXsKQj\n",
+ "gXtt7yxpCHBeLvsj4Bzb5+VzNgEuBIYC04GrbB8D3J+L/UASwNdsP9ya56FHsN1wtxR2/eOIW9wa\n",
+ "8cbSjGB1xrMOE1id8SzNiHaVtzrjGYvnuQ1lfKvLwmuDfwN+F3wqeOl6P18VYx2w8+Gst9y0uR7z\n",
+ "Rjzf3uezQ2OuwXtnc2XAsqNhzSfh4GdgltPPNZ+EZUdXX277ygD6Aq8A3wN6A7uTmgR/nPcvTkpE\n",
+ "+gGLANcDt5Scfx9wUFmZ+5Fq5nqRagAnAX0rXP+ypmvl+72AfwA/JCVLqwAvAF/P+/8G7Jd/XwjY\n",
+ "NP++EjAL6FXv10tXuFV6zUbNSwg9SIVOpqtpsGhLJ1MV1ZclWLfZnQvQr+pyxP+R5mjZAhgHjGFp\n",
+ "fZEB/Ebrds2RPP7wd+drqd4vcvlyp6AV1uYT/4+pi/0/fzC+y8TYeSZdDP3fg94/S60dvfvBp0fB\n",
+ "pFbUnLS7jM1I/UTG5fs3Sfp7007b75GaHgGQdBpwb1kZczXV2L665O7Zkn4IrAkVJzIsPf8LwJK2\n",
+ "f5Lvv5SXvNmHVBs5ExgqaUnb7wIPN1NGqCCSlxB6kgGMmStxAdiJ1bmKI0jV7FVTUauS+q8s2OwB\n",
+ "VTSfSGxFSlrWJc1yO8pmWq2TrDnXq21/Cr/z2R3AHRJ9gUOBH+dlB8bazLdPT3dh29Lqhl6LwV4T\n",
+ "YfEV8uaqn+MalDEEeKNs2yvkZEDSQqTFF7cl1aYALKLcI7QpjNKTJR1D6m81JO8bQOoEXo2VgCGS\n",
+ "3i/Z1ps5zUIHAz8GnpL0ElC0/Ycqy+7xuuKq0iGEjtK3Qm1IKzuZqqg9SUObf8tLHMitPD/XAbfy\n",
+ "AlM4r9lzhSSGSzxA6p9wA7C6zTibaUDlJGsAR7Qmznmtthtsdxistmv7ypmbzUybccBawMfARInj\n",
+ "pOprnxpf36Fw1zfhhvXg7gPT/U4tYxJpeHyplZiTkBxNGvG2ie2BpBFvYk5NR3nisiWp39Wethez\n",
+ "PQj4kMo1I+VJ1qvAS7YHldwG2N4BwPbztve1vRRpTqEbJfVvppzQjKh5CaEnmcmMCtur6mSqovqT\n",
+ "5j3ZBhjhgh+lABosuIoj6Et/ZjKdKZxXXkMi0RvYjVTT0ps0hf+Nbm4K/xolWXOuPWQ0DPgeDOsD\n",
+ "Fw6Ab58urXUKTBlnv3lRW8psjs17wPclfgH8FDhE4njS4+zWH0r2xDNK7raps247y/gr8KmkMcAv\n",
+ "gB1JTTf35P2LkDrGfihpcdJaeqUmA6uV3F+UNL/Pu5L6kmZxHtDC9ScDq5bcfwSYKuk4UqfdmcDa\n",
+ "QD/bj0oaCfzR9jukpMikvi7v5J+rQXUj63qiqHkJoSeZwrmtqSUppaLWItW2DAL+zwU/2rTPk32H\n",
+ "n/NwP+lhfs7DSxMXiQUkDgSeJH37PRn4nM21zSYu0O4ka16TLoZPCqkfxez+FCen7bVn86zNLqSm\n",
+ "gZOAv0hs0hHXContT0jJ8YHAf4G9gJtKDvk50B94l5To3MnctRzjgD0kvZdHHI3Pt2eBl0mJz6st\n",
+ "hHAJsI6k9yXd7DRHyw6khYZfJCUlFzEnAdoWeELSVFJz1j62P7Y9jbTMxYO5rHjdNCMmqQuhh8lz\n",
+ "srRYSzLPOUUdQOqTchLw62qGPEv0J/UXOI70DfI04L5qaiAq9Hl5gdcZ09Y+L9Lqu8M2l8J/X0/9\n",
+ "Ke4+0H6+jcN5W3NdegOjSB9IE4AT7RY/BDswlp41SV1ofDHDbgih1VTUIsAFpOr3vV1wpVEWc84R\n",
+ "A0idV48kjaA43abV81S0JclqOa51ToCZz8ILt6Q+L32H2hPPbGt5rb8+i5D6UBwO/JI0S/DUzrp+\n",
+ "iiGSl9BYInkJIbSKitqANBfGX4EjXPD/WjxeLEmawv9Q0lDQM+yKQ0p7LInlSbVQXyM1oV1mNzdV\n",
+ "b0dcO5KX0FgieQkhVCVPmf8d4BTg+y74qhaPF0NIfVm+CdwInGnzQocH2uAkNiZ1fl6MtOjj3R1/\n",
+ "zUheQmOJtY1CCPOlohYDLiZNr/4lF/xsxWPFqsDxwJ7A5cAGNq93Rpzdgc2jEluTZn39lcRE4Fib\n",
+ "p+scWgjrXyJhAAAgAElEQVRdXow2CqGLkyRpldOVFzrpsOsUtQlpAcPJwOaVEheJ9SSuIg0FfRtY\n",
+ "0+aoSFxaL890fjOwDml6+gckzstNcCGECiJ5CaHL65iJ1ZqoqF4q6mjgduAYF3y4C55nqLLEFyRu\n",
+ "Ae4GngBWtfmRzTsdEVdPYvOxzdmkeUAAnpI4Woqp4kNoTvR5CaGLmjOx2hZ94OI14NvPwl8+reXE\n",
+ "aipqSVKTz5LAPi745bljQKSZSH9AWtPlLOCS2TPhhg4hsRawvc3Paltu9HkJjSX6vITQcGqx2F1l\n",
+ "Kmor4Grgt8APXfAns/elpGV70rwuSwBnAFfbzKzFtUPLcr+X6PsSQgWRvITQRdVisbvm5NFEJ5CG\n",
+ "NR/kgu+cvS9NqLYHKWkxaUjvTZ01lDeEWpJ0OfCa7R/VO5ZqSNoP2N/2trU8tjuK5CWELq1pobo5\n",
+ "E6u1pzQV1Qs4F/gisLELfgMgr4o8ijR66B3gRODO7r4eT+j2TJULHUqaAFxp+5K2XKgWiZLtq0m1\n",
+ "oTU9tjuK5CWELqwWi901UVELkPq3LA982QV/KLEQ8C3gGOAp4NvA/ZG0hNbKMyKPoS/9mMkMpnBu\n",
+ "a2dErkUZzRVb5XEd+pqX1Md282t5hVaL0UYh9AB5NehbSIvCbcdYI3EiacG4YcDuNtva/DkSl9Ba\n",
+ "s9eiGsm27MXWjGRblmecBmtEp5YhbSjpn5KmSLoW5qxOLmmQpNslvZ0XX7xN0nJ536nAlsD5kqZK\n",
+ "OjdvHyfpVUkfSnpU0hYVrjsa2Bc4Lp//+7z9ZUnHSXqctMJ0b0knSHo+x/ikpF1KyjlQ0gMl92dJ\n",
+ "+o6kZ/Mijee3cOzXJT0j6QNJF0j6s6SDq33uGk0kLyF0cypqIPBH4AMu/PdoxvoHwAukuUW+arOb\n",
+ "zd/rGmRobAMYM9cimgA7sToDOKKzypDUF/gdcAVp5fMbgN2ZU6Mi0srPK+bbdOB8ANs/AB4Avmt7\n",
+ "Udtj8jmPAJ/L5f0WuCFfZy62LyI14ZyZz9+5ZPc+wHBgMdufAc8DW9geABSBqyQNbuGhbQ9sDGwA\n",
+ "7CVpnj4ukpbMj/d4YHHgGWBzOrg2qZ4ieQmhG1NRSwP3MXm95xn72bu8vcGTpGHRm9iMsnmyziGG\n",
+ "7qDvnBqOsu39O7GMzYA+tsfZ/sz2TTAnKbf9nu1bbM+w/RGpM/rWZWXM1cRk+2rb79ueZftsYEHS\n",
+ "lAGVlDdRGTjX9hu2P85l3mj7rfz79aQV1zdtocwzbE+x/RppIsPPN3PMCOAJ27/LsZ4LvNVCmQ0v\n",
+ "kpcQuikVtSLvrP0Ql91nfvH4LtDrU2A9m0NsXqx3fKEbmck8kxrm7dM7sYwhwBtl214hJxSSFpL0\n",
+ "q9yU8yHwZ2Bg2czVc9VUSDpG0sTcFPM+MBBaPfvxa2Vl7i/psdwM9D6wHmk6gkpKk5BpwMLNHDME\n",
+ "5pnhulvPeB3JSwjdkDY9f0euu/EpfvXo0rwy7HbQUJtjbN6sd2yhG5rCudzK83Ntu5UXmMJ5nVjG\n",
+ "JGC5sm0rMSchORpYA9jE9kBSrYuYU1tSnrhsCRwL7Gl7MduDgA+p3AG4UhPN7O2SVgIuAr4LLJ7L\n",
+ "fKKFMqv1JqkjftN1VHq/O6rraCNJl5La8962vX7etjhwHelF9zKwl+0P6hZkCA1EYjMWeudMtOcW\n",
+ "LP/QDXy60LdtptY7rtC9ebLv0GDBVRxBX/ozk+lM4bzWjBSqQRl/BT6VNAb4BbAj8AXgnrx/EVI/\n",
+ "lw/z50yh7PzJwGol9xcFPgXezf1cTiB1eK9kMrDqfGJcmJTMvAv0krQ/qealWqXJVqk7SJ2Ndwb+\n",
+ "ABwCLNOKchtOvWteLgO2K9t2AnCX7TVIL7oTOj2qEBqIhCS+KnEPfab/jq1O3YjvbLSPn955n0hc\n",
+ "QmfxZN/h5zzcT3qYn/Pwtgxxbk8Ztj8BdgMOBP4L7AXcVHLIz4H+pMThr8CdzF1bMg7YI49E+jkw\n",
+ "Pt+eJX2Rng682kIIlwDr5OagZqc1sD0R+BnwN1Jz0HrAX0oPKYupvDandP/s322/S1rd/af58a0N\n",
+ "PAp83EK8Da3uaxtJWhm4raTm5Wlga9uTJS0DTLC9Vtk5sbZG6PEkegE7kGbDXYx1rxvPbqP2pfcn\n",
+ "e7vg++ocXuiCYm2jnkFSL1Jfm31t/7ne8bRHI61tNNj25Pz7ZKClIWQh9DgSfUjfsk4CPgFO5Qf9\n",
+ "F2aBGT8FtnfBMew5hB5G0tdJQ7unk/rqADxUv4g6VldMXmZLa7uo2aohSWNL7k6wPaFTggqhTiQW\n",
+ "BPYnzeUwifQG9UfG6gjSDLlfccET6xhi6GIkDSNNQhi6v81Jc9H0BZ4Edmkant0dddVmo2G235K0\n",
+ "LHBfNBuFnkxiYdK0/ccA/wFOs3kgL7B4MrAfsI0LfqWOYYYGEM1GodFUer3Vu8Nuc24FDsi/H0Ca\n",
+ "MTGEHkliKeAfpKnLd7YZnhOXXqQOiLsAW0biEkLoSepa8yLpGtJY+yVJ/VtOBn4PXE+avvllmhkq\n",
+ "HZl/6AkkFiXNqHmnzeyVavMCi5cAqwA7uhBTCYTqRM1LaDSVXm91bzZqi/jnCd2dRD/SfA3PAYc2\n",
+ "LZaYF1i8jtRfbQ8XPK1+UYZGE8lLaDSRvITQICR6k2ofZwH72HwGoKIGkJpVJwEHuOCZ9YsyNKJa\n",
+ "JS+1iieEajTKUOkQGpIGawQDGENf+jGTGUzh3NZO1CUh0uygA4AdShKXpUiTaj0CHOGCP6t1/CFU\n",
+ "I744hq4gkpcQakCDNYLlGcdOrD57462spsGilQnMT0irxn7VTrNjqqgVgLuAG4EfudCA1aUhhFBD\n",
+ "0WwUQg1oqMYzkm3n2XEV4/2ch1dVhjiStCbJFjbvAqioNYE/Aue64LNrGHLogeK9M3QXUfMSQi30\n",
+ "pV+F7f2rOV1iFHAUcycuG5E67f7ABV9ao0hDCKHhRfISQi3MZEaF7dPnd6rE9sBZwJfttPCbitqK\n",
+ "1Ex0iAtudpG3EELoqbriJHUhNJ4pnMutPD/Xtlt5gSmc19JpElsAl5MmoHsKQEVtT0pcvhGJSwgh\n",
+ "zCv6vIRQI3m00RH0pT8zmc4Uzmups67EBsDdwEibPwGoqP2As4GdXPDDnRN56CnivTN0F5G8hFAH\n",
+ "EqsCDwBH2VwHoKK+C5wAbOeCn6xnfKF7ivfO0F1En5cQOpnEMsCfgFNtrssLLP6QtJbXVi74pboG\n",
+ "GEIIXVwkLyF0IomBwHjgSpsL8wKLPwO+Amzhgt+qa4AhhNAA5ttsJGkJ2//tpHiqElWfoRFJ9Ccl\n",
+ "Lo8DYxir3sCvgaHADi74/XrGF7q/eO8M3UU1o40eknSDpBGS4kUfQhtI9AGuBd4AvsdYLUgaUbQM\n",
+ "8PVIXEIIoXrVJC9rAhcD+wPPSzpd0hodG1YI3Uder+giYEHgQMZqYeAO4GPSqKL/1TO+EEJoNK0a\n",
+ "bSTpK8BVwMLAv4ATbf+1g2JrKY6o+gwNQ+KnwJbA1xir/qQFFv8JHBYLLIbOFO+dobuYb4ddSUsC\n",
+ "+5FqXiYDhwO3AZ8jVXuv3IHxhdDQJI4Ftge2ZKwGkUYZ/R44KRZYDCGEtqlmtNFfSbUtO9t+vWT7\n",
+ "o5J+2TFhhdD4JL4JfBfYgrFagrQy9AUu+Kz6RhZCCI2tmtFGvWzP6qR4qhJVn6Grk9gZ+CWwNWO1\n",
+ "EKmPy8ku+Nf1jSz0ZPHeGbqLmGE3hBqT2Bq4ARie+7jcTOrfcmN9Iws9Xbx3hu4ikpcQakhiQ+CP\n",
+ "wD6MVT/gCmA/F/yn+kYWQrx3hu5jvkOlJW3RzLYvdUw4ITQuidWBPwCHMlaDgctIQ6EjcQkhhBqq\n",
+ "ps/LY7Y3nN+2zhTfHkJXI7Es8CBwOmPVB/gBMNwF/6e+kYUwR7x3hu6i4mgjSZsDXwSWknQU0PSC\n",
+ "X5TqJrcLoUeQGERqKvo1YzUAOIy0wOKL9Y0shBC6p5aGSvclJSq9888mU4A9OjKoEBqFxEKkeY/u\n",
+ "4eQ+TwPjgM1dmGtagRBCCDVUTbPRSrZf6aR4qhJVn6ErkFgAuAV4n5MWPoe+0/4IbOeC/1Hn0EJo\n",
+ "Vrx3hu6imknqLm9mPUbb/koHxBNCQ5DoBVwKwKHrn0jfaQ+ShkNH4hJCCB2smuTl2JLf+wG7A592\n",
+ "TDghdH15ocWfAauw6bgdGfzEncClLviGOocWQgg9wnyTF9uPlm36i6S/d1A8ITSCE4Gv0nfK1gw/\n",
+ "8nzgFeDHdY4phBB6jGoWZly85G4vYGNgQIdFNOe6L5M6B38GfGJ7k46+ZgjzIzEa+BawBScNPBRY\n",
+ "A9g6FlkMIYTOU02z0T+BpjfmT4GXgYM7KqASBobZfq8TrhXCfEnsDhRI6xVtChwKbOaCp9U3shBC\n",
+ "6FmqaTZauRPiqKRir3gN1XimcK4n+47ODCj0TBJfAX4BfJ2xWgS4iDQJ3Rv1jSyEEHqeapqN+pMm\n",
+ "3dqCVBvyAPAL2zM6ODYDd0v6DPiV7Yvn2juSbbmV1TRYRAITOpLExsC1wJ6M1VvAw8B3XZinP1gI\n",
+ "IYROUE2z0W9IfU/OJdWE7AtcCezZgXEBfMn2JElLAXdJetr2A7P33gcsyup8zDhJ02xP6OB4Qjcj\n",
+ "SbDyafDySa4w4ZHEmqRJ6L7NWD1MeuVd5oKv78xYQ2gLScOAYXUOI4SaqyZ5Wdf2OiX375U0saMC\n",
+ "amJ7Uv75jqRbgE1ItT7Jl/PPd3jDH0TiEtpitd1gm8Pgrr8DN5fvlVieNO3/SYzVraRE/jViZFFo\n",
+ "EPlL3YSm+5IKdQsmhBqqZo2if+Z1jgCQtBnQoRNxSVpI0qL594WBrwPNL3A3k+kdGUvofqQho6W1\n",
+ "noRhp8GFA2DY6dJaT0pDRs85hiVIicsFNpcBxwNrAwe64Fl1Cj2EEALV1bxsDDwo6TVSP5QVgWck\n",
+ "/Yc00+4GHRDXYOCWPLNvH+Bq23+a56hbeYEpnNcB1w/d2qSLof970PtnqSW0dz/49CiYdDOAxMLA\n",
+ "7cAfbM5SUTsDhwObxsiiEEKov2qSl22Zd9SPm9lWM7ZfAj7f4kF3M5MPOTE664bWsm1pdUOvxWCv\n",
+ "ibD4CnmzJfoCNwFPAcerqM8BvwZGxMiiEELoGqpJXn5ie1TpBklXlm/rdF/jWmBdIKZkD23Qdyjc\n",
+ "9U144RZYbVfoOzSvV3Q5MAMYzVgtDdwKHOGCY1bpEELoIqpZVfox2xuW3O8DPF7WibdTSTJjWZ00\n",
+ "ZHUNF2Iiu9A+eb2ic4ENgO0YKwP3Ane54OjkGLqFWFU6dBcVO+xKOknSVGB9SVObbsDbpG+jdeWC\n",
+ "XwBuAY6pdyyhW/gRaS6jnRirGaRJ6N4AinWNKoQQwjyqqXk5w/YJnRRPVZq+PaioFYHHgLVc8Dv1\n",
+ "jis0JolDgaOBL9lMVlHHA3sBW0YH3dCdRM1L6C6qSV62Zs7aRrPZvr+jgpqf0n9AFXU+MMMFRw1M\n",
+ "aDWJvYCzga1sXlRROwEXktYser2+0YVQW5G8hO6imuTlduYkL/1Ik8X9w/ZXOji2lmIqTV6GAE8A\n",
+ "67ngN+sVU2g8EjsAlwDb2DyuojYA7gG2d8GP1De6EGovkpfQXcx3kjrbO9jeMd+2AdYDPuj40KqT\n",
+ "E5bLgRPrHEpoEBILSJwB/BLYOScuTSOLxkTiEkIIXVs1M+yWe50002hXcgawX+4DE0JFEquQlplY\n",
+ "H9jQ5iEVtSBpeYArXfA1dQ0whBDCfFWzqnTpDLa9SJPHdejyAK3lgt9WUb8CfgB8p97xhK5JYm/g\n",
+ "POB04Oc2VlECfgW8BcSQ6BBCaADVTFL3D+b0efkM+K3tBzsupDb7f8AzKupMF/xivYMJXYfEQsA4\n",
+ "0uq6w+25ku9jSHO7bBlrFoUQQmOopsNuf2B1UgLzvO0ZnRFYSyp1OlNRRWAlF3xg50cVuiKJ9YFr\n",
+ "gX8Ch9lMnb2vqB1J/V42c8Gv1SnEEDpNdNgN3UVLk9QtIOmnwGvAFcBvgNclnSVpgc4KsJXOAbZX\n",
+ "UWvWO5BQXxLK87fcC5xpM6oscVmfNNJot0hcQgihsbTUYfcsYHFgFdsb2d4IWBVYjNRE0+W44A+A\n",
+ "nxN9F3o0iUHAjcC3SRPP/Wau/XNGFh3pgh+uQ4ghhBDaoWKzkaTngTXsufsBSOoNPGN79U6Ir1kt\n",
+ "VX2qqEWB54GvuuAnOjeyUG8SXwKuBn4HHG/z8Vz708iie4AJLviHdQgxhLqJZqPQXbRU8zKrPHEB\n",
+ "sP0Z0GU7NrrgqaRao7F1DiV0IoneEj8EbgIOtzmymcRFpD4ubwMn1yHMEEIINdBS8vKUpAPKN0oa\n",
+ "BTzdcSHVxIXAF1XUhvM9MjQ8iSHAXcDXgP+zub3CoUeThvqPipFFIYTQuFpqNlqeNHHXdObM6/J/\n",
+ "wELArnb91n2ppupTRY0BtnHBO3ZSWKEOJLYndby9ADjN5rNmjytqB9J8LjGyKPRY0WwUuosWh0pL\n",
+ "EvAVYF3SUOmJtu/ppNgqqjJ56Qc8B+wRnTK7H4kFSZPN7Q6MtHmg4rFFrUcadbSTC36ok0IMocuJ\n",
+ "5CV0F/Od56UrqvYfUEUdAuzqgrfthLBCJ5EYSpq75VXgYJv3Kh5b1FLAw8CPXPDVnRRiCF1SJC+h\n",
+ "u2jL2kaN5FJgDRW1Rb0DCbUhMRL4K+lvu9t8Epe+pA6810TiEkII3Ue3rnkBUFHfBA4AvuxCAz7Y\n",
+ "AIDEIqR+LZsA+9j8u8Xj08iiS0jzEu0RHXRDiJqX0H1095oXgCuBIaS+O6EBSWxEmt7/E2Dj+SUu\n",
+ "2VHARsD+kbiEEEL30u2TFxf8KVAETsnfxkODyFP8fw8YD5xs8y2b/833vKK2Jw2L3skFf9TRcYYQ\n",
+ "Quhc3T55ya4FBgLb1TuQUB2JJUlT+O8HbGZzbVXnFbUucBmwuwt+tQNDDCGEUCc9InlxwZ+RZtz9\n",
+ "cdS+dH0Sw4DHgKeALWxerOq8opYEbgOOcsF/67gIQwgh1FOPSF6ym4AFgJ3qHUhonkQfiR8DvwW+\n",
+ "ZXOczcyqzp0zsug6F3xVR8YZQgihvnpM8pI7bZ5Mqn3pMY+7UUisANwHbA5sZPPHqs9NtWkXAu8D\n",
+ "P+iYCEMIIXQVPe1D/DbgY2CPegcS5pDYBXgUuB3Y1uatVhZxJLAxMDJGFoUQQvfXJZMXSdtJelrS\n",
+ "c5KOr1W5eZ6Xk4GxKqp3rcoNbSPRT+IC4GxgZ5sz7datWK6ihgPHEiOLQgihx+hyyYuk3sD5pJFB\n",
+ "6wDfkLR2DS/xR1LzwjdqWGZoJYm1SdP2L0VqJqq45pAGa4SGarzW1QQN1XgN1ggAFbUOcAUxsiiE\n",
+ "EHqULpe8kGZQfd72y7Y/IQ1z3rlWhefalx8CBRXVp1blhurkuVsOBu4nJal723xQ8fjBGsHyjGMk\n",
+ "27IXWzOSbVmecVpT+5CaAY+OkUUhhNCzdMXkZTngtZL7r+dtNeOC78vX2L+W5YaWSQwkjSQ6Etja\n",
+ "5mKblpdsGMAYdmL1ubbtxOoswQXADS74yo6KN4QQQtfUFWseqlp/SNLYkrsTbE9o5XV+BFytoq5y\n",
+ "wVUNxw1tJ7EJcA3wJ2ATm+lVndiXfs0XiIGTahVfCN2RpGHAsDqHEULNdcXk5Q1ghZL7K5BqX+Zi\n",
+ "e2x7LuKCH1RRTwMHA79oT1mhMolepKn6jwEOs7mpVQXMZEaz29/lsRhZFELL8pe6CU33JRXqFkwI\n",
+ "NdQVm40eBYZKWllSX2Bv0jTxHeFk4Acqqvlv96FdJAYDdwC7kGpbWpe4AEzhXG7l+bm23cYrfMA5\n",
+ "NQkyhBBCw+lyyYvtT4HDSaOCJgLX2X6qQ65V8COk1Yq/0xHl92QS25Cm+H+U1L/llbaU48m+g9f5\n",
+ "HtfzIPfyCTfyMK9xmCf7jpoGHEIIoWHIrqqLSZciybZrskaRivo8cCewugue74rFoWUSCwCnACOB\n",
+ "/W3ubVd5afbcbwGnA991wde1P8oQeqZavneGUE9dsc9L57qQIayCMI/rKj3HFM6Nb/VtI7EKqVPu\n",
+ "f4ENbd5pV3lpocWLgVWArVzwxPZHGUIIodF1uWajzjR7DpHhDGYEqzKSbVmB85smQQvVk9iLNOnc\n",
+ "dcCONUhctgH+BTwPbBqJSwghhCY9utlIQzWekWw7z47beZkd2NwFt3aNnR5HYiHg58CXgX1s/tGu\n",
+ "8opaEDiN1FH7QBd8d/ujDCFANBuF7qNH17xUnEOkDwsAE1XU2Spqmc4NqnFIrA/8HehPmuK/vYnL\n",
+ "usAjwMrA5yJxCSGE0JyenbxUnkPkP8B6QG9SEnOOilq2M0PryvIU/4cC9wJn2oyymdrm8oqSijqc\n",
+ "NB/FOGAPF/zf2kQbQgihu+nZzUZNfV5Kp5+/lRd4nTFNnXZz0nIccADwG+BMFzypvdduVBKDgF+T\n",
+ "OtHuY/Nsu8orajBwKWmBxv1c8HPtjzKE0JxoNgrdRY9OXiAnMAM4gr70ZybTmcJ5zY02yknMscCB\n",
+ "wJWkJObNWsTQKCS+BFwN/A443ubjdpVX1PakROgSoOiCP2l/lCGESiJ5Cd1Fj09eWn3t1AfmWOCb\n",
+ "wFWkJOaNesTSWSR6AyeSJg/8ts1t7SqvqP7AWcAOwP4u+P72RxlCmJ9IXkJ3EclLW2NIzR3HAgeR\n",
+ "Vko+wwXPswZTo5MYQkrSegH72bQrUcuTAv6WNAz6MBf8QfujDCFUoyu8d4ZQC5G8tFNOYo4hLfB4\n",
+ "DSmJea2+UdWGxPakJp0LgVNtPmtzWUX1Ao4ETgC+74Kvrk2UIYRqdaX3zhDaI5KXGlFRSzMnibkO\n",
+ "OL1RkxiJBUnT8e8OjLR5oF3lFbUccDmwEDDSBb/U7iBDCK3WFd87Q2iLnj1UuoZc8Nsu+DhgLWAq\n",
+ "8C8V9QsVtWKdQ2sViaHAX0mjiTasQeKyK2nxy/uBrSNxCSGE0F5R89JB8ro8RwOjgRtINTFtWlm5\n",
+ "s0iMBM4BxgIX2rT5xaGiFsllfYU0BPqhmgQZQmizRnjvDKEakbx0sJzEHAV8B7gROK2rJTESiwAX\n",
+ "AJsCe9v8u13lFfU5UsL2IDDGBbd5ArsQQu000ntnCC2J5KWTqKglSEnMIcBNpCTm5boGBUhsBFwL\n",
+ "PACMsflfu8or6qukjsvfc8HX1CDEEEKNNOJ7ZwjNieSlk+Uk5vvAocDNpCSm0/uBSAgYA/yQlLS0\n",
+ "O9FQUfuSmor2cMHt6isTQqi9Rn7vDKFUJC91oqIWZ04S83vgVBf8YqdcWyxJmpJ/GeAbNi+0q7yi\n",
+ "ROrfMwYY7oKfbH+UIYRa6w7vnSFAJC91l5OYI4HDgFtJSUy7kokWryeGkZY3uAb4oc3MdpWX5m/5\n",
+ "GfA1UuLS7SbqC6G76E7vnaFni+Sli1BRg4Dvkabgv42UxDxfs/JFH+Bk4FvAN23+2O4yi1qQtFjl\n",
+ "MsDOMVtuCF1bd3zvDD1TJC9djIpajJTEHAHcDvykvUmMxAqkKflnAKNs3qpBnANJCzS+C4xywTPa\n",
+ "W2YIoWN15/fO0LNE8tJF5SRmTL79gZTEPNfqcsQuwK9IHWl/ajOrBrEtB9wJTCBN9d/mZQNCCJ2n\n",
+ "J7x3hp4hkpcuLtdwNCUxd5KSmGfne57oR+qLMoLUKbcmk8SpqLVzHBcCZ7nQgC+gEHqonvTeGbq3\n",
+ "SF46SJ5m/xJS59gbbNrVHyQnMUeQmpTGk5KYZypce23S3C3PAKPbe+2SGLYgzVFzjAu+shZlhhA6\n",
+ "TyO8d4ZQjUheOohEX2A4MArYBriLlMjc2Z4RPipqAHOSmLuAU1zw0/maAr4JnAmcBPy6PVP8l113\n",
+ "V1Lz00gX/KeKxw3WCAYwhr70YyYzmMK5nuw7ahFDCKF9GuG9M4RqRPLSCSQGAXuQEpm1SVPnXwk8\n",
+ "1NbkIicxh5OGWd/N89uew1XjjwLWI03xP7EmwadrHfr/27v3GDvKOozj36cta6uAl4i12sZiWxOr\n",
+ "IigaFS+LBq1Ei/WClhAUDUpUaBRvQOK6oAIaUajRCN5iKog3pCgWi7QRrVYJbUELQpEqSL2itkRq\n",
+ "AR//mKGebvfsnt3u7szseT7JZufMmZ19dpuZ/vZ9531fisnsXu0+39D2uJk6mtlcwGLm7965ki3c\n",
+ "xbIUMBHVa9q9M6KdFC8TTOJg4DiKQmYasAJYYTOqEUXq1wFsOv4c1px1MjM33cGRfcf685s2jEnW\n",
+ "YvK5jwJvABYNN4meFmgVx/OKvd5YwSrf5leORaaIGL0m3zsjWk2rOkC3sbkD+JjEx4HDgeOBn0n8\n",
+ "jqI15jKbv3dyLokp4JOBY9l/25tZumQ2sEr9WkPRnTTqmW7Vr/2Ai4CFwBHu81+H/aIeprfZP2O0\n",
+ "OSIiIgaaUnWAbmVjm1/ZLANmA2cDLwJ+J3GFxOvLEUODkpgJXAW8BniOd8z6uvt8HjAPuAG4Vv26\n",
+ "TP16+kizqV/7UyxZcBDw0o4KF4BdDD7Xyy7uG2mGiIiIdmpXvEj6iKS7JG0oPxZVnWm82dxvc5XN\n",
+ "UmAOcDnFmkd3S1ws8eKilaUgcRSwAbgeeInN73efq8/3us+foChirgeuUb++2WkRo349DlgDbANe\n",
+ "4z53vsr0di5k5YDur5XcznaWd3yOiIiIYdTumRdJfcAO2+cPcUxX9NtKzOb/z8ccAHwd6AGWAifY\n",
+ "XDvsOfr1CIpC6H3AdcBZ7vNNbY6dB1xdfp+PjGYOl3K00Sn0MINd3Md2ludh3Yh66JZ7Z0x+dS1e\n",
+ "7rX9qSGO6aoLsBwCfQhFEXMQ8D6bzrpyHjpHUcScTFHErKMoYja1vH84xcKQ/e7zF8Yqe0TUR7fd\n",
+ "O2PyqmvxciLwL4puj9PsPRf8ywU4eurXw4F3AB8Afg6cRbGw4teAk9znKyqMFxHjKPfOmCwqKV4k\n",
+ "rab4D3OgM4FfwO5WhbOBWbbfNuDra38BShLM/ThsPcN1qxDZXcS8naKImQoscZ/XVZsqIsZTE+6d\n",
+ "EZ2oXctLK0lzgSttP2PAfgP9LbvW2l47ccmGJ81/HRz1ZVh9or3lu1XnaUf9mgE8zH0ekyUEIqI+\n",
+ "JPUCvS27+lK8xGRQu+JF0izb28rt9wDPsX3cgGNq+9eD9IS3w4HL4IXT4OKnwEm3wk8fgO0X2Hdf\n",
+ "VGNvMfYAAAgNSURBVHW+iOhedb53RoxEHSepO0/SoYCBOyiez2iQbRfDjHtg6qdAwNTp8MB7YVtt\n",
+ "W18iIiKapHbFi+0Tqs6wL2xbmm+Y8ig4djM8Zk65u15NXBEREQ1Vu+JlcuhZAKtPhNsvh3lLitcR\n",
+ "ERExFmr3zEsn0m8bETFyuXfGZFG75QEiIiIihpLiJSIiIholxUtEREQ0Sh7Y7WLlIoqn0sN0drGT\n",
+ "7VyYRRQjIqLuUrx0Kc3U0czmAhYzf/fOlczTTJECJiIi6izdRt3qQE7do3ABWMx8DuSUihJFRER0\n",
+ "JMVLt+phepv9MyY4SURExIikeGkQSZIOPqdYsXof7WJnm/337fO5IyIixlGKl0aZ91pY9M5i1t59\n",
+ "tJ0LWcmWPfat5Ha2s3yfzx0RETGOMsNuA4zXStXlaKNT6GEGu7iP7SzPw7oRk1e33Ttj8spoo0YY\n",
+ "n5Wqy0IlxUpERDRKuo0aoFiRWi0rVevRZKXqiIjoUml5aYysVB0REQF55iUiomvk3hmTRbqNIiIi\n",
+ "olFSvERERESjpHiJiIiIRknxEhEREY2S4iUiIiIaJcVLRERENEqKl4iIiGiUFC8RERHRKCleIiIi\n",
+ "olFSvERERESjpHiJiIiIRknxEhEREY1SSfEi6Q2SfiPpQUnPGvDe6ZJuk3SLpJdXkS8iIiLqq6qW\n",
+ "l5uAJcBPWndKWgi8EVgILAI+J6mxrUOSeqvO0InkHFvJObaakLMJGSMmk0oKA9u32L51kLeOAS61\n",
+ "fb/trcAW4LkTGm5s9VYdoEO9VQfoUG/VATrUW3WADvVWHaBDvVUH6EBv1QEiukndWjWeANzV8vou\n",
+ "4IkVZYmIiIgamjZeJ5a0Gnj8IG+dYfvKEZzKYxQpIiIiJgHZ1dUGktYAp9m+oXz9IQDb55avVwF9\n",
+ "ttcP+LoUNBERo2BbVWeI2Ffj1vIyAq0X0krgEknnU3QXLQB+OfALcvFFRER0r6qGSi+RdCfwPOAH\n",
+ "kn4IYHsz8E1gM/BD4J2usmkoIiIiaqfSbqOIiIiIkarbaKOOSTpb0iZJGyX9WNKcqjMNRtInJd1c\n",
+ "Zv2upEdWnWkwQ00cWAeSFpUTF94m6YNV5xmMpC9L+rOkm6rO0o6kOZLWlP/Wv5Z0atWZBiNpuqT1\n",
+ "5fW9WdI5VWcaiqSpkjZIGslghAklaaukG8uce3XHRzRJY4sX4BO2n2n7UOB7QF/Vgdr4EfA0288E\n",
+ "bgVOrzhPO4NOHFgHkqYCn6WYuHAhsFTSU6tNNaivUGSss/uB99h+GkW37bvq+Lu0vRM4sry+DwGO\n",
+ "lPTCimMNZRlFd3edm7IN9No+zHaT58+KaG7xYntHy8v9gb9VlWUotlfb/m/5cj0wu8o87QwxcWAd\n",
+ "PBfYYnur7fuBb1BMaFgrtq8D/lF1jqHY/pPtjeX2vcDNFPMr1Y7tf5ebPcBU4J4K47QlaTZwNPBF\n",
+ "9hyAUEd1zxfRkcYWLwCSPibpD8CbgXOrztOBtwJXVR2igZ4I3NnyOpMXjgFJc4HDKIrq2pE0RdJG\n",
+ "4M/AmvKB/jr6NPB+4L/DHVgxA9dIul7SSVWHidgXdRgq3dZwE93ZPhM4s5wf5tPAiRMasNTJhHyS\n",
+ "zgR22b5kQsO1GMOJAydanZviG0nS/sC3gWVlC0ztlC2Wh5bPiV0tqdf22opj7UHSq4C/2N7QgPWN\n",
+ "jrC9TdJBwGpJt5SthRGNU+vixfZRHR56CRW2aAyXU9JbKJqVXzYhgdoYwe+zbv4ItD6QPYc9l5GI\n",
+ "EZC0H/AdYIXt71WdZzi2/yXpB8DhwNqK4wz0AmCxpKOB6cCBkr5m+4SKc+3F9rby818lXU7RHZvi\n",
+ "JRqpsd1Gkha0vDwG2FBVlqFIWkTRpHxM+RBiE9StX/x6YIGkuZJ6KFYeX1lxpkaSJOBLwGbbn6k6\n",
+ "TzuSHivpUeX2DOAoaniN2z7D9hzbBwNvAq6tY+Ei6eGSDii3HwG8nOIh/YhGamzxApwj6aayT7wX\n",
+ "OK3iPO0sp3igeHU5RPFzVQcaTLuJA+vA9gPAu4GrKUZ0XGb75mpT7U3SpcA64CmS7pRUSTfmMI4A\n",
+ "jqcYvbOh/KjjCKlZwLXl9b0euNL2jyvO1Im6dnHOBK5r+X1+3/aPKs4UMWqZpC4iIiIapcktLxER\n",
+ "EdGFUrxEREREo6R4iYiIiEZJ8RIRERGNkuIlIiIiGiXFS0RERDRKipeIASSN+XT5kp4kaelYnzci\n",
+ "ohuleInY23hMfnQwcNw4nDciouukeIloQ1KvpLWSviXpZkkrWt7bKuk8STdKWi9pXrn/q5Je13Lc\n",
+ "jnLzXOBF5Yy2ywZ8nyWSrim3Z0n6raTHjf9PGBHRTCleIoZ2KLAMWAg8WdILyv0G/mn7EOCzwGda\n",
+ "9g/mg8B1tg+zfUHrG7YvB7ZJejdwEfBh238Z458jImLSSPESMbRf2r7bxToaG4G5Le9dWn7+BvD8\n",
+ "Yc4z3GKXpwCnAzttXzaaoBER3SLFS8TQ/tOy/SAwrc1xD7W4PEB5XUmaAvR0+H3mlOefWa78HBER\n",
+ "baR4iRi9N7Z8XldubwWeXW4vBvYrt3cABwx2EknTgC8BbwJuAd47DlkjIiaNdn9FRnQzt9ke6NGS\n",
+ "NgE7gYeGQV8MXCFpI7AKeGjY9SbgwXL/VwY893I68BPb6yTdCPxK0vdt/3YsfpiIiMlGRVd+RIyE\n",
+ "pDuAZ9u+p+osERHdJt1GEaOTqj8ioiJpeYmIiIhGSctLRERENEqKl4iIiGiUFC8RERHRKCleIiIi\n",
+ "olFSvERERESjpHiJiIiIRvkfO/rTcyrjvGcAAAAASUVORK5CYII=\n"
],
"text/plain": [
- ""
+ ""
]
},
"metadata": {},
@@ -912,7 +944,8 @@
" plt.plot(x,y,'go',label='data trainig')\n",
" plt.ylabel('Output y') \n",
" plt.xlabel('Input x') \n",
- " plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n"
+ " plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n",
+ " print \"minimal MSE for n=6\"\n"
]
},
{
@@ -932,7 +965,7 @@
},
{
"cell_type": "code",
- "execution_count": 36,
+ "execution_count": 60,
"metadata": {
"collapsed": false
},
@@ -941,331 +974,327 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "Minimum MSE: für lambda = 0.1\n"
+ "Minimum MSE for lambda = 0.1\n"
]
},
{
"data": {
"image/png": [
"iVBORw0KGgoAAAANSUhEUgAAAk4AAAEACAYAAABF4/l0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n",
- "AAALEgAACxIB0t1+/AAAIABJREFUeJzs3XecU1X6x/HPlw4KCqJgwQYo9o4NFVEEEbCgiB1WxQp2\n",
- "0Z8lRNe2u7oCll0r9i4KiigW7F0XCyhiAwRBEAUUpD2/P84dCCHJZCbJZMrzfr3yGnPvueecG8md\n",
- "Z06VmeGcc84550pXq9gVcM4555yrKjxwcs4555zLkgdOzjnnnHNZ8sDJOeeccy5LHjg555xzzmXJ\n",
- "AyfnnHPOuSzlFDhJaiXpNUlfSvpC0sDoeDNJYyVNkvSSpLXzU13nnHPOueJRLus4SWoJtDSz/0la\n",
- "E/gYOAzoB8w2s39IGgQ0NbNL8lJj55xzzrkiyanFycx+NrP/Rf+9AJgIbAj0BO6Lkt1HCKacc845\n",
- "56q0vI1xkrQpsBPwPtDCzGZGp2YCLfJVjnPOOedcseQlcIq66Z4CzjGz+YnnLPQF+r4uzjnnnKvy\n",
- "6uSagaS6hKDpATN7Jjo8U1JLM/tZ0vrArBTXeTDlnHPlYGbK5Xp//jpXunTfs5wCJ0kC7gYmmNnN\n",
- "CadGAicBN0Q/n0lxec5f/oogabCZDS52PUrj9cwvr2d+VYV6VoU6Qv6Cnqrw/HWuWDJ9z3Jtcdob\n",
- "OB74TNKn0bFLgeuBxyWdDPwA9M6xHOecc865osspcDKzt0g/TurAXPJ2zjnnnKtsfOXw0o0rdgWy\n",
- "NK7YFcjSuGJXIEvjil2BLI0rdgWyNK7YFcjCuGJXwDlX+eW0AGZOBUvmfezOOVc2+Xh2+vPXucwy\n",
- "fUe8xck551yNIulsSR9JWiTp3izSN5M0QtICST9IOqYMZf0g6S9J6yQd/1TSckkbR+87SHpH0m+S\n",
- "5kh6S9KuSfn8KWl+wmtoIe43uqaPpInRPU+WtHd0fJykhQl1mJhwzYKk+i1NrKOkjSSNiu5vhqRh\n",
- "kmpnKLNDdLyepLujz2Be9Nl1zeY+CiHn5Qicc865fIv2Pm1pZv9XgOx/Aq4GugANs0h/K7AIWI+w\n",
- "0PPzksab2YQsrjXgO+AY4BYASdtF5Vr0vgnwHHAa8DhQH9gH+Cspn+5m9moWZSYr0/1K6kyY5NXb\n",
- "zD6IlhUqaX0x4Cwzuyf5OjNbMyGPNYCfo/spMRSYDawPNAXGAmcCw0opsw4wBdjXzKZIOoQwAW07\n",
- "M/sx2w8hX7zFyTnnXGU0DOgtKe87T5jZCDN7FphTWtooADgCuMLM/jSzt4FngRPKUOSDwIkJ708C\n",
- "7mdlYLBFqJY9ZsEiMxtrZp+XoYy0ynK/kTgQN7MPoutnmNn0hPPZdPMeCcyMJpGV2AZ4zMwWR7uL\n",
- "vAhsXVqZ0eceN7Mp0fvnge+BnbO8n7zywMk551ylE+068TAZAhRJz0mam+Y1MotisgkAtgCWmtnk\n",
- "hGPjCUFAtt4DmkhqF3VNHU0IpkpMApZJGi6pq6SmZamvpFsl3ZpFPUq936h+uwDrSfpG0tSoS61B\n",
- "QrLrJP0SdSfulyarkuAw0YvAsZIaStoQ6AqMybLMxDq2IPx/+bK0+ykED5ycc86tQsLy8cpDVYYD\n",
- "fdOdNLPuZtY0zatnFvlnU8c1gXlJx+YDjbO4NtEDhFanzsAEQvdZqITZPKBDVJ87gVmSnpW0XsL1\n",
- "Ap5JCg5Pjq4/y8zOyqIO2dxvC6Au0Cuq046E7snLo/ODgM2ADYA7gFGSNk/MQNImwL7AfUl5Dwa2\n",
- "JXyeU4EPo5aw0spMzLsu8BAw3MwmZXE/eeeBk3POuVWYoXy88lCVdYFGktrnIa9UsqnjAqBJ0rG1\n",
- "CMFTtowQOB3H6t10IYHZV2bWz8xaEYKLDYCbk/I4NCk4vLsMdSC5zDQWRj+HmdlMM5sD3AR0i+r5\n",
- "gZn9YWZLzOx+4O2ScwlOAN5MHH8kSYQWpyeARkBzoJmkG4A/M5WZkEctwue4CDg725vONw+cnHPO\n",
- "VTrRrKn2wN+BfmnSvJA0iyvx9XwWxWTTAjMJqCOpTcKxHYAvsrh2ZUFhfM53wMHA06Wk/ZrQWrNt\n",
- "WcrIphqlJjCbC0zLsZwTWb21qTmhO+6WKOj6ldCi2M3MfiutzCjwupsQTPcys2U51rHcPHByzjlX\n",
- "qUg6FuhkZsMILRQ9Uo13MbODzaxxmtchGfKvHeVXB6gtqX7itPikMv4gBDpXSWoUTZHvQWj5KKuT\n",
- "o/tamHhQ0paSLojG/SCpFWEW3rvJVS9HmWW638i9wABJ60bjrc4jdMmtJamLpAaS6kg6jjD7b0xC\n",
- "WXsRWsueSMpzNjADOCOqz9qE1rfxmcpMuP52oB3Q08wSZxtWOA+cnHPOVRqS9gAONLOLAcxsPmGj\n",
- "+D55LOYKQvfQIMJ+qwuByxLqMFrSJQnpzyRM459FGNR9uplNpIzM7Dsz+yTxUPRzPqF17X1JCwgB\n",
- "02fABUlZjEpqVXsqqu9/JN2eoeiy3u/VwIeE1rYJwMfANYRxSFcTPodfgLMI3YeJA+dPBJ6KAs7E\n",
- "ezfC7MQehCDqG8JyC+eVUmbJmKn+hJa+nxPuP+v1tPLJVw53zrkqJB/PTn/+OpdZpu+Itzg555xz\n",
- "zmXJAyfnnHPOuSx54OScc845lyUPnJxzrgAkSdrsumgatXOumvDAyTnnCqL1EdD1TGh9eLFr4pzL\n",
- "Hw+cnHMuj6QN+kvtvoSO18JtTaDjdVK7L6UN+he7bs653NUpdgWcc656mXEnNPwVat8Y1ius3QCW\n",
- "ng8zMq4W7ZyrGrzFyTnn8igs9CeDWmtD7wmgptHh4iya55zLK29xcs65vKvXFsb2g29HhDFO9doW\n",
- "u0bOufzwFifnnMszswnXm01+2sws/JxwQ7Hr5FaS1EzSCEkLJP1Q2tYdks6W9JGkRZLuLWNZP0j6\n",
- "S9I6Scc/lbRc0sbR+w6S3pH0m6Q5kt6StGtSPn8mbbkytBD3G13TR9LE6JrJkvaWVE/S3VEe86J7\n",
- "6JpwTcbzSfm3jT7PB5KOJ5fbIeHcVpJejT6jbyQdls3955sHTs455yodSQMlXVug7G8FFgHrAccB\n",
- "t0vaOkP6nwh7qd1TjrIM+I6waS8AkrYj7H1n0fsmwHPAEKApsCEQJ+zllphP96SNjAdmWYcy3a+k\n",
- "zsD1wElmtiZhI9/vCb1UU4B9zawJcDnweLSXHFmcT67TB6zcry9dud9F5+oAzwIjo8+oP/CgpApv\n",
- "zfW96pxzrgqpKXvVRetffQPsbWYz85jvGsCvwDYlm9NKug+YbmaXlnLt1cBGZtavDOV9D9xF2Ay3\n",
- "fXTsX1Ed/g5sSghoxppZ01LyOdnMXs227Oi6Mt+vpHeAO82s1NY1SeOBwWY2ItvzkvoAhxM2821j\n",
- "ZieUVq6kbYF3zaxxwrEXgffN7MrS6llWvledc865KiUaTP8wcEK6NJKekzQ3zWtkmsu2AJaWBBGR\n",
- "8cA2WVSrvMHme0ATSe0k1QaOBh5MOD8JWCZpuKSuktIFUCnLl3SrpFvTXFOm+43qtwuwXtQdNlXS\n",
- "MEkNUqRtEeX/ZZq8Vjsfta7FgfMS76cs5SaoBWyb4XxB+OBw55xzq1BceemKsFjOrVrDCV0z/0qZ\n",
- "v1n3cuS5JjAv6dh8oHGKtKsVWY7ySjwAnAi8QWhp+WlFpmbzorE8g4A7gZaSRgOnmtmsKJmAZyQt\n",
- "TcjzQjO728zOylBuWe+3BVAX6AV0AJYSusguj16hMlJd4CFguJlNSs4kw/mrgbvMbLq0yr+z0sr9\n",
- "Gpgl6SLgZmB/YF+gTC1w+eCBk3POuVXkIeDJl3WBRpLam9kHecpzAdAk6dhahGCiNOX9XIwQOL0J\n",
- "bAbcn5yXmX0F9AOQtCWhRepm4NiEPA4ta1cdZb/fhdHPYSVdpJJuIiFwklQrup9FwNnJGaQ7L2lH\n",
- "4ABgp5JD2ZZrZkuiweDDCAHmh8DjURkVygMn55xzlU40G6stYRxQP8JA4uQ0LxBaJ1J5w8wOSXF8\n",
- "ElBHUpuE7qsdgC+yqFa5W5zMbIqk74CDgb+VkvbraBxSPlabL9P9mtlcSdPSZRaNPbubENR2M7Nl\n",
- "ZTi/H2FM15SQjDWB2pK2MrNdM5Ub1e1zoGNCWe8AZZrlmA85j3GSdI+kmZI+Tzg2WNK0aCpi2umI\n",
- "zjnnXDJJxwKdzGwY8ATQI9VYFzM7OGmWWeIrVdCEmf0BPA1cJalR1EXWg9BCkq4+taPy6xB+0deP\n",
- "xuSU1cnRfS1MPChpS0kXSNowet+KMAvv3eSqlLXA8twvIRgZIGndaLzVecCo6NztQDugp5n9leLa\n",
- "TOfvADYnBG47Av8Bnge6ZFEukraT1CC6jwsJ3XvDs/kc8ikfg8PvBZIDIwNuMrOdoteYPJTjnHOu\n",
- "mpO0B3CgmV0MYGbzgWeAPnks5kzCcgCzCF1ip5vZxIQ6jJZ0SUL6K4A/CV1ExxO6lS4ra6Fm9p2Z\n",
- "fZJ4KPo5H2gPvC9pASFg+gy4ICmLUVp1Haenovr+R9LtGYou6/1eTegKm0QYj/UxcE20rEB/QuDz\n",
- "c0I9jonyyXjezBaa2azoNZPQjbjQzOZkKjehXicA04GZhDFOnc1sSYb7Loi8LEcgaVNglJltF72P\n",
- "AQvM7MYM11T66bDOOVfZ5OPZ6c9f5zIr1nIEAySNV1hFdO0CluOcq0mko5G+RbqQMHPHOecqTKEC\n",
- "p9sJMwd2BGYAaVuenHMuK1IdpH8C1xHGPnQGPiFhSwbnnCu0gsyqS1h3Akl3kTC4K5GkwQlvx5nZ\n",
- "uELUxzlXxUnNgUcNlu/LG+e/xT6d67L4osXU3xJ4FGkscDFmvxS5pnknqSMJM4mcc8VVkBYnSesn\n",
- "vD0c+DxVOjMbnPAaV4i6OOeqOGlng4/eY/ff6rJkrbfY53pgwRLqjRXWuS/37kvYUuJLpP6ENWSq\n",
- "DTMbl/isLHZ9nKvp8rEcwSPAO8CW0RLpfwNukPSZwh41+xGa1Z1zrkwWqmG/hTQY15fhtffkvU2X\n",
- "UecfwDZmXApsCcy/j74fCJs5jQ27AX2Bd5B2ypSvc86Vl2/y65yrdI7WY03O4taRGzFt72N45OMP\n",
- "2P1yOg5+hY7xrQhr0OxB2P/qLR4eOZNJPWLA9nVZPGgRDZrUwq4FHgGuxCx5u4kqzWfVOVd4mb4j\n",
- "Hjg55yoNibW34YuL76D/hcCcC+tfdtK7l3ZfSgiWegD1CWMm3wK2IqwavRswmdlb/sA7F+zEDx1/\n",
- "7v7rV/83ip7HEFZpPh94nGI97PLMAyfnCs8DJ+dcpSaxPnDuXrx9+rPqUeetVnrnyL6/zllWiy7A\n",
- "N4RgaRQw3mKrPrQUVz3C3ld7Y+rA0gYH8uc6jfi17Y8nT/vspaGvzzmgwVJ+rAVnkWoz0hbqRhMG\n",
- "Uo8GLGYR8xhqM210Bdx2uXjg5FzheeDknKuUJDYHLqb5xD4XNj951qU/vLvZyYey5JmteJkQKD1n\n",
- "MZtRpjzjEj922JGpe/6dxj8fUGfz0fPPHT9njcvfpM6rm/HWBV249vumvG0xW6gW6sZGDKEnbVZk\n",
- "MJLJTOOcyho8eeDkXOFl/I6YWVFeoejilO0vf/mruC8azdqJrR8fS9eBf9Y/r/mce3bgj2mNmdv3\n",
- "UE5jMA3zVg62OdgTrDl96vZ79/nvuxvy9ZQmLDrkWBYxmHfZle8ZjK32asMLxf6M0t8TVhnyqMov\n",
- "4GzgI2ARcG+K882AEYQtQX4AjsmQV9Zp01z/A/AXsE7S8U+B5cDG0fsOhIlYvwFzCN3Vuybk8Sdh\n",
- "65aS19AifR4bEf7omUNYx3EYUDs6txXwanQP3wCHlaWcLM73ASZG5ycDHVLUr210nw+U8plYunMF\n",
- "WcfJOVf1FLrLSnGtxVc9B1J78WkMeH8DljaYsd1vv9/91q1/7td4MZMFfe99xublc6tzM74DjpLW\n",
- "3/eztx+5eU8emfMgx9028uGHB05vzOI2W1A71S6lNKKZ4lJyt6CrOJIGAi3N7P8KkP1PhH3RuhD2\n",
- "cEt2K+GX63qEbuDnJY03swk5pk3FgO8Im/reAmEz26heFr1vAjwHnAY8Thjrt09Ubkke3c3s1SzL\n",
- "TJbPz2MoMBtYH2gKjAXOlHQb8CxwG3AAYW2yUZJ2MrNvsiwn7XlJnYHrgd5m9kG0LFKqFqNbgQ9Y\n",
- "uU9gmXlXnXOOQnVZKa7WmHrwx3p9qTd/W6btuZh5G41gvS+utDs+Xh94jPAgux6z5bnfSYa6iFrA\n",
- "icA1azJ/3Nds+fMJG8wY8Gp/Vt+25WUWcSC/E/6qL3mNt1jFbyiarKZ01UkSoVVibwsbwhaijKuB\n",
- "jcysX8KxNQjrgm1jZpOjY/cB083s0qTrs06boQ7fA3cBh5pZ++jYv6J8/w5sSggUxppZ0wx5nJxD\n",
- "4FSST06fR3Tua+AcMxsTvf8H0JjwPX/XzBonpH0ReN/MriytnCzOvwPcaWZp//aS1IewtuQEoI2Z\n",
- "nZAhbdrviLc4OVcF5b11qAkDVwmaAHrShgcZAGSdr+KqTVgqoAdGD5Y22JCvey7j657z+XHfU5nX\n",
- "6gFDy4AzgBjQF7MXyl3vMjBjOTBc4skFNL5kQ6af0WbuwBc2eGpY5+m9Ev7KHsm3TGMgB/IloXtk\n",
- "b+BvwGaK6wNWBlLvWczmV0TdayIzM0kPAycA/0qVRtJzhP8/qbxpZj1LKSbVL8YtgKUlv5wj40m9\n",
- "entZ0mbyHnCCpHaEYPFown39PTo/CVgmaTjwKCHYmJuUR9pAWNKtAGZ2Vin1yPXzAHgROFbS64Su\n",
- "tYOBy9OkrQVsm2U5ac8rLHq7C/CspG+ABsAzwEVmtghWtNrFgf2B/mnqkxUPnJyrYtK0DrVWC1Hu\n",
- "4KkeDdIcT9Vsv2p94mpMaOLvAXTDNIPvDpzK65c3YeaUn1j/4kU0enw+63H0OnWZyxwOJTzk9sLs\n",
- "23LVNwdmLAAul7hz8sKh1/P1fgs2uPu0WZvUnrP+omX8sugPrpgwZ8Xn+CPwUHSfTYE9CcHUFcDO\n",
- "imsSCa1SFrPpFX0/BSHlpysi91at4cBI0gROZtY9x/xT3eeaQPLaX/MJrSa5pC3NA4QW0TcILSI/\n",
- "raik2TyFPRkHAXcCLSWNBk61sMWZgGckLU3I70Izuzu6vrSAaUVRKY6V9R4HAy9H19QGhpvZswob\n",
- "cs+SdBFwMyGA2Zcw5imbcjKdbwHUBXoRvp9LCd2Cl7MyaLsauMvMpivHf98eODlX1eSpdWgVi1eM\n",
- "lUg+vjDVYcW1CSvXVtoTeJeFa7/Ew6OmMrVDP+AnGp84jG0eOJWebF1yXaMn6XjXH7x3yiL2xOyP\n",
- "8lQ1dOFsei388H+Ww1gDM34EjpF67TV9aq9//8nc2e+y5zft+HoIUmPgrsTuQ4vZXMLnOzr6DOoD\n",
- "OxMe1McBtymueYQg6u3o50SLFbYLsiAqTzfeukAjSe3N7IMC5J/qPhcATZKOrUX4JZ1L2kyMEDi9\n",
- "CWwG3J9cNzP7CugHIGlL4EFCAHJsdP2huXbVJZcZyfoeo+7VF4EngN0JQc09km4ws0GSDiMMFh8E\n",
- "fEgYr1Xy7CmtnHTn58GK59Swkm5dSTcRBU6SdiSMqyrZUSCnf9/Vak8n52qEHFqH0prHUEYyeZVj\n",
- "I/mWeQwDUFy1FNfuiusaxfUZYQbOrsAdPHf7dgy297lh7iVM7dAGOMSMg2nxQKfkAG/qkdQ/dSMW\n",
- "ljdoClofAV3PhNaHlz+Plcx4B9jzN5revBVfdejEK58spMFpwNuEB27q62L2l8XsXYvZPy1mhxJ+\n",
- "yXcjtBjsSfiLtxC/7GsESV2B9oTuqn5p0rwgaX6a1/NZFJMq8J4E1JGU+G93B+CLHNNmrojZFMIg\n",
- "8YOBp0tJ+zVwH7BNWcsprRopjpXlHpsTWpNvMbMlZvYrodWwG4CZfW5mHc2suZkdDLRm5XektHLS\n",
- "nf/SzH4DpmW4r46EsWJTJM0ALgB6SfoowzVpeYuTc1VNGVuHsmEzbbRaCB5kAPVoyGIWsoQ7OZN6\n",
- "iutu4BDC9OJRhPFJ7zHYNiA8gO4EngT2NEsIvvIc4Ekb9Icm50DHOnBbEzj1Oqnd1TBviNn0O8qT\n",
- "Z4lo/NODEiNeo9OFa7Jg4A0Mevd8bnqpVhhnU+rWLdEMvK+i112wohvTlZGkY4Edzexihda/qySd\n",
- "VzJepUT0y7c8+dcmdO3UAWpLqk8YP7PMzP6Q9HRU5imEVsWSltVVlCVtlk4G1jazhZJW/H6OWpi6\n",
- "A4+a2U+SWhFm4b2XeFvlLDNvnwdhNt0M4AxJNxJanE4ijEVC0vaEAKgWcCahi204lP5ZZlGPe4EB\n",
- "ksYQuurOIzyvAP4LPJzwOV1ICKROL8/n5S1OzlU1pbQOlZfNtNEcz6n05jGOx+jHcML6Lp8Be1nM\n",
- "trGYXcJgm81gu5PwMFwKbGtG/1WCJqD2X6SegVbuAG/GnbAkBrUbhGdf7Qaw9MpwPD/M+MOM+HJq\n",
- "73AR//q1JT8v/5iddzaYgHQ0oSsi+/x88HiZSdoDONDMLgYws/mEgb598ljMFYR1jwYBxxO6ei5L\n",
- "OH8mYVr+LEKX2OlmNjGq32hJl2STtqzM7Dsz+yTxUPRzPqH17X1JC4B3Cd/LCxLSjkpqcXuq5ISk\n",
- "2yXdnqHovHweUdf5EYSAZjZhoPtfhCCGKO/pwEzCGKfOZqvMVC3ts8x0/mpC998kwhixj4Fronot\n",
- "NLNZ0WsmodtvoZnNyfCZpOXLEThXBUWz6la2Ds1jWHkGhiuuWqz8y60HsAnwAuEvtTEWs99XpBW7\n",
- "AJcSBnTeAtxixq+pM9bmj9Xn5XO2oPnMXgmDSKMZa+UdxC616QWd74E506BZK3i5r9nkjN0auZBo\n",
- "D9zcmZfWeZIj6zRh/rfA2aTYuqWi1JTlCJwrJt9yxTm3guJqRBgo2YPQ/D+PlXvBvWMxWzEzR0KE\n",
- "vwwvBdoRZjfdZUb6MUrSQYSBrn+v3Zxvl6+de4C3MuutL4HFk+DbEWGMU722ZhNuKG9+2ZWJgN51\n",
- "WPKPa7jstwu4sVVtlt8CXIdZubtHy18fD5ycKzQPnJyr4RTX+oQgqQdhoOQnRMGSxVJsfBsWi+xJ\n",
- "CJjWAm4AHjJjcfpCJEJT/0CgD2Zv5PcuikuiIXB+K6Zc+ARHzdyVj+rXZvmZFbUO1cp6eODkXKF5\n",
- "4ORcDaO4RJhx0oMQALUhTBMeSeiCS9nFJlGXMOh0EGGcw3XAM2Ysy1ygGgP3AK2AIzHLNMOlSpNY\n",
- "H7imO6MOe4ATljZh3hu1sPMwm1ox5Xvg5FyheeDkXA2guBoQutVKuuAWs7IL7s1M24VINCLM6LkQ\n",
- "+JYQML1slsV+TlJbwuDdt4EBmKXc/q26kdi5EX/cHCe2xUCGNqzHkquAoVhht2XxwMm5wvPAybki\n",
- "y9eijavlG9d6hKUCegKdgM8JrUqjgK9K26RWYm3gLEL32rvAdWa8n30F1J3Q0nQ5ZjktCVAVReOf\n",
- "jtiKCf8eTt8G2/H5rw1ZdDJmbxeuTA+cnCs0D5ycK7KVs8HG9stlFljUBbctK2fBbUXYfXwUMNpi\n",
- "Nju7+tCSMEX4FMKu6/8w48vsK6JahCnMpwC9MXu3DLdR7Ug0qMWygUfz2OW3cpbqsfjZNfjzXCy7\n",
- "/x9lK8sDJ+cKzQMn54pk5aKNHerAnVvAqZPgraVlWbRRcdUD9iO0KnUnLGJU0gX3usWy7xqT2By4\n",
- "iLCJ6EPAv6KtR8pyU2sRZs01BY7C7OcyXV+NSbRYj5nXXcHVR/fj3mV1WXJRPZbcQT5bGT1wcq7g\n",
- "PHByrkhCF93mveDAG+G/G8NpU+CV8+HbpzN12Smu5oRtCnoAnYGJrAyWviitC271erAdcAlhM97/\n",
- "AkPMmFWOG9oaGEFo5Tofs/Sz7GowiR325q07evN4y3MYumlWY8WyztsDJ+cKLdN3xLdcca6AzMyk\n",
- "Nga11obeE8KijVhy0BR1wbUjtCr1ALYj7Bo+CjjbYmHjyrKS2JsQMO1K2BD0TDN+z3xV2syOIARd\n",
- "F2E2vFx51BBmjJc67PE2HTbOZ9BUE0kaDkw1syuKXRfnwAMn5ypAvbYwtl/ioo0AiqsusA8rxyvV\n",
- "JwRK1wCvWcxS70lXimjAclfCGkwbAf8EepuVc6uTsI/V1cBxwMGYlWtjzJomCpjK1g3qUjFSbz67\n",
- "GknjgAfM7O7yFJSvIE3SpoQNe+uY2fJc8nKVjwdOzhWY2YTrS/5bcb0GNFBcjxCCm8mEYOlIYHxZ\n",
- "u+ASSdSO8rkEqA1cDzxuxtKMF2bOtBlhc8z6wK6Y/VLuvFyVkI8ZoAWYRZptt2Jla93z7tBqyDf5\n",
- "da4CKK4+imscoQWiD6EbbhuL2W4Ws6ssZv8rb9AkUV/iVOArwrICVwA7mPFwjkHT9oRNM78EOnvQ\n",
- "VFO0PgK6nhlaRys+D0k7SfpE0jxJjwINEs41lfScpFmSfpU0StKG0blrCC24t0Sb3A6Njg+RNEXS\n",
- "75I+ktQhTbn9gWOBi6Prn42ObyDpqajM7yQNSLimfZTn75J+lvSv6FTJqvm/RXntXtbPwVViZlaU\n",
- "F9FGyv7yV3V/MZhjGcxUBtOTwTTKW75YY7ALwH4CewFsXzDlJX/oY/CLwbHF/vz8lfz/HStEHrB+\n",
- "f9jySzj5a1hu4eeWX8L6/bPPN7c8gHqEPy7OIbSa9iIs5HpVdL4ZcDghmFoTeBwYkXD9a8DfkvI8\n",
- "jjADtBZwPjADqJem/HtLyore1wI+Bi4n9NBsRlgg9qDo/LvAcdF/NwJ2j/57E2A5UKvY/178Vb5X\n",
- "pu+Zd9U5V0CKqzNhUHYni9kXeclTNCe0LJ1BaLnqbsan+cgbqQ6hi+9w4EDMxuclX1cFzLgTGv4K\n",
- "tW8MPUy1G8DS82FGGdYdyzmPPQjjgoZE75+S9GHJSTP7lTCrEwBJ1xK+A4lW6R4zs4cS3t4k6XJg\n",
- "S8JisakkXr8b0NzM/h69/17SXYRW45cIQV1bSc0trNn1foo8XDXjXXXOFYji2pkwPujIfARNEq0k\n",
- "bgYmAS2Bvcw4Oo9BU3PCfnbbAbt50FSzmJmBEmaAqikpZoAWOI8NgJ+Sjv1IFIhIaiTpv5J+kPQ7\n",
- "8DqwVhhTtbIaiRdLulDSBEm/SZpL2LS6eZb12QTYQNLckhdh0sV60fmTgS2AiZI+kHRIlvm6Ksxb\n",
- "nJwrAMWcoik0AAAgAElEQVTVmrAi92kWszdKS58xL7ElYdPdwwjbm2xnttovl9xIOwNPEwK9KzDL\n",
- "vKmvq6ZSzwCtwDxmABsmHduEMIkC4AJCoNLezGZJ2hH4hBBYrTb7TtI+hAVfO5nZl9GxX0nfIpQc\n",
- "4E0BvjezLVImNptMGBeFpF7AkwoTKirbIHWXRzkHTpLuIeyVNcvMtouONQMeI/yD/wHobWa/5VqW\n",
- "c1VBtH/cGOBqi1n5t1cRuxD+ut0XuAVoY8av+anlKgWdCPwLOAOzp/Kev6syEmeAEgLpis7jHWCp\n",
- "pIHA7YRlOnYDXonOrwksBH6Pfs/Ekq6fCbROeN8YWArMllSPMOO0SYbyZwKbJ7z/AJgv6WJgGKFr\n",
- "biuggZl9JOl44EULEyd+JwRMy4Ffop+tgW+yv31XFeSjq+5ewrTqRJcAY6Mo/ZXovXPVnuJaE3ge\n",
- "eNRidnuZrxeS6CQxFngGeAvYzIyr8h40SXWRhhEGvu7vQZMrNjNbAhwB9AXmAL2BxH+XNwMNgdmE\n",
- "IOsFVm3dGQIcGc24u5nwB8wYQvf2D4Sga0qGKtwNbB11yz1tYQ2m7sCOhHWZfgHuYGXw1QX4QtJ8\n",
- "4N9AHzP7y8z+JKzH9naUV/tyfByuksrLlivRYl+jElqcvgL2M7OZkloC48ysXdI1Zr7kv6tGogUt\n",
- "RwHTgFPLsryARC3CquGXAmsDNwAPmlGYLU3C9/Jxwl/JJ+AtwlWGb7niXOEVY8uVFmYrtoiYCbQo\n",
- "UDnOVQrRlil3A0uA07MNmiTqAscQxjAtAq4DRphRuDFG0h7AE4T6XoWvbOycc1kr+OBwMzNJKX+J\n",
- "SBqc8HacmY0rdH2cK5DrgbbAARazUhedlGgE/A24kNAFcC7wslmBB5VKpxK6EE7BbGRBy3J5Iakj\n",
- "0LHI1XDORQoVOM2U1NLMfpa0PqTehd3MBheofOcqjOI6FzgU2Nti9mfGtGJt4EzCOkzvAX3MeK/w\n",
- "lVR9YChhZeV9MPu64GW6vIj+oBxX8l5S8oBo51wFKtQ6TiOBk6L/PokwyNW5akdx9SG0GnWxmM1J\n",
- "m060kLiesOpwO+AAMw6roKBpQ8Iv3ubA7h40Oedc+eUcOEl6hDC7YUtJUyX1I3RbdJY0CegUvXeu\n",
- "WlFcnQitON0sZj+mTSc2I2zb0BjYxYwTzfiyYiqpDoQp1SOBIzGbXyHlOudcNZWXWXXlKthndbgq\n",
- "THHtSNhyobfF0o/Nk2hJWFLg32bcWkHVg7CS8pnAlcBJmI2psLJdQfmsOucKrxiz6pyrthTXZoS1\n",
- "ms4qJWham7CGzP0VHDQ1JCweuBOwJ2bfVVjZzjlXzXng5FwCtVA3mjCQejRgMYuYx1CbaaNXnI9r\n",
- "XUIwdJ3F7Im0+YRZc88R9tK6uuAVX1nwJoQFA78B9sLsjwor2znnagAPnJyLqIW6sRFD6EmbFQdH\n",
- "0lothM200YprDUIw9KTF7Ja0+YS1mZ4AvgfOK/gSAysL7gQ8BPwT+DfF6od3Lo8kDQemmtkVxa5L\n",
- "NiQdB5xoZl3ymdZVHoWaVedc1dOEgasETQA9aUMTBkSrgj8BTCBsUZJStAL4cMI+VX8zo/CLS0pC\n",
- "Op8QNB2H2U0eNLlqZLXNe9ORNE7SyeUtSNJwSTm1EJvZQ9kGQmVJ6yoPb3FyrkQ9GqQ53hC4k/Dw\n",
- "7p9uVXAJEfbKagV0MWNJgWqaWOgawF2EHeP3wNLP7nOuNKV1VVdUHqmyzTJdQf9gkFTHrPQFbl31\n",
- "5i1OzpVYzKKUxxvRirAjem+LWaZgKEZYYLKHGQvzX8Ek0uaEpUD+Ajp40ORysaKr+ni60Jv9OJ4u\n",
- "bMQQtVC3Cs1D2knSJ5LmSXoUVv5BI6mppOckzYo28h2lsE4Zkq4hfP9ukTRf0tDo+BBJUyT9Lukj\n",
- "hSU6UpXbHzgWuDi6/tno+A+SLpb0GTBfUm1Jl0iaHNXxS0mHJeTTV9KbCe+XSzpN0qRow99bMqQ9\n",
- "SNLXkn6TdKuk13NpQXOF4YGTcyXmMZSRTF7l2AvMZivqAYdYLP1Aa4mBwHGElqbfC1tRQOoCvEvY\n",
- "qb0fZoUP1Fz1lqGruqLykFSPsGDyfUBTQvd4L1a2JJXsCblx9FoI3AJgZpcBbwJnmVljMxsYXfMB\n",
- "sEOU38PAE1E5qzCzOwjd3TdE1x+acLoPcDCwtpktAyYDHcysCRAHHpSUaU/WQ4Bdge2B3grf3+R7\n",
- "bx7d7yCgGfA1sCcFbkVzZeeBk3MRm2mjmcY5PMgYHud1RvA/tkS0Zl+L2ex010kcB1wEdDZjZrp0\n",
- "eRHGM10K3ENY0PJWH8/k8iJzV3VF5bEHUMfMhpjZMjN7Cviw5KSZ/WpmI8xskZktAK4F9kvKY5Vu\n",
- "vWgc0VwzW25mNwH1gS0z1CG5W9CAoWb2k5n9FeX5pJn9HP3344RZrLtnyPN6M5tnZlOB14AdU6Tp\n",
- "BnxhZs9EdR0K/JwhT1ckPsbJuQTRWIzRiqsj8DhwoMXs+3TpJQ4BbiRsofJDQSsnNQbuBTYC2mP2\n",
- "U0HLczVLuq7qxWXods49jw2A5H/XPxIFM5IaAf8GuhBakADWVLRaYfR+lT8kJF1I2FB7g+hcE8L2\n",
- "Q2UxNSnPE4HzgE1L6gCsk+H6xADoT2CNFGk2AKYlHUt+7yoBb3FyLoni2p4QNPWxmP0vbTqxD2EG\n",
- "3aEF30JF2oKwKfAcYD8PmlzepeqqHsm3zGNYBeYxA9gw6dgmrAyGLiBMhGhvZmsRWpvEylai5KBp\n",
- "H0Jr8FFmtraZNQV+Z/VWpRLpWm9XHFdYK+0O4CygWZTnFxnyzNZ0wh9FJeUo8b2rPLzFybkEimsT\n",
- "YDRwtsXs1bTpxI6EhSaPNeP9wlZK3Qldc5dhdmdBy3I1ls200WoheJAB1KMhi1nIPIaVZUZcHvJ4\n",
- "B1gqaSBh9fsewG7AK9H5NQnjmn6X1IwwISPRTKB1wvvGwFJgdjSu6RJCi1M6M4HNS6njGoRAajZQ\n",
- "K2p92raUaxIlBnqJRhMGth9K2JngdKBlGfJ1FcQDJ+ciimsd4EXgHxazx9OmE20JD7mzzBhbuAqp\n",
- "FnAFcArQE7P3ClaWc6zsqi5WHma2RNIRhOU//h7l81RCkpsJA7xnE7r0bgJ6JpwfAtwn6QzgfuB8\n",
- "wkr/k4A/CN18UzJU4W7C4PG5wGtmdkSKOk6QdCNhcsbyqJy3EpOwastVcitW4vkV/21msyUdRdg4\n",
- "/D7CQPWPCLNmXSXim/w6B0Srgr8MvG4xuyRtOrEhYebOdWYUrvVHWgt4gDCO4yiigajO+Sa/NYPC\n",
- "H05TgWPN7PVi16emyfQd8TFOrsZTXHWAxwh/lV6aNp1oRmiRuqPAQdPWhJlEPwIHeNDkXM0QreO0\n",
- "tqT6wP9Fh72luZLxwMnVaIpLwH8J3danZFgVfE1Ct8ELwA2Fq5B6ETYGvgazAZgtLlhZzrnKZk/C\n",
- "GlG/ENZ+OqxkCQRXeXhXnavRFNfVQFdgf4vZgpRpRH1gFGFq8MkF2bRXqg1cTVi5uBdmH+e9DFct\n",
- "eFedc4WX6Tvig8NdjaW4ziSsCLx3hqCpNmGs0R9A/wIFTc0IA17rArth9kvey3DOOZcX3lXnaiTF\n",
- "dQRwGdDFYjYrZZqwae9thIXtjjEj/5t7SjsQxjN9AXTxoMk55yo3b3FyNY7i2hf4DyFo+i5D0muA\n",
- "nYFOZmlWRM6pIjqGMPV4AGaP5j1/55xzeeeBk6tRFNd2hI00j7WYfZo2nbgAOBzY14z5+a2E6hAG\n",
- "mB9GmDX3WV7zdy4LknyPQ+fKwQMnV2Moro0JM+POtZi9nDad6AcMBDqYkd+uM2ld4FFgCWE80695\n",
- "zd+5LPjAcOfKz8c4uRpBcTUjrCB8k8XskbTpxGGEHdcPMlt1Y8/cK6FdCOOZ3gMO8aDJOeeqHl+O\n",
- "wFV7iqsRYVXwty1mF6VNJ/YnbO7b1Yz8LgcQ9rP6F3A6Zk/nNW9Xo/iz07ni8q46V61Fq4I/AnwH\n",
- "DEqbTuxKCJp65zVoCuszXQv0AjpiNiFveTvnnKtwHji5aitaFfw2oAFwlMVsecp0oh1hgctTzXgt\n",
- "fxVQY+BBwm7su2M2J295O+ecKwof4+SqsxhhOYEjLZZ66xKJjQn7z11qxjN5K1nahLBj+kzC+kwe\n",
- "NDnnXDXggZOrlhTXacDxwCEWs5TLCUisC7wEDDFjeP4K157Au8C9wGm+35xzzlUfPjjcVTuK6zBC\n",
- "F90+FrNvU6YRTYBXgRfNuCx/het44CagL2aj85avcxF/djpXXAUNnCT9AMwDlgFLzKx9wjn/8ru8\n",
- "U1wdgKeBgy2WeqNciQaE9ZwmAWfkZf85qRZhk95jgB6YfZlzns6l4M9O54qr0IPDDehovl6NqwCK\n",
- "axvgKeD4DEFTySy7X4Cz8hQ0rUHYCLg50B6z2Tnn6ZxzrlKqiDFOaf8yUluNUQt1q4A6uGpOcbUC\n",
- "XgAusJi9lDJN2LT3DqARcIIZy3IvWK0Ig8B/Azp70OScc9VboQMnA16W9JGkU1c7ezxd2IghHjy5\n",
- "XCiupoRVwYdazB5MmSYETf8EtgKOMCP3AdvS7oRVwB8CTsbsr5zzdM45V6kVuqtubzObobA/11hJ\n",
- "X5nZmyvOvgY0pg1/MUTSn2Y2rsD1cdWMLlRDxq0znu5znkTcmCHpIKArYdPeP3IvWMcAQwgB06ic\n",
- "83MuDUkdgY5FroZzLlLQwMnMZkQ/f5E0AmgPrAyc9o9+/sJP9psHTa5sFFd9JjZ5g/GHt+STV962\n",
- "5d+lHK8k0R/oT9i0N7fxdmEQeAw4ETgAs89zys+5UkR/UI4reS8pVrTKOOcK11UnqZHCyskoDJ49\n",
- "CEj9S2YxCwtVD1c9qW7LM/j35r/wZrd2LL2jLtbpWqndl9IG/VdJJ44iBDoHmTE9t0LVCHgMOJCw\n",
- "ErgHTc45V8MUssWpBTBCUkk5D5mlGLQ7km+Zx7AC1sNVM4qrLpdxEB82+YrRTVqC1oTaDWDp+TBj\n",
- "xQa6EgcBtwKdzZicW6HaEHgWmEBoaVqUU37OOeeqpIIFTmb2PbBjxkQPMoZ5DLOZvlCgy47iqgs8\n",
- "iqjN2GY3Qq07oPcEaNYKMIsWJpPYgzBo+wgzxudWqHYFRgC3AP+gWKvGOuecK7qibvJr39jBxSzf\n",
- "VS1R0PQwUB/oxZKG58HYfvDtCGh9ONRrCyCxDaF1qK9Zwpi6chWqowitVv0xy99eds4556ok33LF\n",
- "VQmKqw6hBakxcITFUneVSWxKmIBwiRkPlb9ACbgCOBk4FLP/lTsv5/LIn53OFVdRW5ycy0YUND0A\n",
- "rAUcliFoagGMBf6RY9DUELgH2IwwCPzncuflnHOuWqmIlcOdKzfFVRu4D1gHODxD0LQ28CLwkFkO\n",
- "kw2k9YHXgeVARw+anHPOJfLAyVVaUdB0L2GG5qEWs5TLVkg0AkYSuuji5S9QOwHvE8ZHHe8z55xz\n",
- "ziXzMU6uUoqCpruBjYHuFrM/U6YTdQkz3n4DTjRjefkK1BHAf4EzMHuyXHk4VwH82elccfkYJ1fp\n",
- "KK5awJ3AJmQOmtYhdOMB9CtX0BQGgV8KnAF0xezjclXaOedcjeBdda5SiYKmO4DWhKAp5b5yEvsB\n",
- "/wO+BnqZsaTshakBYdD54YRB4B40Oeecy8hbnFylEQVN/wG2BA5OFTRJ1CEsE9Af+JsZL5SvMLUA\n",
- "ngGmAPthqVu1nHPOuUTe4uQqhShoug3YGuhmMVuwWhrRCngV2BvYOYegaQfCIPAXgT4eNDnnnMuW\n",
- "B06u6BSXCNuZbE8ImuavlkYcDnwEjCZs2DujfIWpJ2Gtp0GYDfbtU5xzzpWFd9W5ooqCpqHAzsBB\n",
- "FrN5q5wXDYEbgYOBQ814r3wFScBFwEDgEMw+zKXezjnnaiYPnFzRREHTzUB7UgdNWwOPAhOBncz4\n",
- "rXwFqT5hqYHtgT0wm5ZLvZ1zztVc3lXniiIKmm4C9gK6WMx+X3FOSOJU4A1Ca1SfHIKmdYFXCHvc\n",
- "7eNBk3POuVx4i5OrcFHQ9E9gX+BAi9mKoCjaOuUOwsy6fcyYWP6CtC0wirA58JWYlW9xTOeccy7i\n",
- "LU6uQkVB0w3AAUBni9ncFefEnsCnwCxg9xyDpu7Aa8BlmF3uQZNzzrl88BYnV2GioOla4CDgAIvZ\n",
- "rwAStYBBwLnAaWY8U/5CJOA84EKgB2blG0zunHPOpeCBk6sQUdD0d+AQoJPFbA6AxAbA/UA9YFcz\n",
- "ppa/ENUDbgd2IQwCn5JrvZ1zzrlE3lXnCi4Kmq4CehJammYDSHQDPgbeBDrlGDQ1J6zPtA7QwYMm\n",
- "55xzheAtTq4ixIAjgP0tZr9I1AeuA44EjjbjjZxyl7YmDAJ/nDCmycczOeecKwgPnFxBKa4rgd6E\n",
- "oGmWRFvC2kxTCWszzSl7pqoLbAK0BbYBLgYuxOz+vFXcOeecS8EDJ1cwiusy4BhC0DRT4gTC2k2D\n",
- "gdvMSL/dSQiONiUER22Sfm4ETAcmA98APX0QuHPOuYqgYm3VJcnMTEUp3BWc4roUOAnYn8G2gLCB\n",
- "766ExSzHh0SqR+rgqA0hOPqJEByVBEglP3/A7K8KvB3nKg1/djpXXB44ubxTXBcDpwAdNxw8tVVT\n",
- "5j7Wgbe+uoFBrzZh/iasGhxNY9WgKDE4WlycO3Cu8vJnp3PF5YFTJmFNoLr+C7wUYS+4zYA2D2zP\n",
- "qUtqsd/RXzB+8dK1t23En83+ov7MJsz/lNWDox/9s3WubKrEs9O5aszHOGW2NfA60pOEbTverrEz\n",
- "tkJwtDmrjzdqA6wPTP16HZYsqsMGu0xu/p/Tlv77gM/YfuofrLHHt9b6m+JV3DnnnMsfb3EqjbQp\n",
- "0Ac4DmgCPAI8hNnnRaxVYUgNSB8ctQSmsHqr0WTgRw3mTGAgjz1xGROPvJGwqOWVZiyp8Ptwrhqr\n",
- "Ms9O56opD5zKQtqeEEAdA/xGaIV6pEotthiCo9asHGeUGCC1AH4kTXCE2dKUWcY1AOM87nx/NNPb\n",
- "Hw6cZMbLBb8X52qgKvnsdK4aKVjgJKkrcDNQG7jLzG5IOl91v/xSLaADIYjqBUwAHgaewKzs6xLl\n",
- "m9SQ0HKUair/esAPrBoUlfz3lHTBUdqi4jqLZXUu5bbPZzGn3c9AXzNm5etWnHOrqtLPTueqgYIE\n",
- "TpJqA18DBxKmlH8IHGNmExPSVI8vf5hS35UQRHUFXie0RI3C7M8CltuI9MHRuoTgKNVstallDY7S\n",
- "ViGuM1i8xlXc/j8xt821wM1mpBwDphbqRhMGUo8GLGYR8xhqM210PurhXE1SbZ6dzlVRhRoc3h6Y\n",
- "bGY/AEh6FDgUmJjpoiopzAobCYxEagIcBvwN+A/SKEIQ9Uq5gpUQHLUmdXDUHPielUHRp8ATrAyO\n",
- "luV2Y6VU7dK1zmZ5s+u5+51fmNvmKDM+Spu2hbqxEUPoSZsVB0fSWi2EB0/OOeeqkkK1OB0JdDGz\n",
- "U6P3xwO7m9mAhDTV+68mqSVwNHAsYZHHxwhB1AckfujSGqwaHCUGSOuwanCU2HpU8OAoHZ2yx2DW\n",
- "nnIZjzz7PNN3O8GM+RnTt9UYjqfLaiceZIx9YwcXrKLOVUPV/tnpXCVXqBanrKIxSYMT3o4zs3EF\n",
- "qU0xmP0MDAGGILUlBFAPALWQ3iHstdYGaAZ8x8qg6GPCXm6TgWnFCo5SkRDdT3uALaYew/O3XmI/\n",
- "7fbPrC6sR4M0xxvms37OVUeSOgIdi1wN51ykUIHTT0CrhPetCCtEr8LMBheo/MrF7BsgjnQVsAuw\n",
- "IyuDpWlVYW0oiWbsff1Y2j2zHZ+d0M0mHv5i1hcvZlGa4wvzVT/nqqvoD8pxJe8lxYpWGedcwbrq\n",
- "6hAGhx9A2Iz1A6rr4PAaQGIfdr7jGQ66uB4Lm+5lN39fpjWs0oxx+pZpDPQxTs6VjT87nSuuQi5H\n",
- "cDArlyO428yuSzrvX/5KTqI2cDk73XMu3c5aTt1FHSxm5RrgH82qG0A9GrKYhcxjmAdNzpWdPzud\n",
- "Ky5fANOlJNEKeJD2t6xD13OaU2t5J4vZhGLXy7mazp+dzhVXrWJXIB/UQt3UVmO0jcaprcaohboV\n",
- "u05VmcShwEd0umw6Bw9Yh1rLD/SgyTnnnKsGm/z6GkH5I9EA+CfQnT6HDqXdyAFAZ4vZF0WumnPO\n",
- "OVcpVP0WpyYMXCVoAuhJG5owIM0VLgWJrYD3gRact/GVUdDUxWLVcDNj55xzrpyqfIuTrxGUGwkR\n",
- "Vjq/Hvg/rqw9m1rL/0MImsYXt3bOOedc5VL1AydfI6jcJNYC/gtsA+zHYLUF7gAOtpj9r6iVc845\n",
- "5yqhqt9VN4+hjGTyKsdG8i3zGFakGlUJErsT9rebA7RnsNoQgqZuFrNPilo555xzrpKqFssR+BpB\n",
- "2ZOoBVwMnAecbsYIxdUduAc4xGL2YVEr6JzLyJcjcK64qkXg5LIj0ZKwX14D4DgzpiiubsBwoIfF\n",
- "7P1i1s85Vzp/djpXXFW/q85lRaIroWvuHWD/KGjqSgiaenrQ5JxzzpWu6g8OdxlJ1AOuBY4G+pjx\n",
- "OoDiOgi4HzjMYvZeEavonHPOVRkeOFVjEm2AR4GfgB3NmAOguA4EHgIOt5i9U8QqOuecc1WKd9VV\n",
- "UxLHA+8SuuIOSwiaDgAeAY6wmL1VvBo655xzVY+3OFUzEmsCtwK7AweasWIRS8W1P6EF6kiL2ZtF\n",
- "qqJzzjlXZXmLUzUisTPwCbAU2CUpaNoPeBzobTF7vUhVdM4556o0D5yqAQlJnAuMAa4042Qz/lhx\n",
- "Pq59gCeBPhaz14pVT+ecc66q8666Kk5iXeBeYF1gDzO+W+V8XB2Ap4FjLGavFKGKzjnnXLXhLU5V\n",
- "mEQnwtpMXwAdUgRNewEjgOMsZi8XoYrOOedcteItTlWQRF1gMNAX6GvG2NXSxLUH8AxwgsXspQqt\n",
- "oHPOOVdNeeBUxUhsCjwMzAN2NmPmamni2h0YCfS1mI2p2Bo655xz1Zd31VUhEkcCHwBPAd3SBE27\n",
- "AaOAv1nMNzp2zjnn8slbnKoAiUbAv4EDgEPM+DBlurh2BZ4HTrGYPVeBVXTOOedqBG9xquQktgU+\n",
- "BNYgdM2lC5p2JgRN/S1mIyuwis4551yN4YFTBhLrSMQkNi9C2ZI4HXgN+AdwghnzUqaNayfgBeAM\n",
- "i9kzFVhN55xzrkbxrrrM6gHrAO9LTATuA5404/dCFirRDLgT2AzY24xJadPGtQMhaDrLYvZ0Xspv\n",
- "oW40YSD1aMBiFjGPoTbTx0s555xzMrPiFCyZmakohZeRRD2gG3Ai0AkYDdwPjDVjWZ7L6gA8RFh/\n",
- "aZAZf6VNG9f2wEvAAIvZE3kpv4W6sRFD6EmbFQdHMplpnOPBk3PFV5Wenc5VRx44lZFEc+Bo4CRg\n",
- "I0KQc58ZX+SYb23g/4CzgFPMyDi4W3FtC4wFzrWYPZZL2avk21ZjOJ4uq514kDH2jR2cr3Kcc+VT\n",
- "VZ+dzlUXPsapjMyYbcatZrQnzHJbCoyR+FjinGgLlDKR2BB4GdifMAC8tKBpG0JL0wX5DJoAqEeD\n",
- "NMcb5rUc55xzrgrywCkHZkw041JgE2AQsCvwjcSzEr0k6peWh0RP4GNC4NTZjOkZ08e1NaGl6WKL\n",
- "2cM530SyxSxKc3xh3styzjnnqpiCBE6SBkuaJunT6NW1EOVUFmYsM+NlM04AWhHGJ50N/CRxm8Tu\n",
- "Eqs0rUs0kBgKDAWOMOOa0sZLKa52hKDpEovZgwW5mXkMZSSTVzk2km+Zx7CClOecc85VIQUZ4yQp\n",
- "Bsw3s5sypKn2/fQSmwAnEAaVLycMKH8AaAQ8CnwLnGrG3FLzimtL4BXgcovZ8ELVGVbMqhtAPRqy\n",
- "mIXMY5gPDHeucqgJz07nKrNCBk4LzOzGDGlqzJc/am3agzCg/ChCS98g4E4zSv0foLjaEtZzutJi\n",
- "dk8h6+qcq9xq0rPTucqokIFTP+B34CPgAjP7LSlNjfzySzQAmpgxK6v0cbUhBE1xi9ldBa2cc67S\n",
- "q6nPTucqi3IHTpLGAi1TnLoMeA/4JXp/NbC+mZ2cdH2l//Lr/9u7/1iv6jqO48+Xl25QRrRqCkJh\n",
- "cFnpltiKueSPr2sYshKxmdWcZZu2UcnUtRK3vn7LQjNT1NwS7dcYmDMlSEVJvFPWRllQ1IUBLpbk\n",
- "1X5Y0Q8ZkO/+OGfuAvd777n3++Nzvve+Htsd33PO957z2pd9z973cz7nfSTBzK/DvuWRoG+DappF\n",
- "VjTdENW4u93HN7Py6YRzp9lYNurO4RGxoMj7JN0DbKiz7foBi70R0TvaPK0x60JYsBQ2/RJoSlfu\n",
- "olTTO4DNwAoXTWbjl6QKUEkcw8xyrbpUNzUi+vPXVwHvi4hPHPOe0v7VJE27AiYvg/kTYNUcuHw3\n",
- "bDkCB1ZGPN/yIkY1zQR6gZujGt9u9fHMrHOU+dxpNh606ll1N0maCwTwB+AzLTpOi/SvgkkvQdct\n",
- "IKBrIhy5GvpbPuqkmt5OdnnuFhdNZmZm5dKSwikiLm3FftslIkKaHaApcNFOePP0fHVL5zmppreR\n",
- "FU0roxrum2RmZlYy7hxeV3cPp274MtUHpnLe2u3MOvQR1TS5VUdTTdPJ5jTdGdW4rVXHMTMzs9Hz\n",
- "Q36HoZqmAh8GLgDmA1uAdcD6qMYLTTrGKWRzmr4T1fhmM/ZpZmNTp5w7zcYqF04jkI84nUdWRC0E\n",
- "+siKqHVRjT2j3Oc0sqLp3qjGTU2KamZjVCeeO83GEhdOo6SaXgucQ1ZELQb+Rl5EAb+K6vAfbD6a\n",
- "1Qt8P6qxonVpzWys6PRzp1mnc+HUBKrpBGAesCT/mQT8hOxhv09FNQ4P8jsnkxVNq6MaN7QvrZl1\n",
- "srF07jTrRC6cmkw1CXgn2UjUBcBs4BGykaiNUY3/qKaTyO6euy+q8ZWGjpc9kPdKupnIIQ5ygNv9\n",
- "QF6zsWusnjvNOoULpxbL75Y7n6yIOotslGk2cH9U4/qG9n2SFjGdlZzP7FdXrmcv+1nm4slsbBov\n",
- "506zsnLh1EaqaQqwCOgGflBkHtSQ++vRRi7hg8dtWM3G2BPnNbJvMyun8XjuNCuTVnUOt0FENf4B\n",
- "rPNDj9IAAAXTSURBVGnaDruZWGf9pKYdw8zMzF7lBphtJknSqSskNf4X4yEO1ln/csP7NjMzs+O4\n",
- "cGq7WRfCwqUwa0nDuzrA7axn71Hr1vMsB/DjWszMzFrAc5zaRJp2BUxeBvMnwKo5cPlu2HIEDqyM\n",
- "eP7uUe83u6vu83QziUO8zAHu8MRws7FrvJ07zcrGc5zapn8VTHoJum4BAV0T4cjV0P9gI3vNiyQX\n",
- "SmZmZm3gS3VtEhEBCjhhCny0D/SmfHWaIT8zMzMbMY84tVV3D2y6DJ59KJvj1N2TOpGZmZkV5zlO\n",
- "ZmYdxOdOs7R8qc7MzMysIBdOZmZmZgW5cDIzMzMryIWTmZmZWUEunMzMzMwKcuFkZmZmVpALJzMz\n",
- "M7OCXDiZmZmZFeTCyczMzKwgF05mZmZmBblwMjMzMyvIhZOZmZlZQaMunCRdJOn3kv4n6T3HbLtW\n",
- "0h5JuySd23hMMzMzs/QaGXHaASwBnhq4UtJpwMXAacBC4C5JHTuyJamSOkMRztlcztlcnZCzEzKa\n",
- "WXqjLmgiYldE7B5k02JgbUQcjoh9wF5g3miPUwKV1AEKqqQOUFAldYCCKqkDFFRJHaCgSuoABVRS\n",
- "BzCz8mvFSNA0YP+A5f3AKS04jpmZmVlbTRhqo6RNwMmDbFoeERtGcJwYUSozMzOzElJEYzWNpCeB\n",
- "ayLi1/nylwAi4sZ8eSNQjYitx/yeiykzs1GICKXOYDZeDTniNAIDv8TrgTWSvkV2ia4H+MWxv+Av\n",
- "vpmZmXWaRtoRLJH0HHAW8LCkRwEiog+4H+gDHgWWRqPDWmZmZmYl0PClOjMzM7PxIml/JUlflfQb\n",
- "SdslPSFpRso89Ui6WdLOPOuDkt6YOtNghmpKWgaSFuZNUfdI+mLqPIOR9F1JL0rakTpLPZJmSHoy\n",
- "/7/+naQrU2cajKSJkrbm3+8+SStSZxqKpC5J2ySN5MaXtpK0T9Jv85zHTYEws9ZL3ZjyGxFxRkTM\n",
- "BdYB1cR56nkcOD0izgB2A9cmzlPPoE1Jy0BSF3AnWVPU04CPS3pX2lSD+h5ZxjI7DFwVEaeTXSr/\n",
- "bBk/y4g4CJyTf7/fDZwjaX7iWENZRjbFoMzD8AFUIuLMiOjk/nhmHStp4RQR/xqweCLw11RZhhIR\n",
- "myLilXxxKzA9ZZ56hmhKWgbzgL0RsS8iDgP3kTVLLZWIeBr4e+ocQ4mIFyJie/7638BOsv5ppRMR\n",
- "/81fdgNdwEsJ49QlaTqwCLiHo292KaOy5zMb01KPOCHpa5L+CHwSuDF1ngI+DTySOkQHOgV4bsCy\n",
- "G6M2gaSZwJlkBX3pSDpB0nbgReDJ/OaRMroV+ALwynBvTCyAn0l6RtLlqcOYjUfNakdQ13BNNCPi\n",
- "OuC6vP/TrcBlrc40mCLNPiVdBxyKiDVtDTdAE5uStluZL390JEknAg8Ay/KRp9LJR2rn5vMCH5NU\n",
- "iYjexLGOIulDwJ8jYlsHPK/u7Ijol/RWYJOkXfkoqZm1ScsLp4hYUPCta0g4kjNcTkmfIhvK/0Bb\n",
- "AtUxgs+zbP4EDJz8P4OjH81jIyDpNcCPgdURsS51nuFExD8lPQy8F+hNHOdY7wfOl7QImAhMlvTD\n",
- "iLg0ca7jRER//u9fJD1EdgnchZNZG6W+q65nwOJiYFuqLEORtJBsGH9xPuG1E5RtHsQzQI+kmZK6\n",
- "gYvJmqXaCEkScC/QFxG3pc5Tj6S3SJqSv54ELKCE3/GIWB4RMyLiVOBjwOYyFk2SXifpDfnr1wPn\n",
- "kt0QYmZtlHqO0wpJO/I5EBXgmsR56rmDbPL6pvw24LtSBxpMvaakZRARR4DPAY+R3bn0o4jYmTbV\n",
- "8SStBX4OzJH0nKQkl46HcTZwCdldatvynzLeCTgV2Jx/v7cCGyLiicSZiijrZeWTgKcHfJ4/jYjH\n",
- "E2cyG3fcANPMzMysoNQjTmZmZmYdw4WTmZmZWUEunMzMzMwKcuFkZmZmVpALJzMzM7OCXDiZmZmZ\n",
- "FeTCyczMzKwgF05mZmZmBf0f5H1MkKRxL/8AAAAASUVORK5CYII=\n"
+ "AAALEgAACxIB0t1+/AAAIABJREFUeJzs3XecVNX5x/HPlyYooCiKIlZAjSXRxN6CxoYFjL3XaGLD\n",
+ "JGo0JnGYaCy/GKNgSWJssXdFRY2JEnuLLWIDe0EsqICAgHx/f5wLDMvO7uzOzNbn/Xrd1zK3nHPu\n",
+ "6Mw+e865z5FtQgghhBBC/To0dwNCCCGEEFqLCJxCCCGEEEoUgVMIIYQQQokicAohhBBCKFEETiGE\n",
+ "EEIIJYrAKYQQQgihRGUFTpJWkPSQpLGSXpY0LNu/pKQHJL0h6Z+SlqhMc0MIIYQQmo/KyeMkaVlg\n",
+ "WdsvSOoO/BfYFTgU+Mz2/0k6Gehl+5SKtDiEEEIIoZmU1eNk+2PbL2T/ngq8CiwPDAGuyk67ihRM\n",
+ "hRBCCCG0ahWb4yRpZWA94Cmgj+2J2aGJQJ9K1RNCCCGE0FwqEjhlw3S3AsfbnlJ4zGksMNZ1CSGE\n",
+ "EEKr16ncAiR1JgVNV9u+I9s9UdKytj+WtBzwSS3XRTAVQgiNYFvlXB/fvyGUprbPWlmBkyQBlwGv\n",
+ "2D6/4NAo4GDgnOznHbVcXvaHvylIGm57eHO3oz7RzsqKdlZWa2hna2gjVC7oaQ3fvyE0p2KftXJ7\n",
+ "nDYDDgBekvR8tu/XwNnATZIOB94B9iqznhBCCCGEZldW4GT7UYrPk9qmnLJDCCGEEFqayBxevzHN\n",
+ "3YASjWnuBpRoTHM3oERjmrsBJRrT3A0o0ZjmbkAJxjR3A0IILV9ZCTDLqlhyjLGHEELDVOK7M75/\n",
+ "Q6hfsc9J9DiFEEJoVyQdK+lZSTMkXVHC+UtKul3SVEnvSNq3AXW9I+kbSUvV2P+8pDmSVsxeby7p\n",
+ "cUlfSvpc0qOS1q9RzjRJUwq2EdW43+yafSS9mt3zeEmbl3jsGkkTJE2W9Jak39Qot77jdZXdT9Jd\n",
+ "2fszQdJISR1LuZ9KisAphBBCiyNpmKQzq1T8h8DpwOUlnn8RMANYBtgfuETSmiVea+AtYF6wJWkd\n",
+ "oFt2DEk9gbuBC4BepBU48sA3NcrZ2XaPgm1YiW1o0P1K2pb0kNfBtrsDW2T3UOexzFnAKrZ7AoOB\n",
+ "4yTtUM/x7UssewTwGbAcsC7wQ+DoEt+DionAKYQQQks0EthLUsVXnrB9u+07gc/rO1fSYsBuwO9s\n",
+ "T7P9GHAncGADqrwGOKjg9cHAP4C5w0CrpWb5RiczbD9g+38NqKOohtxvJg/kbT+dXT/B9kclHMP2\n",
+ "WNszCsqaTUEuxyLHPy2lbGAt4EbbM7PVSe7L9jWpCJxCCCG0ONmqE9dRR4Ai6W5JXxTZRpVQTSnz\n",
+ "vFYDZtseX7DvRRr2C/tJoKekNbKhpb1JwdRcbwDfSrpS0g6SejWkvZIuknRRCe2o936z9v0AWEbS\n",
+ "OEnvZ0NiXes6VqOMiyV9DYwFzrD9XB3H/2D7uRLLvh/YT1I3ScuTeqzuLeG+KyoCpxBCCAuQcCW2\n",
+ "CjTlSuCQYgdt72y7V5FtSAnll9LG7sDkGvumAD1KuLbQ1aRep22BV0jDZ6kR9mRg86w9lwKfSLpT\n",
+ "0jIF1wu4o0ZweHh2/TG2jymhDaXcbx+gM7B71qZ1SevQ/pY0VFns2PxK7KNJ79s2wBmSNqzj+OnZ\n",
+ "8brqnWs4sDbpv8f7wDNZT1qTisAphBDCAmxUia0CTVkaWLTmL94KKqWNU4GeNfYtTgqeSmVS4LQ/\n",
+ "Cw/TpRPs12wfansFUnDQFzi/RhlDawSHlzWgDdSss4jp2c+Rtifa/hw4D9ixnmMLyIYcxwA3UzC/\n",
+ "q47j0+oqW5JIPU43A4sCvYElJZ1Twj1VVAROIYQQWpxsQvGGwBnAoUXOubfGU2aF2z0lVFNKD8wb\n",
+ "QCdJAwr2fQ94uYRr51dkv0ea6DwYuK2ec18HriIFUJVU7/3a/gL4oPZD/rLIsbp0Br6u73gJZfcm\n",
+ "DeVdaHuW7UmkHsmFgrZqi8AphBBCiyJpP2Br2yNJPQy71JxHA2B7cI2nzAq3neoov2NWXiego6RF\n",
+ "ij3WbvtrUqDze0mLZo/H70LqQWqow7P7ml64U9Lqkk7I5u0gaQVSL8wTNZveiDobdL+ZK0hPuy2d\n",
+ "zbf6Bempv2LH7srqWTpLJ7BYVuf2wJ6kyfT1Hq+rbNLTdBOAo7JrlyD13r3YmPekLLabZSOb+xdb\n",
+ "bLHFFlvpWyW+O1vy9y+wMXB5jX0XAodUsI7hwJwa22kFx0cDpxS87gXcThq2ewfYpwF1vU0Klmru\n",
+ "7wR8C6xIGpa7kdTjMjX7eQnQvUY500hDhHO3W7NjfwEuqeD9diKlYPiCFKycD3Qp4VhvUgb+L4Av\n",
+ "gaeBIQXl1ne8aNnZ8Y2AR7LjnwI3AEtX8f/FWj8nkTk8hBBakUp8d8b3bwj1K/Y5iaG6EEIIIYQS\n",
+ "ReAUQgghhFCiCJxCCCGEEEoUgVMIIVSBJEmrnJXlnwkhtBEROIUQQlX03w12OBr6/7i5WxJCqJwI\n",
+ "nEIIoYKkvkdKa4yFQWfCxT1h0FnSGmOlvkc2d9tCCOXr1NwNCCGEtmXCpdBtEnT8U8pX2LErzP4l\n",
+ "TKgzW3QIoXWIHqcQQqgg2wYZOiwBe70C6pXtbp6keSGEiooepxBCqLguA+GBQ+HN29Mcpy4Dm7tF\n",
+ "IYTKiB6nEEKoMPuVs+3xt9l2+vlKk6/gHoqTtKSk2yVNlfSOpH3rOf9YSc9KmiHpigbW9Y6kbyQt\n",
+ "VWP/85LmSFoxe725pMclfSnpc0mPSlq/RjnTaixkPKIa95tds4+kV7NrxkvarNT3opZrN8/2d5F0\n",
+ "WdaGydl7sEPBdd+R9GD2HoyTtGuNcvtJuit7fyZIGlnPmntVEYFTCCGEFkfSMElnVqn4i4AZwDLA\n",
+ "/sAlktas4/wPgdOByxtRl4G3SIv2AiBpHaBbdgxJPUmL6F5AWhdveSAPfFOjnJ294ELGw0psQ4Pu\n",
+ "V9K2wNnAwba7A1uQ1sqDet6LIte+lR3uBLwHbGm7J/Bb4CZJK0rqRFrsd1T2HhwJXCOpsLd2BGmx\n",
+ "3+WAdYEfAkeX+B5UTKxVF0IIrUh7Wasuy381DtjM9sQKlrsYMAlYy/b4bN9VwEe2f13PtacD/Wwf\n",
+ "2oD63gb+Dgy1vWG279ysDWcAK5MCmgds96qnnMNtP1hq3dl1Db5fSY8Dl9ou2rtW7L0o5doa579I\n",
+ "WoR4HPCE7R4Fx+4HnrJ9Wvb6deB42/dlr/8P6Gn7Z6XU1VCxVl0IIYRWI5tMfx1wYLFzJN0t6Ysi\n",
+ "26gil60GzJ4bRGReBNYqoVmNDTafBHpKWiMbWtobuKbg+BvAt5KulLSDpGIBVK31S7pI0kVFrmnQ\n",
+ "/Wbt+wGwTDZc9n42JNa1vrY04Nq55/fJ2je2SNs7AGsXvL4f2E9SN0nLA4OBe4tcWzUxOTyEEMIC\n",
+ "lFdFhiKcK7tX60rS0M25tZZv79yIMrsDk2vsmwL0qOXchapsRH1zXQ0cBDwMvEIa8kqF2pOzeUAn\n",
+ "A5cCy0oaDRxh+5PsNAF3SJpdUOaJti+zfUwd9Tb0fvsAnYHdgc2B2aQhtN9m27xml3EtkjoD1wJX\n",
+ "2n4je/2JpJOA84GtgC2Bwh624cC/svvpmF17Z5H7qJoInEIIISygAgFPpSwNLCppQ9tPV6jMqUDP\n",
+ "GvsWJwUT9Wns+2JS4PQIsArwj5pl2X4NOBRA0uqkHqnzgf0Kyhja0KE6Gn6/07OfI+cOkUo6j4WD\n",
+ "n9rei5KuldSB9H7MAI4FsD0rmww+khRAPgPclJ0zd+j2fuBmYCNS4He5pHNsn1zH/VdcDNWFEEJo\n",
+ "cbKnrTYkzQOqdU6RpHtrPGVWuN1TpOg3gE6SBhTs+x7wcgnNanSPk+33SJOkBwN1JkO1/TpwFQsO\n",
+ "UzVWg+7X9hfAByWUu9B7Ucq1WQB0GSko3t32twXX/8/2INu9bQ8G+gNzA+bepGHAC23Psj2J1CO5\n",
+ "YwltraiyAydJl0uaKOl/BfuGS/oge9RwgccNQwghhLpI2g/Y2vZIUg/DLrXNk7E9uMZTZoXbTrWV\n",
+ "bftrUuDye0mLZkNku5B6QIq1p2NWfyego6RFGvkY/OHZfU0v3ClpdUknZPN2kLQC6Sm8J2o2paEV\n",
+ "NuZ+gSuA4yQtnc23+gVwV9a2+t6LotdmLgHWAIbYLnxqEEnrSOqatfNE0tDfldnhz4AJwFFZG5YA\n",
+ "DibN12patsvaSI8argf8r2BfDvhlPde53Lpjiy222NrbVonvzpb8/QtsDFxeY9+FwCEVrKMXcDtp\n",
+ "GOsdYJ8ax0cDpxS8Hg7MqbGdVmJdb5OCpZr7OwHfAisCfYEbSb01U7OflwDda5QzjTTENne7NTv2\n",
+ "F+CSCt5vJ1IKgy9Iwcr5QJdS3ot6rl0pO7/mfeybHf8/0hOAU4B7gFVrtHMj0nDnF8CnwA3A0lX8\n",
+ "f7HWz0lF0hFIWhm4y/Y62escMNX2n+q4xm7hj8OGEFooqQv2zOZuRnNoL+kIQmhuzZGO4DhJLypl\n",
+ "CV2iivWEENoLSUi/AaYh/R1p6eZuUgihfalW4HQJ6cmBdUlddUV7nkIIoSRSj0n0uv81Vj9+LV6e\n",
+ "MYpdvjcHvYJ0DCnrcAghVF1VAifbnzhDypi6YW3nZZPI526DqtGWEELr91udset7rPDh7fx4iw0X\n",
+ "uf+vr+x25k+Gdv/L2PV4Xu+w0vGGZ8nWw2prJA0q/K5s7vaE0N5Va47TcrYnZP/+BbCB7f1qXBNj\n",
+ "7CGEOklsfiiXn/9/nLjeyIEDnv39Pi98QsdZW5ImuK7KrG4T9NpO3Q74b/fFLn73ei/mb0YLfkX2\n",
+ "/dMWxRynEJpGsc9J2YGTpOtJC+31BiaSnqgbRBqmM+lJgJ+6xlpD8cENIdRGQsB2HZZ9+vTfdzlx\n",
+ "7UM/f6zzHnvPmfHEitxHykI82jlPUl6dgXWxNuPLlXbv7qkb//bJqfrZC9/MGb2aR/98B876pDvP\n",
+ "OedZzXtHlRWBUwhNo2qBU2PFBzeEUEhDjuzEVyv8ip4fDFu83/29rv/n+1r5qzmfHbsTv3hwVe5w\n",
+ "bsGcLwtdv8zYzvT46NerL/LUSX/9/M/qO2tS52N25tsH+vMk8Fi2PeGcv2qSG6qSCJxCaBoROIUQ\n",
+ "WhzltRgzFx3MpAHD6PnBpkxb+ptN3+7yn3/d/7+1us7mTsEJuGE9RhK9xJzf7MZtR/5NP/n2i55T\n",
+ "xu6195znnuvLd4H1gTeZH0g9BrzrXDN9ETZCBE4hNI0InEIILYLyWg7YmTkdf4w7bMX7m8DbW73P\n",
+ "Z2sMnz12/286MucvwInYV5VVj+jfg8l//A1nbn0853fowsyzz9vUI07ajjWBzUiLkG7GW3TidWYx\n",
+ "h6lM41MmcZY/8l31FN9sInAKoWlE4BRCaBbKS8CawFBgCGZ1Pl7vHZ78+UqM3/4pvu7ze6OngdNJ\n",
+ "C5rujv3fitUvtvgOr1w0kuP6bcITXy/K9J9ijwZQH+3IilzMzqw074J/YVbgJVZnFPOH92quLt9s\n",
+ "InAKoWk0RwLMEEI7pbw6Ka9Byus8YDwwmm+6r8Q9I9/gjBmz+etzr/HiQVt5ap/BRq+TllfYGNig\n",
+ "kkETgM0jr7Lmutvw7+P347quH7HcjZPV8wGkVenJsAWCJoBtEGOZTVo64lTgI+X1gvK6SHntp7xW\n",
+ "yoLB0EpJOlbSs5JmSLqiluNLSrpd0lRJ70jat46ySj63yPXvSPpG0lI19j8vaY6kFbPXm0t6XNKX\n",
+ "kj6X9Kik9QvKmFZjkeMRDWhDJd+P70h6MGvnOEm71jh+jaQJkiZLekspoW1J9ZTTzmxf4fszuyHv\n",
+ "UaFIGhdCALLel54MowtdmckMJjPCE1PPTEnX59UD2J7Us7Qj6YnaUby+y5Fcf8cO0OEw0npZm9qM\n",
+ "Sxfpu9m+O4CTsWdX+LYAsJkDXC3teuuDbP2rn3P+SSdzzsv9Pf3TN2tb8H42U53zqdl9dQG+Txre\n",
+ "2wP4MzBLeT3K/HlSLzlXnba3V5KGAcva6b9DhX1I6uHcHuhWy/GLgBnAMqS1WO+R9KLtV8o8tzYG\n",
+ "3iIt6nshpMVus3Y5e90TuBv4KXATsAhpndgZBWXsbPvBEuusqSLvh1Ii2juBi4EfkZ6wv0vSerbH\n",
+ "ZaedBfzE9gxJqwP/kfSs7ftLqKfR7bTdvaCdiwEfk97LBouhuhBCCpr6cQFDGDBv5yjG8wHH1xU8\n",
+ "Ka9+pJXWhwKbAo+TvjjvYrg7AycB+5BWYj/X5v35F2sfYCRwPPZ1lb+r4iT6rsXLf+7Yd+s9Xjry\n",
+ "04V73q/hPo/z4FqvTb1N/Zk7Rypt/YCnSUHUo8CTznlKddrePobqJAkYB2xWM51NBes4Hehn+9CC\n",
+ "fYuRFppdy/b4bN9VwEe2f13j+pLPraMNb5MSRQ+1vWG279ys3DOAlUmBwAO2e9VRxuFlBE5zyyn3\n",
+ "/VgbeMJ2j4J99wNP2T6tlvpWB/4NDAFeb0A95bbzYOB3tgdQh2Kfk+hxCqEVKrd3aCE9GbZA0AQw\n",
+ "hAFcw3GkldNTvSlo+C5z5yulpZVGA5cBeznnyRLfAc4k9Tr9FVjD5pP5jVcn4GxgN2Ab7Bcb3e5G\n",
+ "svkI1t5bi296bLdbHjt3+h6fLTLv4CjeZDIji16bnsAbn21XAiivpYBNSMHUacB6ymsccO/cnqvQ\n",
+ "MLYt6TrgQODc2s6RdDcpcK3NI7aH1FNNbcHjasDsub98My+Sek/KObcuTwIHSlqDFCzuTbqvM7Lj\n",
+ "bwDfSroSuIEUiHxRo4yigbCkiwBsH1NPO8p9P2rTAVi7RnsuBg4m9Zwda/s5Ses1oJ5y23kw8I8S\n",
+ "27+QCJxCaGWK9A71Vx/R6OCpC12L7O+WJZr8ISlQGgLMIfUqnQg8NjfBpMQPNJxTScHDBcAwltGm\n",
+ "9OQfWisFeKtP4srX4AhgNrA+9qRGtbdC/NUdF2rpjm/pyr5nLE+ntVeb+WGnrSYtPv63MyY93KBy\n",
+ "cv6cNJRyN4DyWoQ0vNev8q1uAlJlhiLK79W6EhhFkcDJ9s5lll/bfXYHaj4MMAXoUea59bkaOAh4\n",
+ "GHiFNCyVGmlPVlpS6GTgUmBZSaOBI2x/Qgok7pBUOFx8ou3LsuvrC5jmVVXLvobc4+vAJ5JOAs4H\n",
+ "tgK2BBboCbN9tKRjSN8rt0h6jhRElVpPo9spaaWsTYfSSBE4hdDalNg71CAz582VWFAPVgM+IX0h\n",
+ "jgJ2Al4pzHsksSVpEvVapF9wB9pMqy3Am3EzP/rzdG7/xXT2xf62MU1NQzgrnwnvnOoKzDXwp9+O\n",
+ "BkZLdFmG/57cn3NPncT9EyZpwAkDePNSGlFHlqzziXLb1mxazjDe0sCikja0/XQVyq/tPqcCPWvs\n",
+ "W5z0S7icc+tiUuD0CKkX9x8122b7NbJf9tkQ1zWk4GS/7Pqh5Q7V1awzU/I92p6VTQYfSQryniHN\n",
+ "I1ro+yX77I6RdDNpftdVpdZTZjsPJPVGvltLGSWJp+pCaG3q6B1qdJmTGcHdLPhF8k+msSS3AGs6\n",
+ "542d85nOeaxztoQkBks8QhqmuxkYYHOBzTSg1gDv3T3p9Mvl6dHYoCnpvxvscDT0/3Hjy1iYzcz/\n",
+ "+gen78f1yx/HyNHT6XbxW6wy/i2t+v1K1hNKI2kH0gLxZ1Ckd0DSvTWelCrc7imhmtqC4jeATpIK\n",
+ "/9/9HvBymefW3RD7PdIk8cHAbfWc+zop0FirofXU14xa9jXoHm3/z/Yg271tDybNB6wr6O0MfN3A\n",
+ "espp50Gk967RoscphNamWO/QTKY3pJhsvtL3gaEczRDeZglG8yGz+ZKpfMSXnF9z6E+iI2lu0qlA\n",
+ "R9JcpltsFn6irMIBntT3SOh5PAzqBBf3hCPOktY4HSZfYH/0t8aUWRubSbD/3ktphzWO54Ibj+bi\n",
+ "Z57RBvetxhv7L+6vvqxUPaE4SfsB69r+laQewO8l/cL2Av/vZ7+YG1N+R9Iv7E5AR0mLkObHfGv7\n",
+ "a0m3ZXX+hPQZ2YU0h20BDTm3RIcDS9ienj2hNre9qwM7AzfY/lDSCqRemicLb6uRdVbs/cjKWoc0\n",
+ "T6sDcDTQh7lzAaWlSU/b3UXqhdoG2BPYxva0+uopt52SNgX6kv7Qa7TocQqhtZnMCEYxfoF99Uxo\n",
+ "nkt5LaK8dlBeFwPvA9eTHus9llVYyk+5n//rtf26tysMmiQ6SxwCjAVOIE2A/p7NDbUGTUDXb2r9\n",
+ "q7DBAd58Ey6FWTno2DX9jujYFWaflvZX3ude6rXT/Pvv7c2Nu49nwEaz6PzJv7TNcKT43qwiSRuT\n",
+ "fpH+CsD2FFK6in0qWM3vgGmk4aQDgOnAbwqOH036XHxCGhL7me1Xs/aNlnRKKec2lO23bD9XuCv7\n",
+ "OYXU+/aUpKmkYeCXSJ/Fue6q0eN269wDki6RdEkdVVfy/TgQ+AiYSJrjtK3nL5tk4GfAB8DnpNQC\n",
+ "B9p+pr56ym1n5iDgVttf1/Fe1CvSEYTQCmVP1R1HF7oxk+lMZmSxieHKa0nSE25DgW1Jwc+dwCjn\n",
+ "/Fqd9YhuwGHAr0h/RZ4JPGQXCYrmX7jhrV24+6dr0PHz3Vhy3v5RvMkHDGvsJHZpwO6w7eXw+Qew\n",
+ "5Arwr0Ps8XUOa1SCRMejuei0w7ns192Y/tVY1jp4D9/S+KcYy2pL+0hHEEJzK/Y5icAphDZIea3K\n",
+ "/JQBPyA91TIKuNs5f1LXtQASPYGjgJ8DTwFn2TxVWuU6nJTk7ggtw6xSA7zSil7zFJj5Brx5e5rj\n",
+ "1GWg/co5jS2voQZqXI+juOTa/bl25/+xzvPvstJuh/uyRk8ybYwInEJoGhE4hdCGKa8OwAakQGko\n",
+ "0Js0j2AU8G/nPK2kckRvYBgpaPoncLbN/0prhLqQ0hBsBeyK6+7Nas2O0KVrDebeW7bgkdXuZfC1\n",
+ "b7PK4TnnZ9V/ZfkicAqhaUTgFEIbo7y6AVuTAqVdSFlzR5GG4Z52znNKLkv0Jc2XOBS4BTjH5s3S\n",
+ "G6O5Ey4/AQ7GLWdR3Go6U6fuO5h7/9KJ2Z3vYNeTf+fT651nVq4InEJoGhE4hdAGKK/epKdrhpCe\n",
+ "TnmBbIkT5+atBVV6eWJV0kTLPUlPvpxn80EDC9kMuBH4C3AmLj1gawuGa7j68+aft+WBY59mw49u\n",
+ "Y7d9rvQhj1ervgicQmgaETiF0IzKSdqovFZj/hDcd4EHSD1L92QZqxvRHtYGTgF2AC4BRth82sBC\n",
+ "RFp09PfAIbiMJV/agNu0W+8eTLl5PZ7/4bXs/8ilHLHXy1674musReAUQtOIwCmEZjT/abAHDq3v\n",
+ "KTDl1RHYiPmTuxdn/hDcQ8659jxOJbWDDUg5mDYhZR2+2F5omYJSCupKWol8I+DHuOG9XW3VvRq8\n",
+ "6Qq8f6Pwcpdw1F8v4thj630KsQEicAqhaUTgFEIzmJ+0cfNOcOlqcMQb8OjsmkkbldeipFQBQ0hD\n",
+ "cRPJUgYA/23IfKWF24BIa0L9Blgd+CNw2bwM3w0vcAXgVuBd4FDsqY1tW5sl6WG2OK4HUw5djxe+\n",
+ "35hlW+ooOgKnEJpAsc9JZA4PoaomXArdJkHHPxUkbfwlTLhNefUhBUlDSSt4P0MKlM5wzm+XW3MW\n",
+ "MO1E6mFaCjgbuNZmZhmF/pCUNPN84I+VDAjaFNtbwgjSFkJoQyJwCqGKbFsaYOiwBOz5Ciy5Ej+c\n",
+ "tCtbcQLwHeB+4AbgYOf8RSXqzJZF2YMUMJmUtPJWm8avD5fmMx1H6rU6EPufFWhqCPWSdCXwvu3f\n",
+ "NXdbQoAInEJoAl0GssVNt7L1pC14ebHpvN2jP5AD/uOcG9/7U4NEF9JyBycDnwK/Bu4te36N1A34\n",
+ "K2li+ibYb5XZ1BAawtS+qOtCJI0BrrZ9WWMqqlSQJmll0oK9ndzOnjJtDyJwCqHahr86DdgU2Jt1\n",
+ "vn7et0yt6PCWxKLAT4ATgVeBI4CHKzIhOf0CuC0rd1NcWiLN0HqV8wRoJcuoWWSJ57W0oeOYR9YG\n",
+ "xWKVIVSR8tqDtM7bDs75OecqOUmYxSV+TfrLdhCwu832Nv+pUND0I9Lq61cDB0TQ1F703w12ODot\n",
+ "adP0ZUhaT9JzkiZLugHoWnCsl6S7JX0iaZKkuyQtnx37A7AFcGG2yO2IbP8Fkt6T9JWkZyVtXqTe\n",
+ "I4H9gF9l19+Z7e8r6daszrckHVdwzYZZmV9J+ljSudmhh7OfX2ZlbdTQ9yG0YLabZUtVN0/dscXW\n",
+ "FBvD2ZLhfMJw1q1ouXhp8Bngz8BXg9eqaNtBhhMNEwxbNff7GFvN//64GmXAckfC6mPh8NdhjtPP\n",
+ "1cfCckeWXm55ZQBdSE9rHg90BHYHZgK/z44vCfyYFEx1B24Cbi+4/iHgsBpl7g/0InUU/BKYAHQp\n",
+ "Uv8Vc+vKXncA/gv8ljRCswrwJrBddvwJYP/s34sCG2X/XgmYA3Ro7v9fYmv8VuyzFj1OIVSB8lqL\n",
+ "tATJfs75hYqUKfpJnA+8TlqLbkObA23GVqL8rJLFSE/N7QNshP1QxcoOLdyES2FWLj35Oe8J0NPS\n",
+ "/iYrY2PSvKALbH9r+1bS06YA2J5k+3bbM5zSYJxJSrVRaIHhMdvX2v7C9hzb5wGLkNJyFFN4/QZA\n",
+ "b9tn2J5t+23g76TPB6SgbqCk3ran2X6qljJCGxOBUwgVprz6AaOBE5zzv8ouTwyQuBR4CZgNrG3z\n",
+ "M5vKTtKW+pP+gp4BbIH9XkXLDy2a7ayzscMSsNcroF7Z7pKHfStQRl/gwxr73iULRCQtKumvkt6R\n",
+ "9BXwH2DxNKdqfjMKL5Z0oqRXJH0p6QtSQtneJbZnJaCvpC/mbqSHLpbJjh8OrAa8KulpSTuVWG5o\n",
+ "xWJyeAgVpLyWAO4FLnLO15RVlliH9CW9LXAxMNCmUUuslFDZDsBVpOVTLqYBvyxDW9JlIDxwKLx5\n",
+ "e5qf1GVgE5cxAVi+xr6VgPHZv08gBSob2v5E0rrAc6TAaqGn7yRtAZwEbG17bLZvEsV7hGr+f/8e\n",
+ "8Lbt1Wo92R5PmheFpN2BWyQtWUs5oQ0pO3CSdDkpyd4nttfJ9i1JWvRzJeAdYC/bX5ZbVwgtmfJa\n",
+ "BLidNM/ij40uR2xMysG0AXAe8FObKRVp5MKViRScHQvsgf1IVeoJrYL9ytkFL+tcGqhKZTwOzJY0\n",
+ "jLSG4i5NhsJkAAAgAElEQVSkz8G/s+PdgenAV9nvmVyN6ycC/Qte9yD10n4mqQtpfcaeddQ/EVi1\n",
+ "4PXTwBRJvwJGkobmvgN0tf2spAOA+21/CnxFCpjmkNKBzMnaEssRtTGVGKq7grRQaKFTgAeyKP3f\n",
+ "2esQ2izl1YHUY/M58IuGPj0nIYkfSfyblBDzPmBVmz9WMWjqAdxCWuZlgwiaQnOzPQvYDTiE9Fna\n",
+ "i7S8z1znA92Az0hB1r0s2LtzAbBH9sTd+aTP0X3AG6Q/4qeTepGKuQxYMxuWu80pB9POwLqkp1c/\n",
+ "Bf7G/OBre+BlSVOAPwP72P7G6QnUPwCPZWVt2Ii3I7RQFVmrLkv2dVdBj9NrwA9tT5S0LDDG9ho1\n",
+ "rrFjraTQRiivc4ENge0asgivRAfSF/OpwBLAWcB1NrOq0tD5Fa8G3AE8ChyH/U1V6wsVE2vVhdA0\n",
+ "mnqtuj62J2b/ngj0qVI9ITQ75fULYDCwealBk0QnYE9SwDSL9NfpHS5nWZRSSTsDlwO/xf5bfaeH\n",
+ "EEKYr+qTw21bUq3dWpKGF7wcY3tMtdsTQiUpr71JuWE2K2WtOYlFgINIy6JMIE1cvd9ugsmkUgfg\n",
+ "d6TM4kOxn6h6naFskgaREpyGEFqAag7VDbL9saTlgIdiqC60NcprECkB3zbO+aU6zxWLkQKWE4H/\n",
+ "AWfaNN2cImlxUgbwJUmTwD9usrpDRcVQXQhNo9jnpFp5nEYBB2f/Ppg0lyKENkN5rUN6cnTvEoKm\n",
+ "pUnZh7cAhtoMbuKgaU3S00HvAVtH0BRCCI1Xdo+TpOtJmVt7k+YznQbcSfpLfEWKpCOIv3hCa6W8\n",
+ "VgAeA37lnG+o81zRg5Se4F6bslZcbxRpN+CvwEnYVzZ5/aHioscphKZR7HNSkaG6xogPbmiNlFcv\n",
+ "4BHgCuf8pzrPFV2Be0h5XI5qknlM8yvvSEpmeQCwO/azTVZ3qKoInEJoGk39VF0IbY7y6koadn6A\n",
+ "lJiy+LmiI3AtMAk4pomDpl7AdaR8Nxtgf9JkdYcQQhsXa9WFUEB9tKMG6j6tpTEaqPvURzvCvASX\n",
+ "VwMfk9agKxoISYiU9bgncECTpBiYX/l3gWeB14BtI2gKIYTKih6nEDLqox3pxwUMYcC8naPorz6C\n",
+ "o9keWBrYwTnPqaeoM0iZhn9k03SJJaW9gQuBn2Nf22T1hlBFkq4E3rfd9HMEG0HS/sBBtrev5Lmh\n",
+ "5Yg5TiFkNFD3cQALf4GN4nWGMJuU4LLONRclfg78DNjc5rPqtHShSjuRMo7vAfwY+4UmqTc0i/Y2\n",
+ "x0nSFaTA6bQSzh0DXG37skbWdSWtKEgL1RVznEKoTxe61rq/OysDA0oImg4kJcNsyqCpN2ltOwPr\n",
+ "Y3/eJPWGNkl9tCM9GUYXujKTGUxmhCd6dFOXUVuxJZ5X1Z4ASZ1sz65mHaHlizlOIcw1k9qXS/mM\n",
+ "Z5zzB3VdKrET8Edge7vORUQrR1oPeIaUI2pwBE2hHPOGqg9ge/bihxzA9vTjgrnz/JqsDGk9Sc9J\n",
+ "mizpBpj/B42kXpLulvRJtpDvXZKWz479gZQr7UJJUySNyPZfIOk9SV9JelbS5kXqPRLYD/hVdv2d\n",
+ "2f53JP1K0kvAFEkdJZ0iaXzWxrGSdi0o5xBJjxS8niPpp5LeyBb8vbCOc7eT9LqkLyVdJOk/kg4v\n",
+ "9b0LTSMCpxDmmswIRjF+gX338CGfcVZdl0lsDlxJSm75avUauEClBwL/BE7GPpn4KziUqyfDFpjf\n",
+ "BzCEAfTkuKYqQ1IX0pOrVwG9gJuB3ZnfkyTgMlKOwBWB6aR5fdj+DSlVyDG2e9gell3zNPC9rLzr\n",
+ "gJuzehbgtG7jtcA52fVDCw7vQ1qPcgnb3wLjgc1t9wTywDWS6lqTdSdgfeC7wF6SFpoSoNR7fDNp\n",
+ "OaYlgdeBTahyL1pouAicQsh4okfzAcdzA//hQWZyOy/wLkfWNcwg8V3gNmB/m6eq3kipM9L5QI6U\n",
+ "BfymqtcZ2odiQ9Vd6NaEZWwMdLJ9ge1vbd9K6lUFwPYk27fbnmF7KnAmKQFzoQWG9Wxfa/sL23Ns\n",
+ "nwcsAqxeRxtqDgsaGGH7Q9vfZGXe4iwDv9NncBywUR1lnm17su33SQlx163lnB2Bl23fkbV1BOkp\n",
+ "3tDCxBynEAodzZPAMqSs4BfUdarEqsC9wHE2/6x626RlSBn5p5HyM9W7qHAIJSs2VD2T6U1YRl/g\n",
+ "wxr73iULZiQtCvwZ2J7UgwTQXdks3uz1Aj00kk4EDsvKNilNSO8S2zPX+zXKPAj4BbDy3DYAS9Vx\n",
+ "fWEANA1YrJZz+gI1pwTUOUUgNI/ocQoho7y6kdZZvKeEoGlZ0lDZH2xurH7jtAEpP9OjwC4RNIWK\n",
+ "q22oehRvMpmRTVjGBGD5GvtWYn4wdAKwGrCh7cVJvU1ifi9RzaBpC+AkYE/bS9juBXzFwr1KcxUb\n",
+ "Fpu3X9JKwN+AY4AlszJfrqPMUn0E9CuoR4WvQ8sRPU4hAMqrI3ANaSHck+s8VywO3AdcbXNx9Run\n",
+ "w4BzgCOxb696faFd8kSPVh/BNRxHF7oxk+lMZmRDnoirQBmPA7MlDSMlkd0F2AD4d3a8O2le01eS\n",
+ "liQNWReaCPQveN0DmA18ls1rOoXU41TMRGDVetq4GCmQ+gzokPU+rV3PNYUKA71Co0kT24eSlmr6\n",
+ "GbBsA8oNTSQCp9DuKS8BFwBLADvWleBSYm6v1COkteCq2DB1Ac4Htga2xG6aieeh3coCnLJSB5RT\n",
+ "hu1ZSgtTX0pKJDsauLXglPNJE7w/Iw3pnQcMKTh+AXCVpKOAf5DSg9wHvAF8TRrmq+up18tIk8e/\n",
+ "AB6yvVstbXxF0p+AJ4A5WT2PFp7Cgj1XNXuxCo/P+7ftzyTtCYwgTY6/ltTL3HRJdENJIgFmaPeU\n",
+ "18mkx5C3dM5fFT1PdCJ9iX9NWkqlvgziZTRKywG3kH5BHISLtyu0L+0tAWZ7JakDaW7Vfrb/09zt\n",
+ "aY+KfU5ijlNo15TXgcBRwOB6giaR5jUsAhxS5aBpE9KTRPeTMoFH0BRCO5DlcVpC0iLAqdnuJ5uz\n",
+ "TWFhMVQX2i3ltS1wLrCVc/6ontPPAb4DbGMzszoNkoAjgdOBw7Dvrko9IYSWahPSUGQXYCyw69wU\n",
+ "CKHliKG60C4pr/VIPTq7O+dH6jxXnAQcAmxhM6k6DVJXUiK/TUi9TG9UpZ7Q6sVQXQhNI9aqCyGj\n",
+ "vFYB7gaOKiFoOpT02PHmVQya+pHmTr0PbIw9pSr1hBBCKFvMcQrtivLqTXrK5iznfGud54qhpMzE\n",
+ "29lVSkQnbUlaEuJ2YM8ImkIIoWWLHqfQbiivRUmpBG53zhfWea74IemR6ME2lR82S/OZjgV+CxyM\n",
+ "fV/F6wghhFBxETiFdkF5dQKuB95k/tMqtZ8r1iMttrmPzX8r3xh1A/5CWq9qE+y3Kl5HCPWQFIvH\n",
+ "htAIETiFNi9LcHkhsCiwZz0JLgeQsvYeZfNg5RujlUiLAr8BbIr9dcXrCKEeMTE8hMaLOU6hPTiV\n",
+ "tHL57s65aCoBieVI68/lbOqc/9Qo0tbAU6SMwPtF0BRCCK1P9DiFNk15HQL8BNjUOU8uep7oRUpP\n",
+ "8HebSyvbCAn4OWkNvP2x/13PFSGEEFqoCJxCm6W8dgDOBgY55wlFzxOLAneRFhI9q7KNUBfSYqXr\n",
+ "k1INvFPR8kMIITSpCJxCm6S8fkBafHNX5/xa0fNEZ+Am4G3gBHuhBTnLaIR6k/IzfQlshj21YmWH\n",
+ "EEJoFjHHKbQ5ymtVUg/Skc758aLniQ7A5dnLwyq6/py0Jmk+0xOkTOARNIUQQhsQPU6hTVFeS5MS\n",
+ "XJ7unO8oel5atPdPwCqkBJezKtcI7UDq7ToJ+6qKlRtCCKHZReAU2gzltRhpKZWbnfMl9Zz+a+BH\n",
+ "wA9tplWmARIwDDiF1Mv0WEXKDSGE0GJUNXCS9A4wGfgWmGV7w2rWF9qvLMHlDcBrpGzcxc8VR5Ke\n",
+ "tNvc5ovKNECdSbmiNiUltXynIuWGEEJoUard42RgkO3qLI4aAvMSXF4MdAZ+4pyLTvCW2B3IkXqa\n",
+ "PqpMA7QkcAswjTQJvGjagxBCCK1bU0wOL5qhVgN1n/poxyZoQ2jbfgf8gJQVvOhcJYmtSakBdrIZ\n",
+ "X5GapdVJk8CfA4ZG0BRCCG1btQMnA/+S9KykIxY6egDb048LIngKjaW8jgAOAXZyzlOKnifWJw3l\n",
+ "7WnzQmUq17bAw8DZ2Cdif1uRckMIIbRY1R6q28z2BElLAw9Ies32I/OOPgT0YADfcIGkabbHVLk9\n",
+ "oQ1RXodgcvy5391M/mAiuSLnidVJ6QmOsPlPZSrX0cBpwF7YlSkzhFpIGgQMauZmhBAyVQ2c7JSt\n",
+ "2fankm4HNgTmB05bZT8/5UN/GUFTKJ3yOhD4A1f0PZvJO58BD/yTtHjugueJfqSlVE61ubP8itUJ\n",
+ "OB/YmjSf6c2yywyhDtkflGPmvpZU5E+EEEJTqNpQnaRFJfXI/r0YsB3wv1pPnsn0arUjtD3Kaz+e\n",
+ "WnQEp682nfcGHwsX94RBZ0lrjJX6HjnvPLEUKWi6yOaK8itWL+BeYADpybkImkIIoZ2p5hynPsAj\n",
+ "kl4gTZ692/Y/FzprFG8ymZFVbEdoQ5TX3sCfWH/a5nw7+xTo2DU9f9CxK8w+DSZcCiAxN6fTPTZ/\n",
+ "LL9iDSRlAR8L7Iz9VdllhhBCaHWqFjjZftv2utm2tu2FF0+9hvv4gGGe6NHVakdoO5TXnqRhsu38\n",
+ "e48FGTosAXu9AuoF2LYlupDWiHsVOLn8irUV8CjwZ+yfY88uu8wQQgitUrNmDvc4D27O+kProbx2\n",
+ "A0YC2zvnbMi3y0B44FB483bo/2PoMjBbf+5KYAZwZNmL9kpHAqcD+2I/WFZZIYQQWj25eK7A6lYs\n",
+ "2XbRHE8hzKW8hgJ/A3Zwzs8XPS+tPzcC+C6wg13G3Lk0CfxcYDBpaG5co8sKoYLiuzOE5hVr1YUW\n",
+ "TXntQgqadqwraMr8DtgcGFRm0LQ4KedTJ2Bj7MosyxJCCKHVa4rM4SE0ivLaEbgM2Nk5/7fOc8VR\n",
+ "wEGknqbGT9yW+pMmgb8JDI6gKYQQQqEInEKLpLy2J81V2sU5P1PnuWIv4DfAdjYTG1+ptgQeAy7C\n",
+ "PjYmgYcQQqgphupCi6O8tgWuBnZ1zk/Vea7YmTRpfFubtxpfqQ4Dzgb2x36g0eWEEEJo0yJwCi2K\n",
+ "8toauBbYzTk/XvQ80Zn0tNsBwFCblxpXoTqSAqZdgS2xX2tUOSGEENqFCJxCi6G8BgE3Ars750eL\n",
+ "nidWAa4HPgfWs/m0cRWqB3AdsBiwEfakRpUTQgih3Yg5TqFFUF5bAjcDeznnh4ueJ/YmZaK/Edi5\n",
+ "jKBpZeBx4CNg+wiaQgghlCJ6nEKzU16bAbcA+zjnh2o9RywKXEBaJX6wTZ1P2dVd4bz6zgJG0lzJ\n",
+ "zEIIIbQ60eMUmpXy2gS4HTjAOf+71nPEOsAzQFfg+2UGTQdl9R2KPSKCphBCCA0RPU6h2SivjYA7\n",
+ "gYOcW3gB6CwT+M+A3wMn2Pyj8ZWpA/AHYC9gEPYrjS4rhBBCuxWBU2gWymsD4C7gUOd830LHRS/g\n",
+ "78AqwGY2bzS+MnUnpTdYkjQJ/LNGlxVCCKFdi6G60OSU1/eBu4HDnfM9Cx0XmwHPA+8Dm5QZNK0I\n",
+ "PApMAraNoCmEEEI5InAKTUp5rQvcC/zUOd+1wDHRUeK3wK3AsTY/t/mm8ZVpY9LyKf8AfoI9s/Et\n",
+ "DyGEEGKoLjQh5fVd4D7gaOd8xwLHRF/gGlIw/wObD8urTPsB5wOHYd9dVlkhhBBCJnqcQpNQXmsD\n",
+ "9wPDnPOtCxwTOwHPAQ8BPyoraJI6IJ1Omgj+owiaQgghVFL0OIWqU15rAv8EfuGcb5q3XyxCyqW0\n",
+ "O7CnzSPlVaTFgKuAZUmTwD8pq7wQQgihhuhxClWlvNYAHgBOcs43zNsvBpIyd69CWjal3KBpeeBh\n",
+ "4GtST1METSGEECouAqdQNcprdeBfwK+d87Xz9osDSEHT5cBuNuUtdyKtz/xlWA7BbvyE8hBCCKEO\n",
+ "MVQXqkJ5DSQFTb9zzv8AkOgOXARsCGxj82LjCldPYGC2rQX8FDgC+84KND2EEEIoKgKnUHHKqz/w\n",
+ "byDvnK8AkPg+cANpOG19m6/rLkSLAQOA1ZgfJM3dFgPGA+OybWvsl6tyMyGEEEIBNddSXZJsW81S\n",
+ "eaga5bUKMAY40zn/NVs2ZRjwG2CYzQ3zT1Y3oD8LB0YDSVm+32R+cDQOeCP7OSHWmAvtVXx3htC8\n",
+ "InAKFaO8VialFPijc75YondXpl+5Bq+tOIJhI7bg0cIhtoFAH+AdFg6MxgEfYM9p+rsIoWWL784Q\n",
+ "mlcETqF8UqeLNmCTf63KTbu9ymMHvsSEiSyz0Qy6fn95PqQj376jhQOjccB72LObte0htDLx3RlC\n",
+ "84rAqS7pEfczgeuBf2PPauYWNR+pI7AC83uL5s09Mqz4QU86zujEm6tO6vDg5RzWfzQ7rr8kk066\n",
+ "jJ9c3a7ftxAqrFV8d4bQhkXgVBdpCeBgYB/SXJxbSUHUo21yGEnqAPSlRmCUbasAn7Fgj9G469bm\n",
+ "q58M5e/TO3MJw30TcB0wAzjQ5uNmuIsQ2rRW8d0ZQhsWgVOppFVIAdQ+wFKknEHXA/9tVROVJZEy\n",
+ "a9c2Ibs/MJkawVG2jceetkBReS1Hmgh+OcP9OvBX4DzgjzZtL7AMoQVodd+dIbQxVQucJO1AWmS1\n",
+ "I/B32+fUON56P/zSmsC+2WbSY/bXY7/SrO2aKwVHvak9OBpI6hGqGRi9QQqOppRURV7LAg8xq+v1\n",
+ "/GF6H2AwsJ/NkxW+mxBCgVb93RlCG1CVwElpPszrwDbAh8AzwL62Xy04p/V/+FOA8gNSALU38Dmp\n",
+ "F+pG7LeboP5eLBwUzR1iM7U/yj8O+8uyqs1rGeAhPh/wL0aOG0T6b32kTdFy1Uc70pNhdKErM5nB\n",
+ "ZEZ4okeX044Q2qM28d0ZQitWrcBpEyBne4fs9SkAts8uOKdtffjT/KAtSEN5e5ASNF4P3Iw9oYxy\n",
+ "e1B7YDQQWITan1YbB3xejSFE5bU05kHe3O5trrl/E+BU4O82RetSH+1IPy5gCAPm7RzFeD7g+Aie\n",
+ "QmiYNvfdGUIrU63AaQ9ge9tHZK8PADayfVzBOW33wy91JvW27QMMAZ4jBVG3Yn9Ry/mLUjxLdg8W\n",
+ "zJJduE1syvlVyqs3czo+xIsHijsvM3TY26be4UkN1H0cwPYLHbiG+zzOg6vS2BDaqDb93RlCK1Ct\n",
+ "JVdK+mUuaXjByzG2x1SlNU0tPX5/L3Bvlh17R1IQ9Sekh4EngJWZHxwtBbzF/IDoSeDq7N8ftYQn\n",
+ "+JTXknzT/TGeP3wZ7jvvBujwS5vpJV3cha5F9nerZBtDaIskDQIGNXMzQgiZagVOH5Jy/sy1AvBB\n",
+ "zZNsD69S/S2HPZ2UxuDWbHHaocD3gBeAm0nB0fvY3zZfI+umE/suifu+xCt79OL+cw+yO9zaoAJm\n",
+ "MqPI/tICrxDasewPyjFzX0vKNVtjQghVC5yeBQZKWhn4iDRxet8q1dV62JNJPUlXN3dTSqWNRg5k\n",
+ "g8Wf5YNNpvKvc9b0nE7vNriQyYxgFP1rzHF6k8mMrGRbQwghhGqrSuBke7akY4H7SekILit8oi60\n",
+ "DlruhaEMufJmvlz5BZ4+elPP6tqo5VE80aPVR3ANx9GFbsxkOpMZGRPDQwghtDaRADMsRKIzi318\n",
+ "Dvvtcgxdpo5m6dd2c64VJfkMoQ2L784Qmle1huqaVOQIqhyJVej6xY0ctN0AlnjnOhaZclgETSGE\n",
+ "EELS6gOnIjmC+quPiOCpYST2ovPUC/nZelNY/L1bkX8aQVMIIYQwX6sfqoscQeWTWBQ4n85Tt+aX\n",
+ "K3xBty9fAo5wrvnTIIQQFhRDdSE0rw7N3YCyRY6gskisAzzDIl9255ReH9Dty7FE0BRCCCHUqvUH\n",
+ "TpEjqFEkJHEU8CCLfXwev+7Vm46z3wcOj6AphBBCqF3rD5xSjqDxC+yLHEF1kugF3AIcwTIvbcVJ\n",
+ "y+0JfAYc4lzLTcQZQgghNLdWP8cJ5j1VFzmCSiCxGXAtcAeDTvsdg06/AZgK7O+cG5WnKYTQdGKO\n",
+ "UwjNq00ETqF+Eh2BXwPHAkcwXPeTep1mAvs651nN2b4QQmniuzOE5tXq0xGE+kn0Ba4hDc3+gOH6\n",
+ "FLgJmE0ETSGEEELJWv8cp1AniZ2A50iLhP6I4foEuB4QsE8ETSGEEELposepjZJYBDgL2B3Y0+YR\n",
+ "5dWJNL9pEWB35zyzOdsYQgghtDYROLVBEgOBG4D3gPVsJmVB09VAd+DHzvmb5mxjCCGE0BrFUF0b\n",
+ "I3EA8DhwObBbFjR1BK4ClgR2i6AphBBCaJzocWojJLoDFwEbAdvYvAiQBU1XAH2AXZxz7QlDQwgh\n",
+ "hFCv6HFqAyS+T5oAPhv4QUHQ1AH4O9APGOKcI5t6CCGEUIYInFqxbNmU44H7gZzN4TZfw7yg6W/A\n",
+ "KqSepmnN2NQQQgihTYihulZKojdpHtOywMY2b847loKmS4DVgcHO+evmaWUIIYTQtkSPUyskMQh4\n",
+ "HngN2LxG0CTgQmBtYEfnPLVZGhlCCCG0QdHj1IpIdAJOA34CHGpz/wLHU9A0AlgP2N45T2n6VoYQ\n",
+ "QghtVwROrYTECsB1wAzg+zYfL3A8BU1/Jj1Vt61zntz0rQwhhBDathiqawUkdgWeBe4Bti8SNP0R\n",
+ "2BzYzjl/1fStDCGEENq+6HFqwSS6An8CdgSG2jy50DkpaDob2BrYxjl/2bStDCGEENqP6HGqg8RA\n",
+ "iYcljpBYoonr/g7wFLA0admUYkHTH4DtScNzk5qyjSGEEEJ7E4FT3d4l9fhsD7wrcYvEUIku1aow\n",
+ "y810GPAw6em4vW2K9SLlgZ1JPU2fV6wNfbSjBuo+raUxGqj71Ec7VqrsEEIIoTWT7eapWLJtNUvl\n",
+ "jSDRC9gDOBD4DnAzadHcJ20q8iZKLA78hZRKYG+bV4qem9dpwF7AVs7500rUDylooh8XMIQB83aO\n",
+ "YjwfcLwnenSl6gkhNE5r++4Moa2JHqcS2Xxhc6nNlsCGwIekNeDGSQyXCgKNRpDYkLRsypfAhvUE\n",
+ "Tb8B9gF+VMmgCYCeDFsgaAIYwgB6clxF6wkhhBBaoQicGsHmbZs/kHqe9gV6AY9JPCFxtMRSpZYl\n",
+ "0UHiJOBu4Fc2R9kUXVNOeZ1C6vXa2jlPLO9OatGFrkX2d6t4XSGEEEIrE4FTGWxs84zN8aSFdE8H\n",
+ "tgDekrhTYo/sybhaSfQBRgO7AhvY3FpXfcrrJOAwUtD0cV3nNtpMZhTZHwsEhxBCaPeqEjhJGi7p\n",
+ "A0nPZ9sO1ainJbGZZTPaZl9gBeB24CjgI4lLJbaU5r/fEtuSlk15Fvihzbt1la+8fgEcSZrT9FHV\n",
+ "bmQyIxjF+AX2jeJNJjOyanWGEEIIrURVJodLygFTbJ9XxzntYoKjRD9gP9LwWg/gWqALaYjvIJsH\n",
+ "6y0jr+OBYcAg5/x+FZub6uujHenJcXShGzOZzmRGxsTwEFqG9vLdGUJLVc3AaartP9VxTrv68EsI\n",
+ "+C4pgFoaONGm3ondyusY4ARS0PRedVsZQmjp2tt3ZwgtTTUDp0OBr0hDUSfYC2a0jg9//ZTXz4BT\n",
+ "SEHTO83cnBBCCxDfnSE0r0bPcZL0gKT/1bINAS4BVgHWBSaQkki2OpIkrXKWpCb/klJeRwCnkiaC\n",
+ "v9PU9YcQQghhYY1eq872tqWcJ+nvwF1Fjg0veDnG9pjGtqc6+u8G2x4NDzwD3NZUtSqvw4Df/X97\n",
+ "9x9rdV3Hcfz54tLdBY1s6Ux+NJzCFm6JVs4ltsMIJIYyWkU5ptmGbVYytZbKH3d3rTCbEdL8A7K2\n",
+ "5tBaqQNNFBWX5kZZYCTQBYoFebUaJbkkIN798f0uL/fec+/33nPP+XzPua/Hdsf5nh/f72uXne/e\n",
+ "9/P5fN9fsqLpj406rpmVj6QKUEkcw8xy9ZqqOy8ievLHtwAfjohr+7yntMPN0uQbYdJKmDMeNsyE\n",
+ "Fd3wwkk4ujbi1fV1PXaXrie7/9zc6Ix99TyWmTWfMp87zcaCEY84DeFbkmYDAfwJ+EKdjlMnPRtg\n",
+ "whFouwcEtHXAyVuhp66jTurScuCbZCNNLprMzMxKpi6FU0RcV4/9NkpEhHRhgN7D2QtP8caUKVx+\n",
+ "ZDHz2AV01+OY6tK1wN1kt1H5Qz2OYWZmZrXxTX6rkGbdDse7+cqBLTx9zira2uZx9WvTgDfJ1mxt\n",
+ "Bn4ZnXGy5mN1aRmwBpgfnfFKrfszs9ZV9nOnWatz4TQM6pKAS4Gr85/pwBayImpLdJ7ecqHgPj8J\n",
+ "rAMWRGfsGr20ZtaKmvHcadZKXDjVQF2aAiwmK6I+StazajOwOTpj/2CfzT+/lKx1w1XRGS/XM6uZ\n",
+ "tYZWOHeaNTMXTqNEXZoIfIysiFoM/BN4jKyQerHvlJ66tARYDyyMztjR4Lhm1qRa7dxp1mxcONWB\n",
+ "ujQO+CBvj0a9j15TesCVwP3AouiM36TKaWbNp5XPnWbNwIVTA6hLU3m7iLoS+A9Z0fTrmved3ZD3\n",
+ "Ztrp4DjHOMq9viGvWesaS+dOszJy4dRg6tIZwMTojCFv8Dvkvs7VIqaylmu48P9PbmI/h1np4sms\n",
+ "NY3Vc6dZWbhwamKaoS0s56p+LzzAltgXH08QyczqzOdOs7RGfJNfK4F2Oqo8P6HBSczMzMYEF04N\n",
+ "JknS+asl1f4X43GOVXn+rZr3bWZmZv24cGq4Cz4BC2+CC5bWvKuj3MsmTu8XtYkDHGVdzfs2MzOz\n",
+ "frzGqUGkyTfCpJUwZzxsmAkruuGFk3B0bcSr60e83+yqui/TzgSO8xZHWeeF4Wata6ydO83Kpi43\n",
+ "+bWB9GyACUeg7R4Q0NYBJ2+Fnodr2WteJLlQMjMzawBP1TVIRAQoYNxZ8OndoHfnT6cZ8jMzM7Nh\n",
+ "84hTQ7XPgK03wIFHsjVO7TNSJzIzM7PivMbJzKyJ+Nxplpan6szMzMwKcuFkZmZmVpALJzMzM7OC\n",
+ "XBOEmuAAAATaSURBVDiZmZmZFeTCyczMzKwgF05mZmZmBblwMjMzMyvIhZOZmZlZQS6czMzMzApy\n",
+ "4WRmZmZWkAsnMzMzs4JcOJmZmZkVNOLCSdKnJL0i6b+SLu3z2h2S9knaK2lB7THNzMzM0qtlxGkX\n",
+ "sBT4Re8nJc0ClgGzgIXAfZKadmRLUiV1hiKcc3Q55+hqhpzNkNHM0htxQRMReyOie4CXlgAPRsSJ\n",
+ "iDgI7AcuG+lxSqCSOkBBldQBCqqkDlBQJXWAgiqpAxRUSR2ggErqAGZWfvUYCZoMHO61fRiYUofj\n",
+ "mJmZmTXU+MFelLQVeO8AL90ZEZuHcZwYViozMzOzElJEbTWNpG3AbRHx23z7doCIuCvf3gJ0RsT2\n",
+ "Pp9zMWVmNgIRodQZzMaqQUechqH3l3gTsFHSd8im6GYAv+r7AX/xzczMrNnU0o5gqaRDwOXA45Ke\n",
+ "AIiI3cBPgN3AE8BNUeuwlpmZmVkJ1DxVZ2ZmZjZWJO2vJOnrkl6WtFPSM5KmpcxTjaRvS9qTZ31Y\n",
+ "0rtSZxrIYE1Jy0DSwrwp6j5JX0udZyCSfiDpdUm7UmepRtI0Sdvy/+vfS7o5daaBSOqQtD3/fu+W\n",
+ "tDp1psFIapO0Q9JwLnxpKEkHJf0uz9lvCYSZ1V/qxpR3R8TFETEbeBToTJynmqeAiyLiYqAbuCNx\n",
+ "nmoGbEpaBpLagO+RNUWdBXxW0vvTphrQD8kyltkJ4JaIuIhsqvyLZfxdRsQxYG7+/f4AMFfSnMSx\n",
+ "BrOSbIlBmYfhA6hExCUR0cz98cyaVtLCKSL+1WvzTODvqbIMJiK2RsSpfHM7MDVlnmoGaUpaBpcB\n",
+ "+yPiYEScAB4ia5ZaKhHxPPCP1DkGExGvRcTO/PGbwB6y/mmlExH/zh+2A23AkYRxqpI0FVgEfJ/T\n",
+ "L3Ypo7LnM2tpqUeckPQNSX8GrgfuSp2ngM8DP08doglNAQ712nZj1FEgaTpwCVlBXzqSxknaCbwO\n",
+ "bMsvHimjNcBXgVNDvTGxAJ6W9JKkFanDmI1Fo9WOoKqhmmhGxCpgVd7/aQ1wQ70zDaRIs09Jq4Dj\n",
+ "EbGxoeF6GcWmpI1W5umPpiTpTOCnwMp85Kl08pHa2fm6wCclVSLiucSxTiNpMfDXiNjRBPeruyIi\n",
+ "eiSdA2yVtDcfJTWzBql74RQR8wu+dSMJR3KGyinpc2RD+fMaEqiKYfw+y+YvQO/F/9M4/dY8NgyS\n",
+ "3gH8DHggIh5NnWcoEfGGpMeBDwHPJY7T10eAayQtAjqASZJ+FBHXJc7VT0T05P/+TdIjZFPgLpzM\n",
+ "Gij1VXUzem0uAXakyjIYSQvJhvGX5Atem0HZ1kG8BMyQNF1SO7CMrFmqDZMkAfcDuyPiu6nzVCPp\n",
+ "bEln5Y8nAPMp4Xc8Iu6MiGkRcT7wGeDZMhZNkiZKemf++AxgAdkFIWbWQKnXOK2WtCtfA1EBbkuc\n",
+ "p5p1ZIvXt+aXAd+XOtBAqjUlLYOIOAl8CXiS7MqlH0fEnrSp+pP0IPAiMFPSIUlJpo6HcAWwnOwq\n",
+ "tR35TxmvBDwPeDb/fm8HNkfEM4kzFVHWaeVzged7/T4fi4inEmcyG3PcANPMzMysoNQjTmZmZmZN\n",
+ "w4WTmZmZWUEunMzMzMwKcuFkZmZmVpALJzMzM7OCXDiZmZmZFeTCyczMzKwgF05mZmZmBf0PM6oY\n",
+ "ijHHSmwAAAAASUVORK5CYII=\n"
],
"text/plain": [
- ""
+ ""
]
},
"metadata": {},
@@ -1279,23 +1308,18 @@
" Xt = construct_poly(xt,6) #n=d\n",
" w = wRidge(X,y,1.0)\n",
" plt.plot(xt,Xt.dot(w),label='$\\lambda$ = 1.0'+ \" MSE: %f\" % MSE(X.dot(w),y))\n",
- " #plt.title(\"MSE %f\" % MSE(X.dot(w),y))\n",
- " \n",
" \n",
" w = wRidge(X,y,0.1)\n",
" plt.plot(xt,Xt.dot(w),label='$\\lambda$ = 0.1'+ \" MSE: %f\" % MSE(X.dot(w),y))\n",
" \n",
- " \n",
" w = wRidge(X,y,10.0)\n",
" plt.plot(xt,Xt.dot(w),label='$\\lambda$ = 10.0'+\" MSE: %f\" % MSE(X.dot(w),y))\n",
" \n",
- " \n",
- " \n",
" plt.plot(xt,yt,'b*',label='data test')\n",
" plt.plot(x,y,'go',label='data trainig')\n",
" plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n",
"plot()\n",
- "print('Minimum MSE: für lambda = 0.1')"
+ "print('Minimum MSE for lambda = 0.1')"
]
},
{
diff --git a/mr/UB3/A3MutschlerHohloch.pdf b/mr/UB3/A3MutschlerHohloch.pdf
new file mode 100644
index 0000000..6b451a1
--- /dev/null
+++ b/mr/UB3/A3MutschlerHohloch.pdf
Binary files differ
diff --git a/mr/UB3/A3b.pdf b/mr/UB3/A3b.pdf
new file mode 100644
index 0000000..8fd0d9e
--- /dev/null
+++ b/mr/UB3/A3b.pdf
Binary files differ
diff --git a/mr/UB3/mr3.pdf b/mr/UB3/mr3.pdf
deleted file mode 100644
index c2066d9..0000000
--- a/mr/UB3/mr3.pdf
+++ /dev/null
Binary files differ
diff --git a/mr/UB3/mr3.tex b/mr/UB3/mr3.tex
index dea831b..f461b7b 100644
--- a/mr/UB3/mr3.tex
+++ b/mr/UB3/mr3.tex
@@ -161,7 +161,7 @@
\end{itemize}
\item $l_\omega = 0.3m$ irrelevant\\ $l_a = 0.5m \\
- \varPsi = tan^{-1}(\frac{l_a}{r_t})\\
+ \psi = tan^{-1}(\frac{l_a}{r_t})\\
v_t= \frac{\Delta s}{\Delta t}
$
\begin{itemize}
@@ -170,7 +170,7 @@
1 \frac{m}{s}
\end{pmatrix} $
\item
- $ \varPsi_1 = tan^{-1}(\frac{0.5}{0.5}) = 45^\circ\\
+ $ \psi_1 = tan^{-1}(\frac{0.5}{0.5}) = 45^\circ\\
v_1= 0.5*\pi= 1.5708 \frac{m}{s}\\
u_1=\begin{pmatrix}
45^\circ\\
@@ -195,8 +195,8 @@
\begin{enumerate}[(a)]
\item
Assumed left rotation:\\
- $\varPsi_l = tan^{-1}(\frac{l_a}{r-0,5l_\omega}) = tan^{-1}(\frac{0.5}{1-0.5*0.3})= 30.47^\circ\\
- \varPsi_r = tan^{-1}(\frac{l_a}{r+0,5l_\omega}) = tan^{-1}(\frac{0.5}{1+0.5*0.3})=23.5^\circ
+ $\psi_l = tan^{-1}(\frac{l_a}{r-0.5l_\omega}) = tan^{-1}(\frac{0.5}{1-0.5*0.3})= 30.47^\circ\\
+ \psi_r = tan^{-1}(\frac{l_a}{r+0.5l_\omega}) = tan^{-1}(\frac{0.5}{1+0.5*0.3})=23.5^\circ
$
@@ -204,29 +204,34 @@
\centering
\includegraphics[width=0.6\textwidth]{CalcPhi.png}
- \caption{\label{fig:Psi01} Determination of $\varPsi_r$ and $\varPsi_l$}
+ \caption{\label{fig:psi01} Determination of $\psi_r$ and $\psi_l$}
\end{figure}
\item
- $sl = 2*PI* (1-0.5*0.3) = 5.341m \\
- sr = 2*PI* (1+0.5*0.3) =7.225m\\
- sl -sr = 1.885m
+
+ $ d= s_l-s_r = 2\pi(r+\frac{1}{2}l_w)+ 2\pi(r-\frac{1}{2}l_w) \\= \pi l_w+\pi l_w = 2\pi l_w\\
+ 2\pi \cdot 0.3m = 1.885m
$
\end{enumerate}
\Aufgabe{}{8}
\begin{enumerate}[(a)]
- \item $ r= \frac{l}{2\tan^{-1}(\varPsi)}$
- \item todo
- \item $ l_1 = r\tan^{-1}(\varPsi_1)\\
- l_2 = r\tan^{-1}(\varPsi_2)\\
+ \item $ r= \frac{l}{2\tan^{-1}(\psi)}$
+ \item siehe Dokumentende
+
+ \item $ l_1 = r\tan^{-1}(\psi_1)\\
+ l_2 = r\tan^{-1}(\psi_2)\\
$
-\item $r = \frac{l\sin(\Psi_2-\frac{\pi}{2})\sin(\Psi_1-\frac{\pi}{2})}{\Psi_1+\Psi_2}$
+\item $ r= \frac{l_2}{tan^{-1}(\psi_2)} = \frac{l-l_1}{tan^{-1}(\psi_2)}\\
+= \frac{l-r\cdot tan^{-1}(\psi_1)}{tan^{-1}(\psi_2)}\\
+\rightarrow r(1+\frac{tan^{-1}(\psi_1)}{tan^{-1}(\psi_2)})=\frac{l}{tan^{-1}(\psi_2)}\\ \rightarrow r= \frac{l}{tan^{-1}(\psi_2)+tan^{-1}(\psi_1)}
+$
+
\end{enumerate}
- Die war zu einfach ... da ist irgendwas falsch...
-
+
+ \includepdf{A3b.pdf}