From aaa4a2a49011c8016cb564a9a6d173553476fc9d Mon Sep 17 00:00:00 2001
From: emil <emil28092005@gmail.com>
Date: Sun, 1 Dec 2024 22:42:57 +0300
Subject: [PATCH] final commit

---
 best/Main.java                                | 375 ++++++++++++++++++
 other/Main.java                               |  44 ++
 .../demo/src/main/java/com/example/Main.java  |  50 ++-
 .../classes/com/example/Main$Chromosome.class | Bin 3549 -> 3549 bytes
 .../target/classes/com/example/Main.class     | Bin 9579 -> 7937 bytes
 5 files changed, 466 insertions(+), 3 deletions(-)
 create mode 100644 best/Main.java

diff --git a/best/Main.java b/best/Main.java
new file mode 100644
index 0000000..2344403
--- /dev/null
+++ b/best/Main.java
@@ -0,0 +1,375 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class Main {
+    // Initalizing variables
+    public static int POPULATIONSIZE = 0;
+    public static int TOURNAMENTSIZE = 0;
+    public static double MUTATIONRATE = 0;
+    // Threshold of number of mutable positions for easy level sudoku
+    public static int EASYTHRESHOLD = 60; 
+    public static int HARDTHRESHOLD = 70;
+    // List to store the population of chromosomes
+    List<Chromosome> population = new ArrayList<>();
+    Random random = new Random();
+
+    public static void main(String[] args) {
+        // Base Sudoku matrix (input matrix)
+        int[][] baseSudoku = new int[9][9];
+        // List to track positions in Sudoku that are mutable
+        List<int[]> mutablePositions = new ArrayList<>();
+        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+        
+        try {
+            // Reading the Sudoku matrix from the console input
+            for (int i = 0; i < 9; i++) {
+                // Split the input by space
+                String[] tokens = reader.readLine().split(" ");
+                for (int j = 0; j < 9; j++) {
+                    if (tokens[j].equals("-")) {
+                        // Empty cells are marked as 0
+                        baseSudoku[i][j] = 0;
+                        // Add mutable positions (i, j) to the list
+                        mutablePositions.add(new int[]{i, j});
+                    } else {
+                        // Set fixed value from the input
+                        baseSudoku[i][j] = Integer.parseInt(tokens[j]);
+                    }
+                }
+            }
+        } catch (IOException e) {
+            // If an error occurs during input reading, print the error and stop the program
+            System.err.println("Error reading input: " + e.getMessage());
+            return;
+        }
+
+        Main mainInstance = new Main(); // Create instance of Main class
+
+        // Choosing variables for different sudoku difficulties
+        if (mutablePositions.size() < EASYTHRESHOLD) { // Easy sudoku
+            POPULATIONSIZE = 100;
+            TOURNAMENTSIZE = 5;
+            MUTATIONRATE = 0.05;
+        } else if (mutablePositions.size() < HARDTHRESHOLD) { // Hard sudoku
+            POPULATIONSIZE = 100;
+            TOURNAMENTSIZE = 5;
+            MUTATIONRATE = 0.057;
+        }
+        else { // Ultra-hard sudoku
+            POPULATIONSIZE = 20000;
+            TOURNAMENTSIZE = 4;
+            MUTATIONRATE = 0.032;
+        }
+        
+        // Generate initial population of 100 chromosomes
+        mainInstance.generateInitialChromosomes(POPULATIONSIZE, baseSudoku, mutablePositions);
+
+        Chromosome bestSolution = null;
+
+        int generation = 0; // Track the number of generations
+        while (true) {
+            // Evaluate the fitness of each chromosome in the population
+            mainInstance.evaluatePopulation();
+
+            List<Chromosome> newPopulation = new ArrayList<>();
+            for (int i = 0; i < mainInstance.population.size() / 2; i++) {
+                // Select parents using tournament selection
+                List<Chromosome> parents = mainInstance.tournamentSelection(TOURNAMENTSIZE);
+                // Perform crossover to create two children from the selected parents
+                Chromosome child1 = mainInstance.crossoverBySubgrids(parents.get(0), parents.get(1));
+                Chromosome child2 = mainInstance.crossoverBySubgrids(parents.get(1), parents.get(0));
+
+                // Apply mutation to both children
+                mainInstance.mutateChromosome(child1, MUTATIONRATE);
+                mainInstance.mutateChromosome(child2, MUTATIONRATE);
+
+                // Add both children to the new population
+                newPopulation.add(child1);
+                newPopulation.add(child2);
+            }
+
+            // Replace the old population with the new population
+            mainInstance.population = newPopulation;
+
+            // Get the best chromosome from the current population
+            bestSolution = mainInstance.getBestChromosome();
+            generation++;
+
+            // If the best solution found has a fitness of 0, print it and end the program
+            if (bestSolution.getFitness() == 0) {
+                bestSolution.printChromosome(false);
+                return;
+            }
+        }
+    }
+
+    // Generate initial population of chromosomes
+    public void generateInitialChromosomes(int numberOfChromosomes, int[][] baseSudoku, List<int[]> mutablePositions) {
+        for (int i = 0; i < numberOfChromosomes; i++) {
+            // Create a copy of the base Sudoku
+            int[][] sudoku = copyMatrix(baseSudoku);
+            // Randomly fill mutable positions
+            for (int[] pos : mutablePositions) {
+                int row = pos[0];
+                int col = pos[1];
+                sudoku[row][col] = random.nextInt(9) + 1;
+            }
+            // Create a new chromosome with the generated Sudoku and mutable positions
+            Chromosome chromosome = new Chromosome(sudoku, new ArrayList<>(mutablePositions));
+            chromosome.evaluateFitness(); // Evaluate its fitness
+            population.add(chromosome); // Add to the population
+        }
+    }
+
+    // Create a deep copy of a matrix
+    private int[][] copyMatrix(int[][] original) {
+        int[][] copy = new int[original.length][original[0].length];
+        for (int i = 0; i < original.length; i++) {
+            System.arraycopy(original[i], 0, copy[i], 0, original[i].length);
+        }
+        return copy;
+    }
+
+
+    public List<Chromosome> tournamentSelection(int tournamentSize) {
+        List<Chromosome> selectedParents = new ArrayList<>();
+        for (int i = 0; i < 2; i++) {
+            List<Chromosome> tournament = new ArrayList<>();
+            // Randomly select chromosomes for the tournament
+            for (int j = 0; j < tournamentSize; j++) {
+                Chromosome randomChromosome = population.get(random.nextInt(population.size()));
+                tournament.add(randomChromosome);
+            }
+            // Determine the best chromosome in the tournament based on fitness
+            Chromosome best = tournament.get(0);
+            for (Chromosome chromosome : tournament) {
+                if (chromosome.getFitness() < best.getFitness()) {
+                    best = chromosome;
+                }
+            }
+            // Add the best chromosome to the list of selected parents
+            selectedParents.add(best);
+        }
+        return selectedParents;
+    }
+    
+    public Chromosome crossoverBySubgrids(Chromosome parent1, Chromosome parent2) {
+        int[][] childSudoku = new int[9][9];
+    
+        // Copy the entire Sudoku grid from parent1 to the child
+        for (int row = 0; row < 9; row++) {
+            System.arraycopy(parent1.getSudoku()[row], 0, childSudoku[row], 0, 9);
+        }
+    
+        // Determine the number of subgrids to swap from parent2 to child (1-5)
+        int numSubgridsToSwap = random.nextInt(5) + 1;
+        List<Integer> selectedSubgrids = new ArrayList<>();
+        while (selectedSubgrids.size() < numSubgridsToSwap) {
+            int subgridIndex = random.nextInt(9);
+            if (!selectedSubgrids.contains(subgridIndex)) {
+                selectedSubgrids.add(subgridIndex);
+            }
+        }
+    
+        // Swap the selected subgrids from parent2 into the child
+        for (int subgrid : selectedSubgrids) {
+            int rowStart = (subgrid / 3) * 3;
+            int colStart = (subgrid % 3) * 3;
+            for (int row = rowStart; row < rowStart + 3; row++) {
+                for (int col = colStart; col < colStart + 3; col++) {
+                    childSudoku[row][col] = parent2.getSudoku()[row][col];
+                }
+            }
+        }
+    
+        // Create a new chromosome with the resulting child Sudoku and evaluate its fitness
+        Chromosome child = new Chromosome(childSudoku, parent1.getMutablePositions());
+        child.evaluateFitness();
+        return child;
+    }
+    
+    public void printPopulation(boolean printMutPos) {
+        System.out.println("Generated Population:");
+        int count = 1;
+        // Print each chromosome's Sudoku and fitness value
+        for (Chromosome chromosome : population) {
+            System.out.println("Chromosome " + count + ":");
+            chromosome.printChromosome(printMutPos);
+            System.out.println("Fitness: " + chromosome.getFitness());
+            System.out.println();
+            count++;
+        }
+    }
+    
+    public void mutateChromosome(Chromosome chromosome, double mutationRate) {
+        int[][] sudoku = chromosome.getSudoku();
+        List<int[]> mutablePositions = chromosome.getMutablePositions();
+    
+        // Mutate each mutable position with a probability defined by mutationRate
+        for (int[] pos : mutablePositions) {
+            if (random.nextDouble() < mutationRate) {
+                int row = pos[0];
+                int col = pos[1];
+                int newValue = random.nextInt(9) + 1; // Assign a new value between 1 and 9
+                sudoku[row][col] = newValue;
+            }
+        }
+    
+        // Update the chromosome's Sudoku and recalculate its fitness
+        chromosome.setSudoku(sudoku);
+        chromosome.evaluateFitness();
+    }
+    
+    public void evaluatePopulation() {
+        // Evaluate the fitness of each chromosome in the population
+        for (Chromosome chromosome : population) {
+            chromosome.evaluateFitness();
+        }
+    }
+    
+    public Chromosome getBestChromosome() {
+        // Find and return the chromosome with the best (lowest) fitness in the population
+        Chromosome best = population.get(0);
+        for (Chromosome chromosome : population) {
+            if (chromosome.getFitness() < best.getFitness()) {
+                best = chromosome;
+            }
+        }
+        return best;
+    }
+    
+    // Chromosome class representing an individual solution
+    public class Chromosome {
+        private int[][] sudoku; // Sudoku grid representing the chromosome
+        private List<int[]> mutablePositions; // Positions that can be changed (mutable)
+        private int fitness; // Fitness value representing the number of conflicts
+    
+        // Constructor for initializing a Chromosome with a Sudoku grid and mutable positions
+        public Chromosome(int[][] sudoku, List<int[]> mutablePositions) {
+            this.sudoku = sudoku;
+            this.mutablePositions = mutablePositions;
+        }
+    
+        public int[][] getSudoku() {
+            return sudoku;
+        }
+    
+        public void setSudoku(int[][] sudoku) {
+            this.sudoku = sudoku;
+        }
+    
+        public List<int[]> getMutablePositions() {
+            return mutablePositions;
+        }
+    
+        public int getFitness() {
+            return fitness;
+        }
+    
+        // Evaluate the fitness of the Sudoku by counting the number of row, column, and subgrid violations
+        public void evaluateFitness() {
+            fitness = countRowViolations() + countColumnViolations() + countSubgridViolations();
+        }
+    
+        private int countRowViolations() {
+            int violations = 0;
+            // Iterate through each row to count conflicts
+            for (int i = 0; i < 9; i++) {
+                boolean[] present = new boolean[10];
+                for (int j = 0; j < 9; j++) {
+                    int value = sudoku[i][j];
+                    if (value != 0) {
+                        if (present[value]) {
+                            violations++; // Increment violations if the value is already seen
+                        } else {
+                            present[value] = true; // Mark the value as seen
+                        }
+                    }
+                }
+            }
+            return violations;
+        }
+        private int countColumnViolations() {
+            int violations = 0;
+            // Loop through each column
+            for (int j = 0; j < 9; j++) {
+                boolean[] present = new boolean[10]; // Track numbers present in the column
+                for (int i = 0; i < 9; i++) {
+                    int value = sudoku[i][j];
+                    if (value != 0) {
+                        // If the number is already present, increment the violations count
+                        if (present[value]) {
+                            violations++;
+                        } else {
+                            // Mark the number as present
+                            present[value] = true;
+                        }
+                    }
+                }
+            }
+            return violations;
+        }
+        
+        private int countSubgridViolations() {
+            int violations = 0;
+            // Loop through each 3x3 subgrid
+            for (int gridRow = 0; gridRow < 3; gridRow++) {
+                for (int gridCol = 0; gridCol < 3; gridCol++) {
+                    boolean[] present = new boolean[10]; // Track numbers present in the subgrid
+                    // Loop through cells in the 3x3 subgrid
+                    for (int row = gridRow * 3; row < gridRow * 3 + 3; row++) {
+                        for (int col = gridCol * 3; col < gridCol * 3 + 3; col++) {
+                            int value = sudoku[row][col];
+                            if (value != 0) {
+                                // If the number is already present, increment the violations count
+                                if (present[value]) {
+                                    violations++;
+                                } else {
+                                    // Mark the number as present
+                                    present[value] = true;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return violations;
+        }
+        
+        public void printChromosome(boolean printMutPos) {
+            // Print the Sudoku matrix
+            for (int[] row : sudoku) {
+                for (int j = 0; j < row.length; j++) {
+                    System.out.print(row[j]);
+                    if (j < row.length - 1) {
+                        System.out.print(" ");
+                    }
+                }
+                System.out.println();
+            }
+            // If requested, print mutable positions
+            if (printMutPos) {
+                System.out.println("Mutable Positions:");
+                for (int i = 0; i < mutablePositions.size(); i++) {
+                    int[] pos = mutablePositions.get(i);
+                    System.out.print("(" + pos[0] + ", " + pos[1] + ")");
+                    if (i < mutablePositions.size() - 1) {
+                        System.out.print(" ");
+                    }
+                }
+                System.out.println();
+            }
+        }
+    }
+}        
+
+
+
+
+
+
+
diff --git a/other/Main.java b/other/Main.java
index 06e48f9..82ab558 100644
--- a/other/Main.java
+++ b/other/Main.java
@@ -69,12 +69,24 @@ public class Main {
         mainInstance.generateInitialChromosomes(POPULATIONSIZE, baseSudoku, mutablePositions);
 
         Chromosome bestSolution = null;
+        List<Integer> fitnessValues = new ArrayList<>();
+
+        int stuckCounter = 0;
+        int tryUnstuckCount = 0;
+        boolean unstucking = false;
+
+        int INITIAL_POPULATIONSIZE = POPULATIONSIZE;
+        int INITIAL_TOURNAMENTSIZE = TOURNAMENTSIZE;
+        double INITIAL_MUTATIONRATE = MUTATIONRATE;
 
         int generation = 0; // Track the number of generations
         while (true) {
             // Evaluate the fitness of each chromosome in the population
             mainInstance.evaluatePopulation();
 
+            bestSolution = mainInstance.getBestChromosome();
+            fitnessValues.add(bestSolution.getFitness());
+
             List<Chromosome> newPopulation = new ArrayList<>();
             for (int i = 0; i < mainInstance.population.size() / 2; i++) {
                 // Select parents using tournament selection
@@ -104,6 +116,38 @@ public class Main {
                 bestSolution.printChromosome(false);
                 return;
             }
+
+            //change arguments when algorithm is stuck
+            if (fitnessValues.size() > 2) {
+                if (fitnessValues.get(fitnessValues.size()-1) == fitnessValues.get(fitnessValues.size()-2)){
+                    stuckCounter++;
+                    //System.out.println("StuckCount: " + String.valueOf(stuckCounter));
+                    if (stuckCounter > 50){
+                        if (MUTATIONRATE < 1){
+                            unstucking = true;
+                            System.out.println(MUTATIONRATE);
+                            System.out.println(POPULATIONSIZE);
+                            MUTATIONRATE = MUTATIONRATE * 1.1 + 0.01;
+                            POPULATIONSIZE /= 2;
+                        }
+                        stuckCounter = 0;
+                    }
+                } else{
+                    stuckCounter = 0;
+                }
+            }
+            if (unstucking) {
+                //System.out.println("Unstucking");
+                tryUnstuckCount++;
+                if (tryUnstuckCount > 100){
+                    unstucking = false;
+                    tryUnstuckCount = 0;
+                    POPULATIONSIZE = INITIAL_POPULATIONSIZE; 
+                    TOURNAMENTSIZE = INITIAL_TOURNAMENTSIZE;
+                    MUTATIONRATE = INITIAL_MUTATIONRATE;
+                }
+            }
+            //System.out.println("UnstuckCount: " + String.valueOf(tryUnstuckCount));
         }
     }
 
diff --git a/statistical/demo/src/main/java/com/example/Main.java b/statistical/demo/src/main/java/com/example/Main.java
index edf5245..6b10dd6 100644
--- a/statistical/demo/src/main/java/com/example/Main.java
+++ b/statistical/demo/src/main/java/com/example/Main.java
@@ -68,7 +68,7 @@ public class Main {
         else { // Ultra-hard sudoku
             POPULATIONSIZE = 100000;
             TOURNAMENTSIZE = 10;
-            MUTATIONRATE = 0.1;
+            MUTATIONRATE = 0.0;
         }
         
         // Generate initial population of chromosomes
@@ -78,6 +78,17 @@ public class Main {
         List<Integer> fitnessValues = new ArrayList<>();
 
         int generation = 0; // Track the number of generations
+        int stuckCounter = 0;
+        int tryUnstuckCount = 0;
+        boolean unstucking = false;
+
+        int INITIAL_POPULATIONSIZE = POPULATIONSIZE;
+        int INITIAL_TOURNAMENTSIZE = TOURNAMENTSIZE;
+        double INITIAL_MUTATIONRATE = MUTATIONRATE;
+        
+        
+
+
         while (true) {
             // Evaluate the fitness of each chromosome in the population
             mainInstance.evaluatePopulation();
@@ -112,13 +123,46 @@ public class Main {
             if (generation % 10 == 0) {
                 mainInstance.plotFitness(fitnessValues);
             }
-
+            
             // If the best solution found has a fitness of 0, print it and end the program
             if (bestSolution.getFitness() == 0) {
                 bestSolution.printChromosome(false);
                 return;
             }
-        }
+            /* 
+            // Check if algorithm is stuck
+            if (fitnessValues.size() > 2) {
+                if (fitnessValues.get(fitnessValues.size()-1) == fitnessValues.get(fitnessValues.size()-2)){
+                    stuckCounter++;
+                    System.out.println("StuckCount: " + stuckCounter);
+                    if (stuckCounter > 20){
+                        if (MUTATIONRATE < 1){
+                            unstucking = true;
+                            System.out.println(MUTATIONRATE);
+                            System.out.println(POPULATIONSIZE);
+                            MUTATIONRATE = MUTATIONRATE * 1.1 + 0.01;
+                            POPULATIONSIZE /= 2;
+                            TOURNAMENTSIZE /= 2;
+                        }
+                        stuckCounter = 0;
+                    }
+                } else {
+                    stuckCounter = 0;
+                }
+            }
+            if (unstucking) {
+                System.out.println("Unstucking");
+                tryUnstuckCount++;
+                if (tryUnstuckCount > 100){
+                    unstucking = false;
+                    tryUnstuckCount = 0;
+                    POPULATIONSIZE = INITIAL_POPULATIONSIZE;
+                    TOURNAMENTSIZE = INITIAL_TOURNAMENTSIZE;
+                    MUTATIONRATE = INITIAL_MUTATIONRATE;
+                }
+            }
+            System.out.println("UnstuckCount: " + tryUnstuckCount);
+            }*/
     }
 
     // Generate initial population of chromosomes
diff --git a/statistical/demo/target/classes/com/example/Main$Chromosome.class b/statistical/demo/target/classes/com/example/Main$Chromosome.class
index 815de1c9a1695fdfcaffdc8d7ea065f061ca795a..b054448f4c7ed5434b6c5ca8ddc6851728077a95 100644
GIT binary patch
delta 300
zcmWN|&nv@m9LMq3OMQL5!yIt3rZ^$dH=Jy=gOtM#a<P&8D9Oc27$Z$-HordyNyrH8
zG^vsDBe^>|?JsfhI=$-sem=^9a-bMA{xSF%LoMT|=eTV*)10*XChW|>;jH~JQO?;W
zH^c=ScZZ!t)G=WT?v}TN3NFKN1vOmNHHjeC(86`JF@+9ppo^R6(XU_K5V!3_RkKa`
zir$W7Msim&E18qrlRS_-lsu9=k<3bFBu^#(BIi;UQkPO!QrBo?Ug`#&yhS(f(8qg;
z2Siwq%41Z`l=^wO1RtNyszdZjXy7wi`GQ{U0ADf45~6&=2;ULohtf}^wK;y_nBTV2
G|N9S9<wVl}

delta 300
zcmWN|!7IaY9LDkIQ9s|`FbABhDNcyZuMxGeRu&CEETv|f87VnvWW<tIyKJcWO8g5>
zD}RWi)BX|{&*`bp=l$x2x}i?k1ZNRo1cQuXm~(d8lo_+nX4zSU!zKG;e8%mVn_$u&
zxEW^^LrmK*_t9HN4>K^_zyLRO-9nf?Cb*3$?qG(yh%$?L{Z`biao-mD#%(Ro@p6)R
z$%152@=&rQS(ZGOJdr$=EK24j&n5p-7g80eOQ|cVYmBlgb%O|R5#t@=yqBmU#RsV>
z_S77yKa;Dl@%`DKpx49*TbSe%7PLveAk8Lxwvpv4a<od{P}jEjjy6ARZ}9gY*=RXW

diff --git a/statistical/demo/target/classes/com/example/Main.class b/statistical/demo/target/classes/com/example/Main.class
index f46315d57c5dafa56e9c536103459b5907b36bb0..b64674be12bf2c2bc6e696710f3a2731ffa2fa12 100644
GIT binary patch
literal 7937
zcmb7J33y!9b^fnre|p+IlE<>~U~CxeAcIIG<08ujgtZt+#+IC<jHPFJ@MxYoGx9={
zrU~wnGzq0m8*tKKk){Gl!(xyzrcOwp2}=lprrDrPLqpnTCp5vtF!|4YvssqiFPNEk
z-(Ai<_niOy=iJfLZ$Ekhz!mB;A4(J|$L*;$YkzcVI&QV~M`H;e-0ZzEx;NSuk0vJD
z26x_Qji(jLw+wFC+SfhOJ2)`hJGMzd^|EthaO==OcmJk=5vSAa-#Vh_40VsloQ(=)
zo4SWbN3I##G<?lqpS)kwJ+!gt-I%tgXX4Rx%uaCQKE3lyIu>v1i>1<C3W4F+WFnfL
zNm>eR3x?PAEmVJX&+eo>WvA>Zt7|=1dy~<`ggvEDU9@ya_sQtGSR$5Qui%O_T(98n
zu_r78F4UT+MvV_k6>16!btjY21EQ6II@AWBP;bISnGY*+Cew;L;tec!CWTE@qDrBn
zFP5+dW~O#p$&u*JIFD1^XOBnY*GH2vdCzvb)4O9S8C!TX>g!)O9@iSn<`<dpz$>i=
z6F#TaWWtYt^tG5UoW3>_rSS4}Q*^IFZDfaI3hmzEbTXEh>}t5)hqY9(;P*|*q@DER
zGKG(BO(d<99p7tBgsIbX%yCwDI%!kusZ?j!2n-)cq@(-8mMm%x#}X+knGUbA;wdXU
zoQ|fgDJzj)6;9h)K-@}O;oe>OfwL`t-{~th#O?7thJkimF7A1ULNKz}Nfee%S_v!3
zZF}k6STtV11Pxmk>D{rTw+IayXX5_)#YWcc=v`0q7&Pe>Cf4Kk6pV3u`apk_mfKI4
zL@2F+pHg(A$A=A!iUMRrwuy~kEV!Z*6AM&!VymlROx9j);u<if{IRs?ZYRZ64MlqP
zX8XHJu^Ih7^bsV5opPfl1~5oxC#?O9+9f#&MX}uF!*vQJJ9-77!zM<sRlz6odlOvZ
zj`TM0Fq^T>#CD8wXm>O<prtWN#(da8OD)7^QP@dvyjvXf9)(cWK{_mY?0B41!Z_FV
z9K#JVE2<EQoQd^CU1VSk<0d9hL#SGNqwyK~_^MbsVWsHUnuLz6!Cj}h+t?XRS;I3E
z_MRE~fMOY{Q!{A^xGi>y@URnHt70UBRCbncG8vl~viI@m(xTpMO)~}vVlmtpMWkkS
z%2<&IS5j8E#$~ogbYp<KrfmxMC#-$fI~~S&o}Ls|oN??TGcww1Pp5|i(>aP*QiKXY
zn8qlXl@T?*r$0KanZ$=l9}))MhxhyNM>&FWg8o2?A!*`|@d5H{RA@~gt<YE;P+4?l
zL!}r%y}c4HemfbPj3uHxuiIH(leTA)iKqnou$A>S{X#%3P?(2nKePA$V{?g;KR59q
ze3(0?VmFC_BZAd#e8j{@@iD$nT69q`FS}T4LC;^BxK)-LoR<eqd6C*$YDG$GZ%u58
zCV3XR&?rnHSZ<^>oxD<j8dch9rMP*`c+yU#?7dcU!+~K3B@{4vCdP}MeNH4aoO4u;
z^+^+-!r#%CJXQ|to`|rLfjcnk!(oN00=F~Htw}3s;!b>q(AHob+$DUI^OUw*b{hGn
z8=p1t55i*pahps}f)~MenYdf5>5nDS8sMVKKbp7~|3o`bm;N&XtvW|Y#VOu5t?hh?
zgqd!&E0m7!j>RW(hpA$0=ZraG5ATakOAKbclp9bmvtikrn6SvrzU(VCWN<P%lJpNx
z5YIL}dJly)3*foVc|XkvQcP4#Gg+p$6xA#4$XLVm0mj&4CjJ>G2ta#A0O$ya*=<{7
z1(U25o$B)A3mm#So0}%W1wow#zKAD$_!7;g-E{g&6HiLIBL`7fJW<X1?aL;<f~T0x
zrlNbS9y>7}O>c{(ce9mBM>S*@1VJ{@i-(>u@hl$A9j5@{YUa2vizZ)_4QuEFy&;`Q
znj`GVd!BK7Mo3UoXxb{QRXG3L2;V3<bUFUb#5eIR29)HRjrNSLgBZmdMX~Rg_%2=|
zj8g>|dv$&#-I&7KLf1nieY!F0TY@InBx(XVKeIcKbF{Q`{W2%lpPfIrYZv!(`g3hJ
z`H>K-&Lx?Gs~AWG_6CM}@!?kz*5}BH#7^mS+%8Z~O>tt(7a&Z8g@mq&eNiAvvG!Ai
zrFL?%ZBN49H`TU(d^fS(wtcimo(6t`pG$821sxU<vi9SboS!AUuy9j23qwhNGXMWf
z{7Nw9rzu8a>A2;`8}w3PmP~rn#BXF$87FP;-XBY4XTC*jW`)bNjH!^DHkzNt5mjO;
zm*V{*z*=b7O2#b0YOpxxWKp`n3|$M~8~PSGyCbkGpuEcOQ$Ci!XPvZq`=~Q}$RblD
zhtmh*mZ<{DAd5?tE;o(eX>pgKOjYhvWvqG5y3kY=s*)@#);n{5g}%t|xaqmf;8WGC
zFwW3rcpuCCZOQ2Lw3Reem0CiasGvgYB72i;ET;2#n?@IzIo+o5CFL8J)|qOl3NbJz
zVyWqP^ne~K6s`N)QnFXuwO1us5ikPEb~%-r&J=V!*;f<tvc*pAY$Qcl7AEzJ&C0r*
zKpke~G0s|0u2liK$F@o&k*GG<b~=^jf%~oWZhInSs0-8@pIWW3x{wfKiM{q7tIa{5
z!=_h7$613PAkC@^6>cjAX?C_F@EYDF<5p^QpUnz$I*U}DIZnf}?m2DY2<y2;rWaq%
za`%HG7RZX|iN@o@yeM>4c-1PuYM^xsbQD&de$_;yWMi^3tmviQ1n)#W@n|X~QD+pU
z`&1iK;2FkP?07y!E<NwuQ|U9u7R+Uf!n|~V<k@e@JvfE)nR8ssXFdevHp^B(?y~yH
zo2-8F9;=_c#qtTca&uKVTP3LAH*eRvmwb&Hjx6EZb(BgLLVe>=1RIZ|ZuBTZ4`Ugd
z%h^2dVXS<B!zEMzT;}F?Ilt>Da4D9ty^1}iBLWv-HQ)SLlNWzASIU2Nt|PdRpGf%;
zG*+%Vg67Jrj-a(5x|XLB4c*ky&y7rKSB0P!FCqfC7?)&qZp`Xz97p?T^`%GA@p;a0
zRP<_9ZqBb$cqckJ=2)Ri&g>G)l>w^4)#08~p2p^Rtn2i+I=pju+STEk!|_VvF?Xjw
zYmLr8(CgjZVa(y$ppT8xIjjwNf<}9=w6((wnzzFY`Gcl=WDZM10ncN`s4Hj;j=F=T
zgU4`X3AP<9Rl!nO>b+q$^Ob{!3K}9&-W~`Aj^QeWP6~ZTsPq`FRrmt7bQ+BhVP$1t
z9z*UMI<)w;hcZ76c|wM(wLN6GTZ87Hv#Bg%)<2Ya;-F7)liAFsgI-1Xvzd<L7#nR2
zdE^`|NAa$s`29|A$UBdnl)fzF&1&aXL3jP^+rJTKxV4{?EI@#J2%~#xsL#=x_aTJ)
zu@Vm;f+KXqLp18cysyur7e_IOM=*qAm}LJ9$8W|7d=ii2F4jo*<4b&dg8xq7Im-Da
z<$VuN;dMNXlXymXaE~g-SGB|LBmn4^ERLjQQ3t}4tzDE(Ah5NYI=SFdrHFCV&9^sj
zBS$@4{XF)t&x=~_9_Q0Xo$tdG5(HI*mATE?0kmQ(ra5Zha{f~B2W*w{EEgcjmPySU
zkYZpM)PFhBy6<&@aRz(Y-bc&S<~7+*O&q!VDfa-!?nT8Z{)+S#OdoDir{Ga<qt1sv
z^r4$?etzoIn^;ovCdx7t#92ylrVPshe#ulSz8T0+ud__>VM}&O<ZM%NGWb*1!cBlT
z;XjEMo`b*CWW(yOcshyi#-<ZZuJ#j8;-->**ZMgGn^v^Dn)%`L#3Oj`L6=(5bYeF1
zqvrcL+ociXgzwj>?+f(8i?sR+w97ZNR~sFvIj^D-AEdWf>2cQ0+N))#*S>UV3mPbS
z3zcGwD$Y8HKcSXR`2MMculgMK^mFIK+4$5--jWMex2wZ5hgLzj#E?9X;m;J2I&=(w
zQNrjNV-UFW==Z3gr+zl`LdfmPk9$IHCo0JW;gByIm9mb(b4$p>uRGxjc{@EasH5+t
z=8z{FPc)BbHj~uWapGycrr&Q<>+cYM-=*7MCbIsWG4vnA-OK35_gU4yLj3&~-j5&9
zDzEUG{y+Fz&i^!iq^<ZaP4b8HRy+*x7Yk9`hQFrN65{paSu57^7mJUx&&{a46o12c
z9`0pOo*;M(>+lJ-Jlt;~svT(+l;+5&pbSBEC%kXT54ha~cDXznGdM4YD?x6zk8(94
zmuE=ZZU=GQl3G|5;C6n~cO@U>t|t3VRt72qg0KPMU@UE#$DyFR-PIyrl>tGS&{Ab!
zHuFPqqu*gdch1XnaijEWitO-`j=hiI)5q}lB{+o2{OgruU-1k5A9T-Vo|m?;E&V#0
z_v;<=nCtM8G2<k6KcCZl27-QJ{KjBF_`a@1(>)W#A&2(|9ZnAjhrjADx?kEa<^k~;
zO};HW*gXZ_4S6MG98kQ6Nfh`Q-TE5g@k@r$YiPo+Nl9<uN>XDFV|0M`h<D=@>Fp%;
zDur8B32s*|%qlnTB6Z%Uyu2%W@GRfI#qsYelb4w?{EC#iiqb!(1LtHOG$%>Ed+7=~
zfV8-mZVuq*r07Y8l*w=uQgl;;FOuk`btOstK?2D`O_r0`g<5aL)uef8-A?Lwm`^`u
zxn`cN06vSgS!%r(;ViZOf-{b4=m~jBvEaykgmML3Q!w5_g#`SPQ#g-Ux-diA2x$>i
z`v02*VL3iqgVKdV9Nw&WewxawYTiU?hFhLR0JlGeM;$!kC7M7Ak8Ka)c=hM!@wod6
zhcN^t1m@+!1Ue^=4RFfxNAWM<Ngr>ipU2beXdx9m%Iqb5e4WR02TPQ!(WLOCq*R9>
z8yS93)l2|2U;%&&R4v+69WGT%(W65AL3<g0s19=7a_u>XG`HnFw~eXo>r~nxS-e0?
zmvE#(rzD3oYfzG5Mdp#X<1JIN$68K*5&!C(RK3h|3X47@q1Ne^;F-raBDZ}ChYEq@
zDKx!7#?&2|SA!lM7d}2EE+jrAPNXK1cf%#|ah<EfoWq8YJLn6R-q0RoIdns7N7-rb
zd<p15Lk0&=dkvNi9yC?ZWYKa$M;06RHHF;s_%_wuSuo=OYZ0iG^ztg+$1da_lrBO<
zMQF+<T&|k=SBDl{ty=lZ{w4gizMa3puf-m9DGA^*e1h+X*?+g{V&JU95p{(&^+5uh
zcFCJsY8WR-9wIjfXlgIRMk)+9R^TJ#ZQ;`hK0x-CFu0sN`aM2<42K)>pKSRVB0I_H
z5)gx$*`?MP!Zz}|)Ee9Q7mOdUWwKgn#;a_V=|FfVyr)pjK*(T24&*Lf70{^;ygh0?
zQ+I|62*oluWSr_N{4ig1zn5=vS6GvWa{nBvnsY$z6O-~yL-fZ5+v@6GZD4)UgL*z!
zt4-QIy4qn)?^O47w1Q(F3Ee7z9m_H5;($(W9RJPK<=igrrtzet&_R{YuYGyF2IjD=
zC8t+E>Gc-s#@y;@?qj!B@Rg=Qm9dPL;@?wIuCB!zwHX(yKD4vlr3SU8VSVf?vYM8o
zP3JjY+Nh%FT%xVKM0Bpt+0RkCmJ0tbGi|QY__1UwV#2M}Uw<4w8Le`Kt4g*X#n1Yi
zt6!VP>&?}_p2x}N>QnQ0o8PKwUa5hW2bE`Dm2Nw(sz#fSs+xIKyRBg1RYV5VQ`G-y
zEK$#3nR*ss^;I;e=WvPo8voe*d{OYP&m(d@$-%kGU99R!5G4%#pjx5M<9TzG3dpQS
zcn&w?gQ-@9)%kpuvvm<kA)>z<86)7m%|%oy)xuA!x|neh;*UY5T6<-Pu_6gdVeGe)
CUtpC0

literal 9579
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