From: Benjamin Auder Date: Wed, 4 Feb 2015 15:53:17 +0000 (+0100) Subject: commit last state X-Git-Url: https://git.auder.net/variants/current/css/img/scripts/%24%7BgetWhatsApp%28link%29%7D?a=commitdiff_plain;h=81923e5c228da9009430108440a750edb062efb6;p=ppam-mpi.git commit last state --- 81923e5c228da9009430108440a750edb062efb6 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9baa2c6 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +/code/build/* +/code/data/src/ diff --git a/code/data/test/integers.txt b/code/data/test/integers.txt new file mode 100644 index 0000000..4803f02 --- /dev/null +++ b/code/data/test/integers.txt @@ -0,0 +1,3 @@ +1234,-987,654321,12 +345678 +-1234 diff --git a/code/data/test/reals.txt b/code/data/test/reals.txt new file mode 100644 index 0000000..ef894e6 --- /dev/null +++ b/code/data/test/reals.txt @@ -0,0 +1,4 @@ +1234.056,987e-3,-654321E-2,12.34567 +345678 +-1234.05 +3.0000000e-001,-1.0188000e+000 diff --git a/code/data/test/sample_byCols.bin b/code/data/test/sample_byCols.bin new file mode 100644 index 0000000..effa00e Binary files /dev/null and b/code/data/test/sample_byCols.bin differ diff --git a/code/data/test/sample_byCols.csv b/code/data/test/sample_byCols.csv new file mode 100644 index 0000000..55d304e --- /dev/null +++ b/code/data/test/sample_byCols.csv @@ -0,0 +1,13 @@ +FK_CCU_ID,CPP_DATE_PUISSANCE,CPP_PUISSANCE_CORRIGEE,CPP_PUISSANCE_BRUTE +12301,12JAN2009:00:30:00,,23.051 +12301,12JAN2009:01:00:00,,33.052 +12301,12JAN2009:01:30:00,32.32,43.053 +50000,23MAR2009:00:30:00,,150.321 +50000,23MAR2009:01:00:00,,160.322 +50000,23MAR2009:01:30:00,11.1,140.323 +1313,30MAY2009:10:30:00,10.0,50.05 +1313,30MAY2009:11:00:00,,51.05 +1313,30MAY2009:11:30:00,,52.05 +6300,20JUL2009:08:30:00,,500.30 +6300,20JUL2009:09:00:00,,501.31 +6300,20JUL2009:09:30:00,1.001,502.32 diff --git a/code/data/test/sample_byRows.bin b/code/data/test/sample_byRows.bin new file mode 100644 index 0000000..0bb324b Binary files /dev/null and b/code/data/test/sample_byRows.bin differ diff --git a/code/data/test/sample_byRows.csv b/code/data/test/sample_byRows.csv new file mode 100644 index 0000000..a91eafb --- /dev/null +++ b/code/data/test/sample_byRows.csv @@ -0,0 +1,4 @@ +12301,23.051,,33.052,43.053 +50000,150.321,160.322,140.323 +1313,50.05,51.05,52.05 +6300,500.30,501.31,,502.32 diff --git a/code/postprocess/hungarian.c b/code/postprocess/hungarian.c new file mode 100644 index 0000000..6cdc261 --- /dev/null +++ b/code/postprocess/hungarian.c @@ -0,0 +1,371 @@ +/******************************************************************** + ******************************************************************** + ** + ** libhungarian by Cyrill Stachniss, 2004 + ** -- modified (very) slightly by Benjamin Auder, 2010 + ** -- (verbose and printing routines deleted, because used in a R package) + ** + ** + ** Solving the Minimum Assignment Problem using the + ** Hungarian Method. + ** + ** ** This file may be freely copied and distributed! ** + ** + ** Parts of the used code was originally provided by the + ** "Stanford GraphGase", but I made changes to this code. + ** As asked by the copyright node of the "Stanford GraphGase", + ** I hereby proclaim that this file are *NOT* part of the + ** "Stanford GraphGase" distribution! + ** + ** This file is distributed in the hope that it will be useful, + ** but WITHOUT ANY WARRANTY; without even the implied + ** warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + ** PURPOSE. + ** + ******************************************************************** + ********************************************************************/ + +#include +#include + +#define HUNGARIAN_NOT_ASSIGNED 0 +#define HUNGARIAN_ASSIGNED 1 + +#define HUNGARIAN_MODE_MINIMIZE_COST 0 +#define HUNGARIAN_MODE_MAXIMIZE_UTIL 1 + +typedef struct { + int num_rows; + int num_cols; + int** cost; + int** assignment; +} hungarian_problem_t; + +#define INF (0x7FFFFFFF) +#define hungarian_test_alloc(X) do {if ((void *)(X) == NULL) fprintf(stderr, "Out of memory in %s, (%s, line %d).\n", __FUNCTION__, __FILE__, __LINE__); } while (0) + +/** This method initialize the hungarian_problem structure and init + * the cost matrices (missing lines or columns are filled with 0). + * It returns the size of the quadratic(!) assignment matrix. **/ +void hungarian_init(hungarian_problem_t* p, int* cost_matrix, int rows, int cols, int mode) { + + int i,j, org_cols, org_rows; + int max_cost; + max_cost = 0; + + org_cols = cols; + org_rows = rows; + + // is the number of cols not equal to number of rows ? + // if yes, expand with 0-cols / 0-cols + rows = (cols < rows) ? rows : cols; + cols = rows; + + p->num_rows = rows; + p->num_cols = cols; + + p->cost = (int**)calloc(rows,sizeof(int*)); + hungarian_test_alloc(p->cost); + p->assignment = (int**)calloc(rows,sizeof(int*)); + hungarian_test_alloc(p->assignment); + + for(i=0; inum_rows; i++) { + p->cost[i] = (int*)calloc(cols,sizeof(int)); + hungarian_test_alloc(p->cost[i]); + p->assignment[i] = (int*)calloc(cols,sizeof(int)); + hungarian_test_alloc(p->assignment[i]); + for(j=0; jnum_cols; j++) { + p->cost[i][j] = (i < org_rows && j < org_cols) ? cost_matrix[i*(p->num_cols)+j] : 0; + p->assignment[i][j] = 0; + + if (max_cost < p->cost[i][j]) + max_cost = p->cost[i][j]; + } + } + + if (mode == HUNGARIAN_MODE_MAXIMIZE_UTIL) { + for(i=0; inum_rows; i++) { + for(j=0; jnum_cols; j++) { + p->cost[i][j] = max_cost - p->cost[i][j]; + } + } + } +} + +/** Free the memory allocated by init. **/ +void hungarian_free(hungarian_problem_t* p) { + int i; + for(i=0; inum_rows; i++) { + free(p->cost[i]); + free(p->assignment[i]); + } + free(p->cost); + free(p->assignment); + p->cost = NULL; + p->assignment = NULL; +} + +/** This method computes the optimal assignment. **/ +void hungarian_solve(hungarian_problem_t* p) { + + int i, j, m, n, k, l, s, t, q, unmatched, cost; + int* col_mate; + int* row_mate; + int* parent_row; + int* unchosen_row; + int* row_dec; + int* col_inc; + int* slack; + int* slack_row; + + cost=0; + m =p->num_rows; + n =p->num_cols; + + col_mate = (int*)calloc(p->num_rows,sizeof(int)); + hungarian_test_alloc(col_mate); + unchosen_row = (int*)calloc(p->num_rows,sizeof(int)); + hungarian_test_alloc(unchosen_row); + row_dec = (int*)calloc(p->num_rows,sizeof(int)); + hungarian_test_alloc(row_dec); + slack_row = (int*)calloc(p->num_rows,sizeof(int)); + hungarian_test_alloc(slack_row); + + row_mate = (int*)calloc(p->num_cols,sizeof(int)); + hungarian_test_alloc(row_mate); + parent_row = (int*)calloc(p->num_cols,sizeof(int)); + hungarian_test_alloc(parent_row); + col_inc = (int*)calloc(p->num_cols,sizeof(int)); + hungarian_test_alloc(col_inc); + slack = (int*)calloc(p->num_cols,sizeof(int)); + hungarian_test_alloc(slack); + + for (i=0;inum_rows;i++) { + col_mate[i]=0; + unchosen_row[i]=0; + row_dec[i]=0; + slack_row[i]=0; + } + for (j=0;jnum_cols;j++) { + row_mate[j]=0; + parent_row[j] = 0; + col_inc[j]=0; + slack[j]=0; + } + + for (i=0;inum_rows;++i) + for (j=0;jnum_cols;++j) + p->assignment[i][j]=HUNGARIAN_NOT_ASSIGNED; + + // Begin subtract column minima in order to start with lots of zeroes 12 + for (l=0;lcost[0][l]; + for (k=1;kcost[k][l]cost[k][l]; + cost+=s; + if (s!=0) + for (k=0;kcost[k][l]-=s; + } + // End subtract column minima in order to start with lots of zeroes 12 + + // Begin initial state 16 + t=0; + for (l=0;lcost[k][0]; + for (l=1;lcost[k][l]cost[k][l]; + row_dec[k]=s; + for (l=0;lcost[k][l] && row_mate[l]<0) { + col_mate[k]=l; + row_mate[l]=k; + goto row_done; + } + col_mate[k]= -1; + unchosen_row[t++]=k; + row_done: + ; + } + // End initial state 16 + + // Begin Hungarian algorithm 18 + if (t==0) + goto done; + unmatched=t; + while (1) { + q=0; + while (1) { + while (qcost[k][l]-s+col_inc[l]; + if (delcost[k][l]cost[k][l]!=row_dec[k]-col_inc[l]) + exit(0); + } + k=0; + for (l=0;lm) + exit(0); + // End doublecheck the solution 23 + // End Hungarian algorithm 18 + + for (i=0;iassignment[i][col_mate[i]]=HUNGARIAN_ASSIGNED; + /*TRACE("%d - %d\n", i, col_mate[i]);*/ + } + for (k=0;kcost[k][l]=p->cost[k][l]-row_dec[k]+col_inc[l]; + } + } + for (i=0;i 1) + par(new=TRUE) + par(mar=c(5,5,2,2)) + plot(data[i,],type="l",col=cols[i],ylim=ylim, ...) + } +} + +getDistor = function(data, ctrs) +{ + distor = 0.0 + for (i in 1:nrow(data)) + distor = distor + min(sqrt(colSums((t(ctrs) - data[i,])^2))) + return (distor) +} + +getPartition = function(data, ctrs) +{ + partition = c() + for (i in 1:nrow(data)) + partition = c(partition, which.min(sqrt(colSums((t(ctrs) - data[i,])^2)))) + return (partition) +} + +#~ system("R CMD SHLIB hungarian.c") +#~ dyn.load("hungarian.so") +comparePartitions = function(partition1, partition2) +{ + result = 1.0 + n = length(partition1) + maxInd = max(partition1) + return ( .C("computeCoefSimil", P1=as.integer(partition1), P2=as.integer(partition2), + maxInd=as.integer(maxInd), n=as.integer(n), coefSimil=as.double(result))$coefSimil ) +} diff --git a/code/ppam.sh b/code/ppam.sh new file mode 100644 index 0000000..8bdccc2 --- /dev/null +++ b/code/ppam.sh @@ -0,0 +1,26 @@ +#!/bin/bash +#PBS -l walltime=00:05:00 +#PBS -l nodes=4:ppn=4,pmem=1gb +#PBS -o output.txt +#PBS -e error.txt + +WORKDIR="/workdir/auder/ppam_mpi/src" +cd $WORKDIR + +rm -f output.txt +rm -f error.txt + +saveLibPath=$LD_LIBRARY_PATH +LD_LIBRARY_PATH=/workdir/cds/lib:/opt/openmpi/lib:$LD_LIBRARY_PATH +export LD_LIBRARY_PATH + +# ppam args (in case of clustering) = +# 1: path to binary dataset +# 2: series per processor +# 3: number of clusters +# 4: boolean to randomize series sampling +# 5: type of distance (1 for L1, 2 for L2...) +mpirun -np 16 ppam cluster ../data/2009_first10000.bin 300 7 0 1 + +LD_LIBRARY_PATH=$saveLibPath +export LD_LIBRARY_PATH diff --git a/code/shared_CMakeLists.txt b/code/shared_CMakeLists.txt new file mode 100644 index 0000000..8832383 --- /dev/null +++ b/code/shared_CMakeLists.txt @@ -0,0 +1,7 @@ +#shared between library/exec and tests +set(CMAKE_C_FLAGS "-std=gnu99") +set(CMAKE_C_FLAGS_DEBUG "-g3") +set(CMAKE_C_FLAGS_RELEASE "-O3") + +#already by default... ?! +include_directories("${CMAKE_SOURCE_DIR}") diff --git a/code/src/Algorithm/compute_coefficients.c b/code/src/Algorithm/compute_coefficients.c new file mode 100644 index 0000000..a7a73f3 --- /dev/null +++ b/code/src/Algorithm/compute_coefficients.c @@ -0,0 +1,57 @@ +#include +#include "Util/types.h" +#include +#include +#include + +// compute rows of the matrix of reduced coordinates +void compute_coefficients(PowerCurve* powerCurves, uint32_t nbSeries, uint32_t nbValues, + Real* reducedCoordinates, uint32_t index, uint32_t nbReducedCoordinates) +{ + uint32_t D = (1 << nbReducedCoordinates); + Real* x = (Real*) malloc(nbValues*sizeof(Real)); + for (uint32_t i=0; i +#include + +// compute L^p dissimilarities for a nxm matrix +Real* get_dissimilarities_intra(Real* samples, uint32_t nbSamples, uint32_t nbValues, uint32_t p) +{ + Real* dissimilarities = (Real*) malloc(nbSamples*nbSamples*sizeof(Real)); + for (uint32_t i=0; i +#include +#include + +// auxiliary function to obtain a random sample of 1..n with k elements +static void sample(uint32_t* v, uint32_t n, uint32_t k) +{ + // refVect = (0,1,...,n-1,n) + uint32_t* refVect = (uint32_t*) malloc(n * sizeof(uint32_t)); + for (uint32_t i = 0; i < n; i++) + refVect[i] = i; + + uint32_t curSize = n; // current size of the sampling set + for (uint32_t j = 0; j < k; j++) + { + // pick an index in sampling set: + uint32_t index = get_rand_int() % curSize; + v[j] = refVect[index]; + // move this index outside of sampling set: + refVect[index] = refVect[--curSize]; + } + + free(refVect); +} + +// assign a vector (represented by its dissimilarities to others, as dissimilarities[index,]) +// to a cluster, represented by its center ==> output is integer in 0..K-1 +static uint32_t assignCluster(uint32_t index, Real* dissimilarities, + uint32_t* centers, uint32_t n, uint32_t K) +{ + uint32_t minIndex = 0; + Real minDist = dissimilarities[index * n + centers[0]]; + + for (uint32_t j = 1; j < K; j++) + { + if (dissimilarities[index * n + centers[j]] < minDist) + { + minDist = dissimilarities[index * n + centers[j]]; + minIndex = j; + } + } + + return minIndex; +} + +// assign centers given a clustering, and also compute corresponding distortion +static void assign_centers(uint32_t nbClusters, Vector** clusters, Real* dissimilarities, + uint32_t nbItems, uint32_t* ctrs, Real* distor) +{ + *distor = 0.0; + // TODO [heuristic]: checking only a neighborhood of the former center ? + for (uint32_t j = 0; j < nbClusters; j++) + { + // If the cluster is empty, choose a center at random (pathological case...) + uint32_t minIndex = get_rand_int() % nbItems; + Real minSumDist = INFINITY; + for (uint32_t i = 0; i < vector_size(clusters[j]); i++) + { + uint32_t index1; + vector_get(clusters[j], i, index1); + // attempt to use current index as center + Real sumDist = 0.0; + for (uint32_t ii = 0; ii < vector_size(clusters[j]); ii++) + { + uint32_t index2; + vector_get(clusters[j], ii, index2); + sumDist += dissimilarities[index1 * nbItems + index2]; + } + if (sumDist < minSumDist) + { + minSumDist = sumDist; + minIndex = index1; + } + } + ctrs[j] = minIndex; + *distor += minSumDist; + } +} + +// Core PAM algorithm from a dissimilarity matrix; (e.g. nstart=10, maxiter=100) +void pam(Real* dissimilarities, uint32_t nbItems, uint32_t nbClusters, int clustOnMedoids, + uint32_t nbStart, uint32_t maxNbIter, Result_t* result) +{ + uint32_t* ctrs = result->medoids_ranks; //shorthand + uint32_t* oldCtrs = (uint32_t*) malloc(nbClusters * sizeof(uint32_t)); + Vector** clusters = (Vector**) malloc(nbClusters * sizeof(Vector*)); + Vector** bestClusts = (Vector**) malloc(nbClusters * sizeof(Vector*)); + for (uint32_t j = 0; j < nbClusters; j++) + { + clusters[j] = vector_new(uint32_t); + bestClusts[j] = vector_new(uint32_t); + } + + Real lastDistor, distor, bestDistor = INFINITY; + for (uint32_t startKount = 0; startKount < nbStart; startKount++) + { + // centers (random) [re]initialization + if (clustOnMedoids) + { + // In this special case (clustering groups of medoids), we can improve the sampling + uint32_t randomMedoidRank = get_rand_int() % (nbItems / nbClusters); + uint32_t startIndex = randomMedoidRank * nbClusters; + for (uint32_t index = startIndex; index < startIndex + nbClusters; index++) + ctrs[index - startIndex] = index; + } + else + // No information: complete random sampling + sample(ctrs, nbItems, nbClusters); + for (uint32_t j = 0; j < nbClusters; j++) + oldCtrs[j] = 0; + uint32_t kounter = 0; + + distor = INFINITY; + do // while 'distortion' decreases... + { + // (re)initialize clusters to empty sets + for (uint32_t j = 0; j < nbClusters; j++) + vector_clear(clusters[j]); + + // estimate clusters belongings + for (uint32_t i = 0; i < nbItems; i++) + { + uint32_t affectation = assignCluster(i, dissimilarities, ctrs, nbItems, nbClusters); + vector_push(clusters[affectation], i); + } + + // copy current centers to old centers + for (uint32_t j = 0; j < nbClusters; j++) + oldCtrs[j] = ctrs[j]; + + // recompute centers + lastDistor = distor; + assign_centers(nbClusters, clusters, dissimilarities, nbItems, ctrs, &distor); + } + while (distor < lastDistor && kounter++ < maxNbIter); + + if (distor < bestDistor) + { + // copy current clusters into bestClusts + for (uint32_t j = 0; j < nbClusters; j++) + { + vector_clear(bestClusts[j]); + for (uint32_t i = 0; i < vector_size(clusters[j]); i++) + { + uint32_t index; + vector_get(clusters[j], i, index); + vector_push(bestClusts[j], index); + } + } + bestDistor = distor; + } + } + + // Assign centers from bestClusts + assign_centers(nbClusters, bestClusts, dissimilarities, nbItems, ctrs, &distor); + + free(oldCtrs); + for (uint32_t j = 0; j < nbClusters; j++) + { + vector_destroy(clusters[j]); + vector_destroy(bestClusts[j]); + } + free(clusters); + free(bestClusts); +} diff --git a/code/src/Algorithm/pam.h b/code/src/Algorithm/pam.h new file mode 100644 index 0000000..106919f --- /dev/null +++ b/code/src/Algorithm/pam.h @@ -0,0 +1,13 @@ +#ifndef PPAM_PAM_H +#define PPAM_PAM_H + +#include "Util/types.h" + +#define NSTART 5 +#define MAXITER 100 + +// Core PAM algorithm from a 'flat' dissimilarity matrix +void pam(Real* dissimilarities, uint32_t nbItems, uint32_t nbClusters, + int clustOnMedoids, uint32_t nbStart, uint32_t maxNbIter, Result_t* result); + +#endif diff --git a/code/src/CMakeLists.txt b/code/src/CMakeLists.txt new file mode 100644 index 0000000..f5039fe --- /dev/null +++ b/code/src/CMakeLists.txt @@ -0,0 +1,41 @@ +cmake_minimum_required(VERSION 2.8.5) +project(ppam_mpi) + +include("${CMAKE_SOURCE_DIR}/../shared_CMakeLists.txt") + +#ppam executable (serialize, cluster, classif) + +#cds +find_path(CDS_INCLUDE_PATH "cds/cds.h") +find_library(CDS_LIBRARY cds) +include_directories(${CDS_INCLUDE_PATH}) + +#GSL: standard location +find_path(GSL_INCLUDE_PATH "gsl/gsl_linalg.h") +include_directories(${GSL_INCLUDE_PATH}) +find_library(GSL_LIBRARY gsl) +find_library(GSLCBLAS_LIBRARY gslcblas) +set(GSL_LIBRARIES ${GSL_LIBRARY} ${GSLCBLAS_LIBRARY}) + +#MPI: standard location +find_package(MPI REQUIRED) +include_directories(${MPI_INCLUDE_PATH}) + +#LibXml2: standard location +find_package(LibXml2 REQUIRED) +include_directories(${LIBXML2_INCLUDE_DIR}) + +file(GLOB_RECURSE ppam_src "${CMAKE_SOURCE_DIR}/*.c") +add_executable(ppam.exe ${ppam_src}) +add_library(ppam SHARED ${ppam_src}) +target_link_libraries(ppam.exe m cds ${MPI_LIBRARIES} ${LIBXML2_LIBRARIES} ${GSL_LIBRARIES} ${CDS_LIBRARY}) +target_link_libraries(ppam m cds ${MPI_LIBRARIES} ${LIBXML2_LIBRARIES} ${GSL_LIBRARIES} ${CDS_LIBRARY}) + +if (MPI_COMPILE_FLAGS) + set_target_properties(ppam.exe PROPERTIES + COMPILE_FLAGS "${MPI_COMPILE_FLAGS}") +endif() +if (MPI_LINK_FLAGS) + set_target_properties(ppam.exe PROPERTIES + LINK_FLAGS "${MPI_LINK_FLAGS}") +endif() diff --git a/code/src/Classification/_Readme b/code/src/Classification/_Readme new file mode 100644 index 0000000..4e34128 --- /dev/null +++ b/code/src/Classification/_Readme @@ -0,0 +1,2 @@ +The output of a k-style clustering can easily be used for supervised classification: +we assign any new observation to the closest cluster representative ("center"). diff --git a/code/src/Classification/getClass.c b/code/src/Classification/getClass.c new file mode 100644 index 0000000..aed1467 --- /dev/null +++ b/code/src/Classification/getClass.c @@ -0,0 +1,46 @@ +#include "Algorithm/get_dissimilarities.h" +#include "TimeSeries/deserialize.h" +#include +#include "Algorithm/compute_coefficients.h" +#include +#include "Util/utils.h" + +uint32_t* get_class(PowerCurve* data, uint32_t nbSeries, PowerCurve* medoids, + uint32_t nbClusters, uint32_t nbValues, uint32_t p_for_dissims, double* DISTOR) +{ + // nbReducedCoordinates = smallest power of 2 which is above nbValues + uint32_t nbReducedCoordinates = (uint32_t)ceil(log2(nbValues)); + + // Preprocessing to reduce dimension of both data and medoids + Real* reducedCoordinates_data = (Real*) malloc(nbSeries * nbReducedCoordinates * sizeof(Real)); + compute_coefficients(data, nbSeries, nbValues, + reducedCoordinates_data, 0, nbReducedCoordinates); + Real* reducedCoordinates_medoids = (Real*) malloc(nbClusters * nbReducedCoordinates * sizeof(Real)); + compute_coefficients(medoids, nbClusters, nbValues, + reducedCoordinates_medoids, 0, nbReducedCoordinates); + + Real* dissimilarities = get_dissimilarities_inter(reducedCoordinates_data, nbSeries, + reducedCoordinates_medoids, nbClusters, nbReducedCoordinates, p_for_dissims); + free(reducedCoordinates_data); + free(reducedCoordinates_medoids); + + // 3] Finally, assign each row to the least dissimilar center + uint32_t* result = (uint32_t*) malloc(nbSeries*sizeof(uint32_t)); + for (uint32_t i=0; i +#include "Util/types.h" +#include "Util/utils.h" + +// serialize a Work_t object into a bytes string +void pack_work(Work_t* work, uint32_t nbSeriesInChunk, Byte* packedWork) +{ + uint32_t index = 0; + + while (work->inputFileName[index] != 0) + { + packedWork[index] = work->inputFileName[index]; + index++; + } + // complete with zeros + while (index < NCHAR_FNAME) + packedWork[index++] = 0; + + write_int(work->nbSeries, 4, packedWork + index); + index += 4; + + for (uint32_t i = 0; i < work->nbSeries; i++) + { + write_int(work->ranks[i], 4, packedWork + index); + index += 4; + } + // complete with zeros + for (uint32_t i = 0; i < nbSeriesInChunk - work->nbSeries; i++) + { + write_int(0, 4, packedWork + index); + index += 4; + } + + write_int(work->nbClusters, 4, packedWork + index); + index += 4; + write_int(work->clustOnMedoids, 4, packedWork + index); + index += 4; + write_int(work->p_for_dissims, 4, packedWork + index); +} + +// serialize a Result_t object into a bytes string +void pack_result(Result_t* result, Byte* packedResult) +{ + uint32_t index = 0; + + write_int(result->nbClusters, 4, packedResult); + index += 4; + + for (uint32_t i = 0; i < result->nbClusters; i++) + { + write_int(result->medoids_ID[i], 4, packedResult + index); + index += 4; + } + + for (uint32_t i = 0; i < result->nbClusters; i++) + { + write_int(result->medoids_ranks[i], 4, packedResult + index); + index += 4; + } +} diff --git a/code/src/MPI_Communication/pack.h b/code/src/MPI_Communication/pack.h new file mode 100644 index 0000000..38338f7 --- /dev/null +++ b/code/src/MPI_Communication/pack.h @@ -0,0 +1,12 @@ +#ifndef PPAM_PACK_H +#define PPAM_PACK_H + +#include "Util/types.h" + +// serialize a Work_t object into a bytes string +void pack_work(Work_t* work, uint32_t nbSeriesInChunk, Byte* packedWork); + +// serialize a Result_t object into a bytes string +void pack_result(Result_t* result, Byte* packedResult); + +#endif diff --git a/code/src/MPI_Communication/unpack.c b/code/src/MPI_Communication/unpack.c new file mode 100644 index 0000000..de51270 --- /dev/null +++ b/code/src/MPI_Communication/unpack.c @@ -0,0 +1,68 @@ +#include +#include "Util/types.h" +#include "Util/utils.h" + +// deserialize a Work_t object from a bytes string +Work_t* unpack_work(Byte* packedWork, uint32_t nbSeriesInChunk) +{ + Work_t* work = (Work_t*) malloc(sizeof(Work_t)); + + uint32_t index = 0; + + size_t inputFileNameSize = 0; + while (packedWork[inputFileNameSize++] != 0) { } + work->inputFileName = (char*) malloc(inputFileNameSize); + while (index < inputFileNameSize) + { + work->inputFileName[index] = packedWork[index]; + index++; + } + + index = NCHAR_FNAME; + + uint32_t nbSeries = work->nbSeries = bInt_to_uint(packedWork + index, 4); + index += 4; + + work->ranks = (uint32_t*) malloc(nbSeries * sizeof(uint32_t)); + for (uint32_t i = 0; i < nbSeries; i++) + { + work->ranks[i] = bInt_to_uint(packedWork + index, 4); + index += 4; + } + // shift over the zeros + index += 4 * (nbSeriesInChunk - nbSeries); + + work->nbClusters = bInt_to_uint(packedWork + index, 4); + index += 4; + work->clustOnMedoids = bInt_to_uint(packedWork + index, 4); + index += 4; + work->p_for_dissims = bInt_to_uint(packedWork + index, 4); + + return work; +} + +// deserialize a Result_t object from a bytes string +Result_t* unpack_result(Byte* packedResult) +{ + Result_t* result = (Result_t*) malloc(sizeof(Result_t)); + uint32_t index = 0; + + uint32_t nbClusters = result->nbClusters = bInt_to_uint(packedResult, 4); + index += 4; + + result->medoids_ID = (uint32_t*) malloc(nbClusters * sizeof(uint32_t)); + for (uint32_t i = 0; i < nbClusters; i++) + { + result->medoids_ID[i] = bInt_to_uint(packedResult + index, 4); + index += 4; + } + + result->medoids_ranks = (uint32_t*) malloc(nbClusters * sizeof(uint32_t)); + for (uint32_t i = 0; i < nbClusters; i++) + { + result->medoids_ranks[i] = bInt_to_uint(packedResult + index, 4); + index += 4; + } + + return result; +} diff --git a/code/src/MPI_Communication/unpack.h b/code/src/MPI_Communication/unpack.h new file mode 100644 index 0000000..3c7b414 --- /dev/null +++ b/code/src/MPI_Communication/unpack.h @@ -0,0 +1,12 @@ +#ifndef PPAM_UNPACK_H +#define PPAM_UNPACK_H + +#include "Util/types.h" + +// deserialize a Work_t object from a bytes string +Work_t* unpack_work(Byte* packedWork, uint32_t nbSeriesInChunk); + +// deserialize a Result_t object from a bytes string +Result_t* unpack_result(Byte* packedResult); + +#endif diff --git a/code/src/MPI_Main/master.c b/code/src/MPI_Main/master.c new file mode 100644 index 0000000..c4e16cd --- /dev/null +++ b/code/src/MPI_Main/master.c @@ -0,0 +1,383 @@ +#include "Util/types.h" +#include "Util/utils.h" +#include +#include +#include +#include +#include +#include +#include "MPI_Communication/pack.h" +#include "MPI_Communication/unpack.h" +#include "Util/rng.h" + +// save the final result in XML format +static void result_to_XML(Result_t* result, const char* inputFileName, + const char* lastBinaryFileName, uint32_t p_for_dissims) +{ + uint32_t nbClusters = result->nbClusters; + FILE* ofile = fopen("ppamResult.xml", "w"); + + fprintf(ofile, "\n\n"); + + fprintf(ofile, " "); + fprintf(ofile, "%s", lastBinaryFileName); + fprintf(ofile, "\n\n"); + + fprintf(ofile, " "); + fprintf(ofile, "%u", p_for_dissims); + fprintf(ofile, "\n\n"); + + fprintf(ofile, " \n"); + for (uint32_t i=0; i%u\n", result->medoids_ID[i]); + fprintf(ofile, " \n\n"); + + // medoids ranks in last binary file (human printing: 0 --> 1 ...etc) + fprintf(ofile, " \n"); + for (uint32_t i=0; i%u\n", result->medoids_ranks[i] + 1); + fprintf(ofile, " \n\n"); + + fprintf(ofile, "\n"); + fclose(ofile); +} + +static void binaryResult_to_file(Result_t* result, const char* inputFileName, + const char* outputFileName) +{ + // Determine tsLength from inputFile + uint32_t tsLength = get_tsLength(inputFileName); + + FILE* ifile = fopen(inputFileName, "rb"); + FILE* ofile = fopen(outputFileName, "ab"); //'append binary' + + Byte tsBuffer[tsLength]; + for (uint32_t i = 0; i < result->nbClusters; i++) + { + // Get time-series in (binary) inputFile + fseek(ifile, 8 + result->medoids_ranks[i] * tsLength, SEEK_SET); + // Copy current serie onto ofile + + size_t lengthRead = fread(tsBuffer, 1, tsLength, ifile); + if (lengthRead != tsLength) + fprintf(stderr, "problem while copying binary series to new file.\n"); + fwrite(tsBuffer, 1, tsLength, ofile); + } + + fclose(ifile); + fclose(ofile); +} + +// fill a new unit of work suitable to be given to a slave +static Work_t* get_next_work(char* inputFileName, uint32_t nbSeries, uint32_t nbSeriesInChunk, + double idealNbSeriesInChunk, uint32_t jobsSentCount, uint32_t lastEndIndex, + uint32_t nbClusters, uint32_t clustOnMedoids, + int randomize, uint32_t p_for_dissims) +{ + Work_t* work = (Work_t*) malloc(sizeof(Work_t)); + + work->inputFileName = (char*) malloc(strlen(inputFileName) + 1); + strcpy(work->inputFileName, inputFileName); + + if (randomize) + work->nbSeries = nbSeriesInChunk; + else + { + double adjustedNbSeriesInNextChunk = + idealNbSeriesInChunk * (jobsSentCount + 1) - lastEndIndex; + // round to closest integer + work->nbSeries = (uint32_t)adjustedNbSeriesInNextChunk; + // stay below the upper bound (TODO: is this check required ?) + if (work->nbSeries > nbSeriesInChunk) + work->nbSeries = nbSeriesInChunk; + // TODO: what about this one ? (probably useless) + if (lastEndIndex + work->nbSeries > nbSeries) + work->nbSeries = nbSeries - lastEndIndex; + } + + //TODO: ranks on uint64_t if more than 4.3 billion series at the same place (unlikely...) + work->ranks = (uint32_t*) malloc(work->nbSeries * sizeof(uint32_t)); + for (uint32_t i = 0; i < work->nbSeries; i++) + work->ranks[i] = (randomize ? get_rand_int() % nbSeries : lastEndIndex + i); + + work->nbClusters = nbClusters; + work->clustOnMedoids = clustOnMedoids; + work->p_for_dissims = p_for_dissims; + + return work; +} + +// process all subtasks and save binary results into a new file +// NOTE: this file will be smaller than initial file (or DB...) +static void clusters_reduce(char* inputFileName, char* outputFileName, uint32_t ntasks, + uint32_t totalNbSeries, uint32_t nbSeriesInChunk, double idealNbSeriesInChunk, + uint32_t tsLength, uint32_t nbClusters, uint32_t clustOnMedoids, + int randomize, uint32_t p_for_dissims) +{ + FILE* ofile = fopen(outputFileName, "wb"); //'write binary' + // Leave a blank for series' count and tsLength + for (uint32_t i = 0; i < 8; i++) + fputc(0, ofile); + fclose(ofile); + + uint32_t jobsSentCount = 0; //used if randomize==FALSE + uint32_t lastEndIndex = 0; //used if randomize==FALSE + + uint32_t sentSeriesCount = 0; //used if randomize==TRUE + + // Count series sent to binary file on output + uint32_t newSeriesCount = 0; + + // Expected size of a Work message in bytes: + uint32_t work_message_length = get_packedWork_length(nbSeriesInChunk); + Byte packedWork[work_message_length]; + + // Expected size of a Result message in bytes: (uint32_t is on 4 bytes) + uint32_t result_message_length = 4 + 4 * nbClusters + 4 * nbClusters; + Byte packedResult[result_message_length]; + + // Seed the slaves; send one unit of work to each slave. + Work_t* work; + int* busy_slave = (int*) malloc(ntasks * sizeof(int)); + for (int rank = 1; rank < ntasks; rank++) + busy_slave[rank] = 0; + for (int rank = 1; rank < ntasks; rank++) + { + // Find the next item of work to do + work = get_next_work(inputFileName, totalNbSeries, nbSeriesInChunk, idealNbSeriesInChunk, + jobsSentCount, lastEndIndex, nbClusters, clustOnMedoids, + randomize, p_for_dissims); + + if (randomize) + sentSeriesCount += nbSeriesInChunk; + else + { + lastEndIndex = lastEndIndex + work->nbSeries; + jobsSentCount++; + } + + // Send it to current rank + pack_work(work, nbSeriesInChunk, packedWork); + free_work(work); + fprintf(stdout, "0 / Send work %s to rank=%i / %u\n",inputFileName, rank, + (randomize ? sentSeriesCount : lastEndIndex)); + MPI_Send(packedWork, work_message_length, MPI_BYTE, rank, WORKTAG, MPI_COMM_WORLD); + + busy_slave[rank] = 1; + + if ((randomize && sentSeriesCount >= 1.5*totalNbSeries) //TODO: 1.5 = heuristic, magic number... + || (!randomize && lastEndIndex >= totalNbSeries)) + { + // Nothing more to read + break; + } + } + + // Loop over getting new work requests until there is no more work to be done + Result_t* result; + MPI_Status status; + while (1) + { + // If no slave is active, job is over + int atLeastOneSlaveActive = 0; + for (int rank = 1; rank < ntasks; rank++) + { + if (busy_slave[rank]) + { + atLeastOneSlaveActive = 1; + break; + } + } + if (!atLeastOneSlaveActive) + break; + + // Receive results from a slave + MPI_Recv(packedResult, result_message_length, MPI_BYTE, MPI_ANY_SOURCE, + WORKTAG, MPI_COMM_WORLD, &status); + result = unpack_result(packedResult); + fprintf(stdout, "0 / Receive result from rank=%i on %s\n",status.MPI_SOURCE,inputFileName); + + // 'binarize' the result (only series' values) returned by the slave + binaryResult_to_file(result, inputFileName, outputFileName); + free_result(result); + newSeriesCount += nbClusters; + + if ((randomize && sentSeriesCount < totalNbSeries) + || (!randomize && lastEndIndex < totalNbSeries)) + { + // Get the next unit of work to be done + work = get_next_work(inputFileName, totalNbSeries, nbSeriesInChunk, + idealNbSeriesInChunk, jobsSentCount, lastEndIndex, nbClusters, + clustOnMedoids, randomize, p_for_dissims); + + if (randomize) + sentSeriesCount += nbSeriesInChunk; + else + { + lastEndIndex = lastEndIndex + work->nbSeries; + jobsSentCount++; + } + + // Send the slave a new work unit + pack_work(work, nbSeriesInChunk, packedWork); + free_work(work); + fprintf(stdout, "0 / Send work %s to rank=%i / %u\n",inputFileName, status.MPI_SOURCE, + (randomize ? sentSeriesCount : lastEndIndex)); + MPI_Send(packedWork, work_message_length, MPI_BYTE, + status.MPI_SOURCE, WORKTAG, MPI_COMM_WORLD); + } + + else + // No more work to do + busy_slave[status.MPI_SOURCE] = 0; + } + + // There's no more work to be done, so receive all results from the slaves. + for (int rank = 1; rank < ntasks; rank++) + { + if (busy_slave[rank]) + { + MPI_Recv(packedResult, result_message_length, MPI_BYTE, + rank, WORKTAG, MPI_COMM_WORLD, &status); + result = unpack_result(packedResult); + + // 'binarize' the result (only series' values) returned by the slave + binaryResult_to_file(result, inputFileName, outputFileName); + free_result(result); + newSeriesCount += nbClusters; + } + } + free(busy_slave); + + // Finalize output file: write total number of series inside it, and tsLength + ofile = fopen(outputFileName, "r+b"); //read and write, binary + fseek(ofile, 0, SEEK_SET); + Byte intBuffer[4]; + write_int(newSeriesCount, 4, intBuffer); + fwrite(intBuffer, 1, 4, ofile); + write_int(tsLength, 4, intBuffer); + fwrite(intBuffer, 1, 4, ofile); + fclose(ofile); +} + +// generate random temporary file names +static char* get_unique_name() +{ + size_t nbDigits = 7; //rather arbitrary + size_t stringLength = 5 + nbDigits; //5 for '.tmp/' + char* s = (char*) malloc(stringLength + 1); + s[0] = '.'; + s[1] = 't'; + s[2] = 'm'; + s[3] = 'p'; + s[4] = '/'; + for (int i=0; i= nbSeriesInChunk) + { + fprintf(stdout, "WARNING: cluster size (%u) may be too high compared with chunk size (%u).\n", + nbClusters, nbSeriesInChunk); + } + + // Find out how many processes there are in the default communicator + int ntasks; + MPI_Comm_size(MPI_COMM_WORLD, &ntasks); + if (ntasks <= 1) + { + fprintf(stderr,"No slaves available (only master running).\n"); + return; + } + + // initializations + char* inputFileName = mainInputFileName; + char* outputFileName; + + uint32_t nbSeriesInFile = totalNbSeries; + + while (nbSeriesInFile > nbSeriesInChunk) + { + outputFileName = get_unique_name(); + uint32_t clustOnMedoids = (nbSeriesInFile < totalNbSeries ? 1 : 0); + clusters_reduce(inputFileName, outputFileName, ntasks, nbSeriesInFile, nbSeriesInChunk, + idealNbSeriesInChunk, tsLength, nbClusters, clustOnMedoids, + randomize, p_for_dissims); + + // read nbSeries in outputFile + nbSeriesInFile = get_nbSeries(outputFileName); + + // update file names + if (strcmp(mainInputFileName, inputFileName) != 0) + { + // No need to keep every intermediate binary + unlink(inputFileName); + free(inputFileName); + } + inputFileName = outputFileName; + } + + // read nbSeries in inputFileName (the last one) + // we know that there is at most 'nbSeriesInChunk' series in it + nbSeriesInFile = get_nbSeries(inputFileName); + + // Expected size of a Work message in bytes: + uint32_t work_message_length = get_packedWork_length(nbSeriesInChunk); + Byte packedWork[work_message_length]; + + // Expected size of a Result message in bytes: (uint32_t is on 4 bytes) + uint32_t result_message_length = get_packedResult_length(nbClusters); + Byte packedResult[result_message_length]; + + // Run a last task by some slave, and get final result + Work_t* work = get_next_work(inputFileName, nbSeriesInFile, nbSeriesInChunk, + (double)nbSeriesInFile, 0, 0, nbClusters, 1, 0, p_for_dissims); + + // Send the slave a new work unit + pack_work(work, nbSeriesInChunk, packedWork); + free_work(work); + int selectedSlaveRank = get_rand_int() % (ntasks - 1) + 1; + fprintf(stdout, "0 / Send final work %s to rank=%i / %u\n", + inputFileName, selectedSlaveRank, nbSeriesInFile); + MPI_Send(packedWork, work_message_length, MPI_BYTE, selectedSlaveRank, + WORKTAG, MPI_COMM_WORLD); + + MPI_Status status; + // Wait for him to finish + MPI_Recv(packedResult, result_message_length, MPI_BYTE, selectedSlaveRank, + WORKTAG, MPI_COMM_WORLD, &status); + Result_t* finalResult = unpack_result(packedResult); + fprintf(stdout, "0 / Receive final result from rank=%i on %s\n",status.MPI_SOURCE,inputFileName); + + //Tell all the slaves to exit by sending an empty message with the DIETAG. + for (int rank = 1; rank < ntasks; ++rank) + MPI_Send(0, 0, MPI_BYTE, rank, DIETAG, MPI_COMM_WORLD); + + const char finalBinaryName[] = "ppamFinalSeries.bin"; + result_to_XML(finalResult, inputFileName, finalBinaryName, p_for_dissims); + free_result(finalResult); + + // free memory + if (strcmp(mainInputFileName, inputFileName)) + { + // Keep last input binary, but rename it + rename(inputFileName, finalBinaryName); + free(inputFileName); + } + else + { + // just symlink mainInputFileName + if (!access(finalBinaryName, F_OK)) + unlink(finalBinaryName); + if (symlink(mainInputFileName, finalBinaryName)) + fprintf(stderr,"Cannot create symlink to initial binary file.\n"); + } +} diff --git a/code/src/MPI_Main/master.h b/code/src/MPI_Main/master.h new file mode 100644 index 0000000..397ea59 --- /dev/null +++ b/code/src/MPI_Main/master.h @@ -0,0 +1,11 @@ +#ifndef PPAM_MASTER_H +#define PPAM_MASTER_H + +#include + +// code executed by master process +void master_run(char* fileName, uint32_t totalNbSeries, uint32_t nbSeriesInChunk, + double idealNbSeriesInChunk, uint32_t tsLength, uint32_t nbClusters, + int randomize, uint32_t p_for_dissims); + +#endif diff --git a/code/src/MPI_Main/slave.c b/code/src/MPI_Main/slave.c new file mode 100644 index 0000000..d9b0c47 --- /dev/null +++ b/code/src/MPI_Main/slave.c @@ -0,0 +1,111 @@ +#include "Util/types.h" +#include "Util/utils.h" +#include "TimeSeries/deserialize.h" +#include "Algorithm/compute_coefficients.h" +#include "Algorithm/get_dissimilarities.h" +#include "Algorithm/pam.h" +#include +#include +#include +#include +#include +#include "MPI_Communication/unpack.h" +#include "MPI_Communication/pack.h" + +// main job done by a slave: +static Result_t* do_work(Work_t* work) +{ + // *** Step 1 *** + // Obtain reduced coordinates matrix from time-series. + + uint32_t nbSeries = work->nbSeries; + uint32_t tsLength = get_tsLength(work->inputFileName); + uint32_t nbValues = (tsLength - 4) / 3; + + // nbReducedCoordinates = smallest power of 2 which is above nbValues + uint32_t nbReducedCoordinates = (uint32_t)ceil(log2(nbValues)); + Real* reducedCoordinates = (Real*) malloc(nbSeries * nbReducedCoordinates * sizeof(Real)); + + // call preprocessing with the rows of raw power values matrix. + // Keep the IDs in memory for further processing. + uint32_t* IDs = (uint32_t*)malloc(nbSeries*sizeof(uint32_t)); + for (uint32_t i = 0; i < nbSeries; i+=CURVES_PER_REQUEST) + { + uint32_t nbCurvesRetrieved = CURVES_PER_REQUEST; + if (i + nbCurvesRetrieved > nbSeries) + nbCurvesRetrieved -= (i + nbCurvesRetrieved - nbSeries); + PowerCurve* powerCurves = + deserialize(work->inputFileName, NULL, work->ranks + i, nbCurvesRetrieved); + compute_coefficients(powerCurves, nbCurvesRetrieved, nbValues, + reducedCoordinates, i, nbReducedCoordinates); + for (uint32_t ii=i; iip_for_dissims); + free(reducedCoordinates); + + uint32_t nbClusters = work->nbClusters; + Result_t* result = (Result_t*) malloc(sizeof(Result_t)); + result->medoids_ID = (uint32_t*) malloc(nbClusters * sizeof(uint32_t)); + result->medoids_ranks = (uint32_t*) malloc(nbClusters * sizeof(uint32_t)); + result->nbClusters = nbClusters; + + // Run PAM algorithm to fill result->medoids_ranks + pam(dissimilarities, nbSeries, nbClusters, work->clustOnMedoids, NSTART, MAXITER, result); + free(dissimilarities); + + // Deduce medoids_IDs from indices + for (uint32_t i = 0; i < nbClusters; i++) + result->medoids_ID[i] = IDs[result->medoids_ranks[i]]; + free(IDs); + + // return medoids IDs, indices and items labels (to be post-processed) + return result; +} + +// code executed by slave process +void slave_run(int myrank, uint32_t nbSeriesInChunk, uint32_t nbClusters) +{ + Work_t* work; + Result_t* result; + MPI_Status status; + + // Expected size of a Work message in bytes: + uint32_t work_message_length = get_packedWork_length(nbSeriesInChunk); + Byte packedWork[work_message_length]; + + // Expected size of a Result message in bytes: (uint32_t is on 4 bytes) + uint32_t result_message_length = get_packedResult_length(nbClusters); + Byte packedResult[result_message_length]; + + while (1) + { + // Receive a message from the master + MPI_Recv(packedWork, work_message_length, MPI_BYTE, 0, + MPI_ANY_TAG, MPI_COMM_WORLD, &status); + + // Check the tag of the received message. + if (status.MPI_TAG == DIETAG) + return; + + // Do the work + work = unpack_work(packedWork, nbSeriesInChunk); + fprintf(stdout, "%u / Slave pid=%u work on %s\n",myrank,getpid(),work->inputFileName); + result = do_work(work); + free_work(work); + + // Send the result back + pack_result(result, packedResult); + free_result(result); + MPI_Send(packedResult, result_message_length, MPI_BYTE, 0, WORKTAG, MPI_COMM_WORLD); + } +} diff --git a/code/src/MPI_Main/slave.h b/code/src/MPI_Main/slave.h new file mode 100644 index 0000000..b5ef443 --- /dev/null +++ b/code/src/MPI_Main/slave.h @@ -0,0 +1,9 @@ +#ifndef PPAM_SLAVE_H +#define PPAM_SLAVE_H + +#include + +// code executed by slave process +void slave_run(int myrank, uint32_t nbSeriesInChunk, uint32_t nbClusters); + +#endif diff --git a/code/src/TimeSeries/deserialize.c b/code/src/TimeSeries/deserialize.c new file mode 100644 index 0000000..5d1d758 --- /dev/null +++ b/code/src/TimeSeries/deserialize.c @@ -0,0 +1,82 @@ +#include "TimeSeries/deserialize.h" +#include +#include "Util/utils.h" + +// Deserialize a portion of a binary file into an array of PowerCurve, or a file +// WARNING: NO start bytes, NO date times (all series have the same length, at same times). +PowerCurve* deserialize(const char* ifileName, const char* ofileName, + uint32_t* ranks, uint32_t nbRanks) +{ + // Read tsLength at the beginning of the file + uint32_t tsLength = get_tsLength(ifileName); + + uint32_t valuesPerSerie = (tsLength - 4) / 3; //remove 4 bytes of ID + + FILE* ifile = fopen(ifileName, "rb"); + FILE* ofile = NULL; + if (ofileName) + ofile = fopen(ofileName, "w"); + + if (!ranks || nbRanks <= 0) + { + nbRanks = get_nbSeries(ifileName); + ranks = NULL; + } + + PowerCurve* powerCurves = NULL; + if (!ofile) + powerCurves = (PowerCurve*) malloc(nbRanks * sizeof(PowerCurve)); + + for (uint32_t i = 0; i < nbRanks; i++) + { + // position to the beginning of current (binarized) time-series + // NOTE: shift by 8 bytes, because data size and series length are written first + fseek(ifile, 8 + (ranks ? ranks[i] : i) * tsLength, SEEK_SET); + + PowerCurve* powerCurve; + if (!ofile) + { + powerCurve = powerCurves + i; + powerCurve->values = (Real*) malloc(valuesPerSerie * sizeof(Real)); + } + + // translate 4-bytes binary integer into integer ID + void* binaryID = malloc(4); + size_t lengthRead = fread(binaryID, 4, 1, ifile); + if (lengthRead != 1) + fprintf(stderr,"Warning: deserializing truncated binary file.\n"); + uint32_t ID = bInt_to_uint((Byte*) binaryID, 4); + free(binaryID); + if (ofile) + fprintf(ofile, "%u,", ID); + else + powerCurve->ID = ID; + + // translate 3-bytes binary integers into Real + Byte* binarySerie = (Byte*) malloc(3 * valuesPerSerie); + lengthRead = fread(binarySerie, 1, 3*valuesPerSerie, ifile); + if (lengthRead != 3*valuesPerSerie) + fprintf(stderr,"Warning: deserializing truncated binary file.\n"); + for (uint32_t i = 0; i < valuesPerSerie; i++) + { + uint32_t powerInt = bInt_to_uint(binarySerie + 3 * i, 3); + if (ofile) + { + fprintf(ofile, "%g", powerInt / 10.0 - 0.0); + if (i < valuesPerSerie-1) + fprintf(ofile, ","); + } + else + powerCurve->values[i] = powerInt / 10.0 - 0.0; + } + free(binarySerie); + if (ofile) + fprintf(ofile, "\n"); + } + + fclose(ifile); + if (ofile) + fclose(ofile); + + return powerCurves; +} diff --git a/code/src/TimeSeries/deserialize.h b/code/src/TimeSeries/deserialize.h new file mode 100644 index 0000000..aa6a3d6 --- /dev/null +++ b/code/src/TimeSeries/deserialize.h @@ -0,0 +1,12 @@ +#ifndef PPAM_DESERIALIZE_H +#define PPAM_DESERIALIZE_H + +#include +#include +#include "Util/types.h" + +// deserialize a portion of a binary file into an array of PowerCurve +PowerCurve* deserialize(const char* ifileName, const char* ofileName, + uint32_t* ranks, uint32_t nbRanks); + +#endif diff --git a/code/src/TimeSeries/serialize.c b/code/src/TimeSeries/serialize.c new file mode 100644 index 0000000..ab552c9 --- /dev/null +++ b/code/src/TimeSeries/serialize.c @@ -0,0 +1,306 @@ +#include "TimeSeries/serialize.h" +#define __STDC_FORMAT_MACROS +#include +#include +#include "Util/types.h" +#include "Util/utils.h" +#include +#include + +// parse a line into two integers (ID, raw power) +static void scan_line(FILE* ifile, int posID, uint32_t* ID, int posPower, uint32_t* rawPower) +{ + char nextChar; + int position = 1; + while (1) + { + if (position == posID) + { + int64_t ID_on64bits; + nextChar = readInt(ifile, &ID_on64bits); + *ID = (uint32_t)ID_on64bits; + } + else if (position == posPower) + { + Real untruncatedPower; + nextChar = readReal(ifile, &untruncatedPower); + if (untruncatedPower < 0.0) + untruncatedPower = 0.0; + *rawPower = (uint32_t) floor(untruncatedPower*10.0); + } + else + //erase the comma (and skip field then) + nextChar = fgetc(ifile); + + //continue until next comma (or line end or file end) + while (!feof(ifile) && nextChar != '\n' && nextChar != '\r' && nextChar != ',') + nextChar = fgetc(ifile); + position++; + + if (feof(ifile) || nextChar == '\n' || nextChar == '\r') + { + // skip all potential line feeds + while (!feof(ifile) && nextChar == '\n' || nextChar == '\r') + nextChar = fgetc(ifile); + if (!feof(ifile)) + ungetc(nextChar, ifile); + break; + } + } +} + +//main job: parse a text file into a binary compressed version +//TODO [long term]: adapt to distributed files/DB, maybe to distributed binary chunks +void serialize_byCols(const char* ifileName, const char* ofileName, uint32_t nbItems) +{ + // use the header to know positions of ID and rawPower + FILE* ifile = fopen(ifileName, "r"); + uint32_t headerShift = 0; + char curChar; + Vector* header = vector_new(char); + do + { + curChar = fgetc(ifile); + headerShift++; + if (curChar == '\n' || curChar == '\r') + { + //flush all potential other line feeds + while (curChar == '\n' || curChar == '\r') + curChar = fgetc(ifile); + ungetc(curChar, ifile); + break; + } + vector_push(header, curChar); + } + while (1); + char* headerString = (char*)malloc((vector_size(header) + 1)*sizeof(char)); + VectorIterator* it = vector_get_iterator(header); + int index = 0; + while (vectorI_has_data(it)) + { + vectorI_get(it, headerString[index]); + vectorI_move_next(it); + index++; + } + vectorI_destroy(it); + headerString[index] = 0; + vector_destroy(header); + int position = 1, posID = 0, posPower = 0; + char* columnDescriptor = strtok(headerString, ","); + while (columnDescriptor != NULL) + { + if (!strcmp(columnDescriptor,"FK_CCU_ID") || !strcmp(columnDescriptor,"fk_ccu_id")) + posID = position; + else if (!strcmp(columnDescriptor,"CPP_PUISSANCE_BRUTE")) + posPower = position; + position++; + columnDescriptor = strtok(NULL, ","); + } + free(headerString); + + //estimate tsLength with a scan of the 3 first series + uint32_t ID=0, rawPower=0, lastID=0, refTsLength=0; + scan_line(ifile, posID, &ID, posPower, &rawPower); + //'sl' = sample lengths (short because a lot of comparisons then) + uint32_t* sl = (uint32_t*) calloc(3, sizeof(uint32_t)); + for (int i=0; i<3; i++) + { + lastID = ID; + while (ID == lastID) + { + sl[i]++; + scan_line(ifile, posID, &ID, posPower, &rawPower); + } + } + if (sl[1] <= sl[0] <= sl[2] || sl[2] <= sl[0] <= sl[1]) + refTsLength = sl[0]; + else if (sl[0] <= sl[1] <= sl[2] || sl[2] <= sl[1] <= sl[0]) + refTsLength = sl[1]; + else + refTsLength = sl[2]; + free(sl); + //go back at the beginning of the first series (ready to read '\n'...) + fseek(ifile, headerShift-1, SEEK_SET); + + // output file to write time-series sequentially, binary format. + // Format: for each series, ID is stored on 4 bytes (unsigned integer32). Then, + // ()+ follow, with rawPower stored as a "3 bytes int" + // rawPower values are multiplied by 10 and truncated one digit after 0 + // NOTE: no raw power should be exactly zero + FILE* ofile = fopen(ofileName, "wb"); + + // leave space to write the number of series (32bits), and their length in bytes (32bits) + for (int i = 0; i < 8; i++) + fputc(0, ofile); + + // process one client (ID in first column) at a time + uint64_t processedLines = 0; //execution trace + uint32_t seriesCount=0, skippedSeriesCount=0, tsLength=0; + uint32_t mismatchLengthCount=0, overflowCount=0; + Byte tsBuffer[4+3*refTsLength]; + int overflow = 0; + lastID = 0; + while (!feof(ifile)) + { + // next element to read always start with a digit + do + curChar = fgetc(ifile); + while (!feof(ifile) && (curChar < '0' || curChar > '9')); + if (feof(ifile)) + break; + ungetc(curChar, ifile); + + // read line + scan_line(ifile, posID, &ID, posPower, &rawPower); + if (ID != lastID) + { + //just starting a new time-series: must process the last one (if there is a last one !) + if (lastID > 0) + { + if (tsLength == refTsLength && !overflow) + { + seriesCount++; + fwrite(tsBuffer, 4+3*tsLength, 1, ofile); + if (nbItems > 0 && seriesCount >= nbItems) + break; + } + //if something wrong happened, skip series + else + { + skippedSeriesCount++; + if (tsLength != refTsLength) + mismatchLengthCount++; + if (overflow) + overflowCount++; + } + } + + // ID for the new series is printed only once: + write_int(ID, 4, tsBuffer); + // reinitialize flags + overflow = 0; + tsLength = 0; + lastID = ID; + } + + overflow = (overflow || (rawPower >= (1 << 24))); + //We cannot write more than refTsLength bytes + if (tsLength < refTsLength) + write_int(rawPower, 3, tsBuffer + 4+3*tsLength); + tsLength++; + + if ((++processedLines) % 1000000 == 0) + fprintf(stdout,"Processed %"PRIu64" lines\n", processedLines); + } + + if (!overflow && tsLength == refTsLength && (nbItems <= 0 || seriesCount < nbItems)) + { + // flush last time-series if all conditions are met + fwrite(tsBuffer, 4+3*tsLength, 1, ofile); + seriesCount++; + } + else if (nbItems <= 0 || seriesCount < nbItems) + { + if (tsLength != refTsLength) + mismatchLengthCount++; + if (overflow) + overflowCount++; + } + + // write lines count and size of a time-series in bytes + Byte intBuffer[4]; + fseek(ofile, 0, SEEK_SET); + write_int(seriesCount, 4, intBuffer); + fwrite(intBuffer, 1, 4, ofile); + // re-express tsLength in bytes (not forgetting the ID)) + write_int(4 + 3 * refTsLength, 4, intBuffer); + fwrite(intBuffer, 1, 4, ofile); + + // finally print some statistics + if (seriesCount < nbItems) + fprintf(stdout,"Warning: only %u series retrieved.\n",seriesCount); + fprintf(stdout,"%u overflows / %u mismatch series lengths.\n",overflowCount,mismatchLengthCount); + + fclose(ifile); + fclose(ofile); +} + +//serialize from usual 'by-row' data (for StarLight example and toy dataset) +void serialize_byRows(const char* ifileName, const char* ofileName, uint32_t nbItems) +{ + FILE* ifile = fopen(ifileName, "r"); + // first scan to know dimensions + uint32_t nbValues = 0; //ID (or, more useful, real class number) comes first + char curChar = ' '; + while (curChar != '\n' && curChar != '\r') + { + curChar = fgetc(ifile); + if (curChar == ',') + { + nbValues++; + //skip potential consecutive commas (could be hard to spot) + while (curChar == ',') + curChar = fgetc(ifile); + ungetc(curChar, ifile); + } + } + while (curChar == '\n' || curChar == '\r') + curChar = fgetc(ifile); + ungetc(curChar, ifile); + uint32_t nbSeries = 1; //we already read 1st line + while (!feof(ifile)) + { + if ((curChar = fgetc(ifile)) == '\n') + nbSeries++; + } + fseek(ifile, 0, SEEK_SET); + + //write meta info first + uint32_t tsLength = 3*nbValues+4; + FILE* ofile = fopen(ofileName, "wb"); + Byte intBuffer[4]; + write_int(nbSeries, 4, intBuffer); + fwrite(intBuffer, 1, 4, ofile); + write_int(tsLength, 4, intBuffer); + fwrite(intBuffer, 1, 4, ofile); + Real rawPower; + int64_t ID; + + //DEBUG / TEST (ugly, TOFIX...) + double minrp = INFINITY, maxrp = -INFINITY; + + for (uint32_t i=0; i maxrp) + maxrp = rawPower; + + write_int((uint32_t)floor(10.0*(rawPower+0.0)), 3, intBuffer); //x10... +3... + fwrite(intBuffer, 1, 3, ofile); + while (curChar == ',') + curChar = fgetc(ifile); + ungetc(curChar, ifile); + } + } + fclose(ifile); + fclose(ofile); + + //DEBUG / TEST (ugly, TOFIX...) + printf("min / max values = %g %g\n",minrp,maxrp); +} diff --git a/code/src/TimeSeries/serialize.h b/code/src/TimeSeries/serialize.h new file mode 100644 index 0000000..af89cae --- /dev/null +++ b/code/src/TimeSeries/serialize.h @@ -0,0 +1,14 @@ +#ifndef PPAM_SERIALIZE_H +#define PPAM_SERIALIZE_H + +#include +#include +#include + +//main job: parse a text file into a binary compressed version +void serialize_byCols(const char* ifileName, const char* ofileName, uint32_t nbItems); + +//serialize from usual 'by-row' data +void serialize_byRows(const char* ifileName, const char* ofileName, uint32_t nbItems); + +#endif diff --git a/code/src/Util/rng.c b/code/src/Util/rng.c new file mode 100644 index 0000000..6cd4025 --- /dev/null +++ b/code/src/Util/rng.c @@ -0,0 +1,135 @@ +// ISAAC PRNG +// Initial code by Bob Jenkins, March 1996 - modified in 2008 +// Reference: http://burtleburtle.net/bob/rand/isaacafa.html +// Further slightly modified by Benjamin Auder, 2013 + +#include "Util/rng.h" +#include +#include + +// Internal state +static uint32_t mm[256]; +static uint32_t aa, bb, cc; + +// initialize the (pseudo-)random generator +void init_rng(int flag) +{ + // 'bootstrap' isaac with basic bad PRNG + srand(time(NULL)); + + aa = rand() & 0xffffffff; + bb = rand() & 0xffffffff; + cc = rand() & 0xffffffff; + + uint32_t a, b, c, d, e, f, g, h, i; + // The golden ratio: + a = b = c = d = e = f = g = h = 0x9e3779b9; + // Scramble it + for (i = 0; i < 4; ++i) + mix(a, b, c, d, e, f, g, h); + + // Fill in mm[] with messy stuff (the seed) + uint32_t seedArray[256]; + for (i = 0; i < 256; ++i) mm[i] = seedArray[i] = rand() & 0xffffffff; + for (i = 0; i < 256; i += 8) + { + if (flag) + { + // Use all the information in the seed + a += seedArray[i ]; + b += seedArray[i + 1]; + c += seedArray[i + 2]; + d += seedArray[i + 3]; + e += seedArray[i + 4]; + f += seedArray[i + 5]; + g += seedArray[i + 6]; + h += seedArray[i + 7]; + } + mix(a, b, c, d, e, f, g, h); + mm[i ] = a; + mm[i + 1] = b; + mm[i + 2] = c; + mm[i + 3] = d; + mm[i + 4] = e; + mm[i + 5] = f; + mm[i + 6] = g; + mm[i + 7] = h; + } + + if (flag) + { + // Do a second pass to make all of the seed affect all of mm + for (i = 0; i < 256; i += 8) + { + a += mm[i ]; + b += mm[i + 1]; + c += mm[i + 2]; + d += mm[i + 3]; + e += mm[i + 4]; + f += mm[i + 5]; + g += mm[i + 6]; + h += mm[i + 7]; + mix(a, b, c, d, e, f, g, h); + mm[i ] = a; + mm[i + 1] = b; + mm[i + 2] = c; + mm[i + 3] = d; + mm[i + 4] = e; + mm[i + 5] = f; + mm[i + 6] = g; + mm[i + 7] = h; + } + } +} + +// return a (pseudo-)random integer +uint32_t get_rand_int() +{ + // TODO: register variables ? (x,y,i) + uint32_t x, y; + static uint32_t i = 0; + + if (i == 0) + { + cc = cc + 1; // cc just gets incremented once per 256 results + bb = bb + cc; // then combined with bb + } + + x = mm[i]; + switch (i % 4) + { + case 0: + aa = aa^(aa << 13); + break; + case 1: + aa = aa^(aa >> 6); + break; + case 2: + aa = aa^(aa << 2); + break; + case 3: + aa = aa^(aa >> 16); + break; + } + + // NOTE: bits 2..9 are chosen from x but 10..17 are chosen + // from y. The only important thing here is that 2..9 and 10..17 + // don't overlap. 2..9 and 10..17 were then chosen for speed in + // the optimized version (rand.c) */ + // See http://burtleburtle.net/bob/rand/isaac.html + // for further explanations and analysis. + + aa = mm[(i + 128) % 256] + aa; + mm[i] = y = mm[(x >> 2) % 256] + aa + bb; + bb = mm[(y >> 10) % 256] + x; + + i = (i + 1) % 256; + + return bb; +} + +// return a (pseudo-)random real number in [0,1] +Real get_rand_real() +{ + return (Real) (INV_RANDMAX * (double) get_rand_int()); +} diff --git a/code/src/Util/rng.h b/code/src/Util/rng.h new file mode 100644 index 0000000..40822aa --- /dev/null +++ b/code/src/Util/rng.h @@ -0,0 +1,33 @@ +#ifndef PPAM_RNG_H +#define PPAM_RNG_H + +#include +#include "Util/types.h" + +#define INV_RANDMAX 2.3283064370807974E-10 // 1/0xffffffff + +// If (flag!=0), then use a random array to initialize mm[] +#define mix(a,b,c,d,e,f,g,h) \ +{ \ + a^=b<<11; d+=a; b+=c; \ + b^=c>>2; e+=b; c+=d; \ + c^=d<<8; f+=c; d+=e; \ + d^=e>>16; g+=d; e+=f; \ + e^=f<<10; h+=e; f+=g; \ + f^=g>>4; a+=f; g+=h; \ + g^=h<<8; b+=g; h+=a; \ + h^=a>>9; c+=h; a+=b; \ +} + +// initialize the (pseudo-)random generator +// NOTE: flag has only two states, active or not. +// flag != 0 --> "maximal randomness" +void init_rng(int flag); + +// return a (pseudo-)random integer +uint32_t get_rand_int(); + +// return a (pseudo-)random real number in [0,1] +Real get_rand_real(); + +#endif diff --git a/code/src/Util/types.h b/code/src/Util/types.h new file mode 100644 index 0000000..eaab1b0 --- /dev/null +++ b/code/src/Util/types.h @@ -0,0 +1,46 @@ +#ifndef PPAM_TYPES_H +#define PPAM_TYPES_H + +#include + +// types of work given to a slave +#define WORKTAG 1 +#define DIETAG 2 + +// 256 characters for file name should be enough +#define NCHAR_FNAME 256 + +typedef unsigned char Byte; + +typedef double Real; + +// Type to describe a job to be done in a node +//TODO: merge with packed version to avoid extra copy by MPI +typedef struct Work_t { + // "structural" parameters: + char* inputFileName; + uint32_t nbSeries; + uint32_t* ranks; + // clustering parameters [to be completed]: + uint32_t nbClusters; + uint32_t clustOnMedoids; //a boolean, but 1 byte storage would be inefficient + uint32_t p_for_dissims; +} Work_t; + +// Type returned by a worker (clusters labels and medoids) +//TODO: merge with packed version to avoid extra copy by MPI +typedef struct Result_t { + // parameters describing sizes + uint32_t nbClusters; + // informative parameters: + uint32_t* medoids_ID; + uint32_t* medoids_ranks; +} Result_t; + +// data structure to store a customer ID + [time-]serie +typedef struct PowerCurve { + uint32_t ID; + Real* values; +} PowerCurve; + +#endif diff --git a/code/src/Util/utils.c b/code/src/Util/utils.c new file mode 100644 index 0000000..3786eda --- /dev/null +++ b/code/src/Util/utils.c @@ -0,0 +1,117 @@ +#include "Util/utils.h" +#include +#include + +void free_work(Work_t* work) +{ + free(work->inputFileName); + free(work->ranks); + free(work); +} + +void free_result(Result_t* result) +{ + free(result->medoids_ID); + free(result->medoids_ranks); + free(result); +} + +char readInt(FILE* stream, int64_t* integer) +{ + *integer = 0; + char curChar = fgetc(stream); + int sign = (curChar == '-' ? -1 : 1); + while (curChar < '0' || curChar > '9') + curChar = fgetc(stream); + ungetc(curChar, stream); + while ((curChar = fgetc(stream)) >= '0' && curChar <= '9') + *integer = 10 * (*integer) + (int64_t) (curChar - '0'); + (*integer) *= sign; + return curChar; +} + +char readReal(FILE* stream, Real* real) +{ + int64_t integerPart; + char nextChar = readInt(stream, &integerPart); + int64_t fractionalPart = 0; + int countZeros = 0; + if (nextChar == '.') + { + //need to count zeros + while ((nextChar = fgetc(stream)) == '0') + countZeros++; + if (nextChar >= '0' && nextChar <= '9') + { + ungetc(nextChar, stream); + nextChar = readInt(stream, &fractionalPart); + } + } + int64_t exponent = 0; + if (nextChar == 'e' || nextChar == 'E') + nextChar = readInt(stream, &exponent); + int64_t divisorForFractional = pow(10, floor(log10(fractionalPart > 0 ? fractionalPart : 1))+1); + *real = ( (Real)integerPart + + (integerPart < 0 ? -1 : 1) * (Real)fractionalPart/(divisorForFractional*pow(10,countZeros)) ) + * pow(10,exponent); + return nextChar; +} + +// convert n-bytes binary integers to uint32_t +uint32_t bInt_to_uint(Byte* pInteger, size_t bytesCount) +{ + uint32_t integer = 0; + for (size_t i = 0; i < bytesCount; i++) + integer += ((uint32_t) (pInteger[i])) << (i << 3); + return integer; +} + +// serialize integers with a portable bytes order +void write_int(uint32_t integer, size_t bytesCount, Byte* buffer) +{ + Byte chunk; + // write from left to right, from least to most significative bit + for (size_t i = 0; i < bytesCount; i++) + { + chunk = (integer >> (i << 3)) & 0xFF; + buffer[i] = chunk; + } +} + +// Expected size of a Work message in bytes: +uint32_t get_packedWork_length(uint32_t nbSeriesInChunk) +{ + return NCHAR_FNAME + 4 + 4*nbSeriesInChunk + 4 + 4 + 4; +} + +// Expected size of a Result message in bytes: (uint32_t is on 4 bytes) +uint32_t get_packedResult_length(uint32_t nbClusters) +{ + return 4 + 4 * nbClusters + 4 * nbClusters; +} + +// get metadata: nbSeries +uint32_t get_nbSeries(const char* ifileName) +{ + FILE* ifile = fopen(ifileName, "rb"); + fseek(ifile, 0, SEEK_SET); + Byte binaryInt[4]; + size_t lengthRead = fread(binaryInt, 4, 1, ifile); + if (lengthRead != 1) + fprintf(stderr,"Warning: getting nbSeries from truncated binary file.\n"); + fclose(ifile); + return bInt_to_uint(binaryInt, 4); +} + +// get metadata: tsLength +uint32_t get_tsLength(const char* ifileName) +{ + FILE* ifile = fopen(ifileName, "rb"); + fseek(ifile, 4, SEEK_SET); + Byte binaryInt[4]; + size_t lengthRead = fread(binaryInt, 4, 1, ifile); + if (lengthRead != 1) + fprintf(stderr,"Warning: getting tsLength from truncated binary file.\n"); + fclose(ifile); + return bInt_to_uint(binaryInt, 4); +} diff --git a/code/src/Util/utils.h b/code/src/Util/utils.h new file mode 100644 index 0000000..2ed68aa --- /dev/null +++ b/code/src/Util/utils.h @@ -0,0 +1,36 @@ +#ifndef PPAM_UTIL_UTILS_H +#define PPAM_UTIL_UTILS_H + +#include "Util/types.h" +#include +#include + +#define CURVES_PER_REQUEST 50 + +void free_work(Work_t* work); + +void free_result(Result_t* result); + +char readInt(FILE* stream, int64_t* integer); + +char readReal(FILE* stream, Real* real); + +// convert n-bytes binary integers to uint32_t +uint32_t bInt_to_uint(Byte* pInteger, size_t bytesCount); + +// serialize integers with a portable bytes order +void write_int(uint32_t integer, size_t bytesCount, Byte* buffer); + +// Expected size of a Work message in bytes: +uint32_t get_packedWork_length(uint32_t nbSeriesInChunk); + +// Expected size of a Result message in bytes: (uint32_t is on 4 bytes) +uint32_t get_packedResult_length(uint32_t nbClusters); + +// get metadata: nbSeries +uint32_t get_nbSeries(const char* ifileName); + +// get metadata: tsLength +uint32_t get_tsLength(const char* ifileName); + +#endif diff --git a/code/src/main.c b/code/src/main.c new file mode 100644 index 0000000..bb4bd46 --- /dev/null +++ b/code/src/main.c @@ -0,0 +1,272 @@ +#include "MPI_Main/master.h" +#include "MPI_Main/slave.h" +#include "Util/utils.h" +#include "Util/rng.h" +#include +#include +#include +#include +#include "TimeSeries/serialize.h" +#include "TimeSeries/deserialize.h" +#include "Classification/getClass.h" +#include +#include +#include + +// serialize text file argv[1] into a binary file argv[2] +int serialize_main(int argc, char** argv) +{ + const char* ifileName = argv[1]; + const char* ofileName = argv[2]; + int byCols = atoi(argv[3]); + uint32_t nbItems = atoi(argv[4]); //==0 for "all series" + + if (byCols) + serialize_byCols(ifileName, ofileName, nbItems); + else + serialize_byRows(ifileName, ofileName, nbItems); + return 0; +} + +// deserialize binary file argv[1] into text file argv[2] +int deserialize_main(int argc, char** argv) +{ + const char* ifileName = argv[1]; + const char* ofileName = argv[2]; + Vector* vranks = vector_new(uint32_t); + //each token is at most two ints (a-b = from a to b included) + char* token = strtok(argv[3], ","); + int retrieveAll = 0; + uint32_t* ranks = NULL; + while (token) + { + //scan token to find middle position of '-' (if any) + int minusPos = -1; + int tokenLength = strlen(token); + //loop starts at index 1 because -N is allowed (and means 'everything') + for (int i=1; i totalNbSeries) + nbSeriesInChunk = totalNbSeries; + if (nbClusters > nbSeriesInChunk) + nbClusters = nbSeriesInChunk; + + double idealNbSeriesInChunk = 0.0; //unused if randomize == TRUE + if (!randomize) + { + // Adjust nbSeriesInChunk to avoid small remainders. + // Each node should have at least nbSeriesInChunk (as given to the function). + + // ==> We seek for the largest N such that (double)totalNbSeries / N >= nbSeriesInChunk + uint32_t N = totalNbSeries / nbSeriesInChunk + 1; + while ((double)totalNbSeries / N < nbSeriesInChunk) N--; + // At this point N>=1 is the solution + idealNbSeriesInChunk = (double)totalNbSeries / N; + nbSeriesInChunk = ceil(idealNbSeriesInChunk); + } + + // Initialize random generator + init_rng(1); + + // Find out my identity in the default communicator + int myrank; + MPI_Comm_rank(MPI_COMM_WORLD, &myrank); + + if (myrank == 0) + { + // create temporary folder for intermediate results + mkdir(".tmp", S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH); + + master_run(ifileName, totalNbSeries, nbSeriesInChunk, idealNbSeriesInChunk, + tsLength, nbClusters, randomize, p_for_dissims); + } + + else + slave_run(myrank, nbSeriesInChunk, nbClusters); + + MPI_Finalize(); + return 0; +} + +//main classification task (using clustering result) +int classif_main(int argc, char** argv) +{ + const char* ifileName = argv[1]; + const char* xmlFileName = argv[2]; + + // 1] load and retrieve info from XML file + xmlDoc* doc = xmlReadFile(xmlFileName, NULL, 0); + + // Get the root element node + xmlNode* root_element = xmlDocGetRootElement(doc); + + uint32_t p_for_dissims = 0; + uint32_t* ranks = NULL; + uint32_t nbClusters = 0; + char* binFileName; + for (xmlNode* cur_node=root_element->children; cur_node; cur_node=cur_node->next) + { + if (cur_node->type != XML_ELEMENT_NODE) + continue; + if (!strcmp(cur_node->name,"p_for_dissims")) + p_for_dissims = atoi(cur_node->last->content); + else if (!strcmp(cur_node->name,"ranks")) + { + //first pass: find nbClusters + for (xmlNode* rankNode=cur_node->children; rankNode; rankNode=rankNode->next) + { + if (rankNode->type == XML_ELEMENT_NODE && !strcmp(rankNode->name,"rank")) + nbClusters++; + } + //second pass: fill ranks (not optimal, but not very important here) + ranks = (uint32_t*) malloc(nbClusters*sizeof(uint32_t)); + uint32_t index = 0; + for (xmlNode* rankNode=cur_node->children; rankNode; rankNode=rankNode->next) + { + if (rankNode->type == XML_ELEMENT_NODE && !strcmp(rankNode->name,"rank")) + ranks[index++] = atoi(rankNode->last->content) - 1; + } + } + else if (!strcmp(cur_node->name,"file")) + { + binFileName = (char*) malloc(strlen(cur_node->last->content)+1); + strcpy(binFileName, cur_node->last->content); + } + } + + xmlFreeDoc(doc); + xmlCleanupParser(); + + uint32_t tsLength1 = get_tsLength(ifileName); + uint32_t tsLength2 = get_tsLength(binFileName); + if (tsLength1 != tsLength2) + { + fprintf(stderr,"Warning: nbValues do not match. Data will be truncated.\n"); + if (tsLength1 > tsLength2) + tsLength1 = tsLength2; + } + uint32_t nbValues = (tsLength1 - 4) / 3; + + // 2] Classify all series by batches of CURVES_PER_REQUEST + uint32_t nbSeries = get_nbSeries(ifileName); + PowerCurve* medoids = deserialize(binFileName, NULL, ranks, nbClusters); + free(binFileName); + free(ranks); + ranks = (uint32_t*)malloc(CURVES_PER_REQUEST*sizeof(uint32_t)); + + uint32_t smallestNonProcessedIndex = 0; + double DISTOR = 0.0; + while (smallestNonProcessedIndex < nbSeries) + { + uint32_t lowerBound = smallestNonProcessedIndex; + uint32_t upperBound = smallestNonProcessedIndex + CURVES_PER_REQUEST; + if (upperBound > nbSeries) + upperBound = nbSeries; + for (uint32_t i=0; i +#include + +void t_compute_coefficients1() +{ + uint32_t nbSeries = 3; + uint32_t nbValues = 10; + Real curves[] = + { + 1.0,2.0,3.0,4.0,1.0,2.0,3.0,4.0,1.0,2.0, + 3.0,4.0,1.0,2.0,3.0,4.0,1.0,1.0,2.0,3.0, + 3.0,1.0,0.0,8.0,2.0,4.0,2.0,0.0,3.0,3.0 + }; + + PowerCurve* powerCurves = (PowerCurve*)malloc(nbSeries*sizeof(PowerCurve)); + for (int i=0; i 10, 2^3 < 10 + Real* reducedCoordinates = (Real*)malloc(nbSeries * nbReducedCoordinates * sizeof(Real)); + Real epsilon = 1e-4; + compute_coefficients(powerCurves, nbSeries, nbValues, reducedCoordinates, 0, nbReducedCoordinates); + free(powerCurves); + + //~ LUT_ASSERT(fabs(reducedCoordinates[0] - 1.2829311) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[1] - 2.8197073) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[2] - 2.7653092) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[3] - 0.5390868) < epsilon); +//~ + //~ LUT_ASSERT(fabs(reducedCoordinates[4] - 1.433019) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[5] - 3.319643) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[6] - 2.078569) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[7] - 1.248209) < epsilon); +//~ + //~ LUT_ASSERT(fabs(reducedCoordinates[8] - 1.4532363) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[9] - 6.1433038) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[10] - 5.2052217) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[11] - 0.3447528) < epsilon); + + free(reducedCoordinates); +} + +void t_compute_coefficients2() +{ + uint32_t nbSeries = 3; + uint32_t nbValues = 20; + Real curves[] = + { + 0.07291223,0.3468863,0.8648239,0.2348877,0.4315312,0.7036144,0.2431289,0.01040031,0.1178515,0.03080914,0.3673594,0.3738354,0.6695186,0.9140619,0.3102869,0.6374112,0.843919,0.2661967,0.1571974,0.7748992, + 0.8818654,0.6703627,0.8847847,0.03184918,0.997876,0.7612137,0.6387965,0.296034,0.5018912,0.7942868,0.1095461,0.3727642,0.2351644,0.5057783,0.7287164,0.340264,0.08904832,0.5050351,0.1371493,0.8821361, + 0.1844872,0.5861217,0.7114864,0.8779052,0.5999996,0.2707162,0.9586406,0.6902478,0.2514943,0.8113025,0.2820882,0.5661663,0.9571422,0.6838519,0.998652,0.6126693,0.9178886,0.7810725,0.7895782,0.181061 + }; + + PowerCurve* powerCurves = (PowerCurve*)malloc(nbSeries*sizeof(PowerCurve)); + for (int i=0; i 20, 2^4 < 20 + Real* reducedCoordinates = (Real*)malloc(nbSeries * nbReducedCoordinates * sizeof(Real)); + Real epsilon = 1e-4; + compute_coefficients(powerCurves, nbSeries, nbValues, reducedCoordinates, 0, nbReducedCoordinates); + free(powerCurves); + + //~ LUT_ASSERT(fabs(reducedCoordinates[0] - 1.2829311) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[1] - 2.8197073) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[2] - 2.7653092) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[3] - 0.5390868) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[4] - 0.5390868) < epsilon); +//~ + //~ LUT_ASSERT(fabs(reducedCoordinates[5] - 3.319643) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[6] - 2.078569) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[7] - 1.248209) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[8] - 1.4532363) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[9] - 6.1433038) < epsilon); +//~ + //~ LUT_ASSERT(fabs(reducedCoordinates[10] - 5.2052217) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[11] - 0.3447528) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[12] - 0.3447528) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[13] - 1.248209) < epsilon); + //~ LUT_ASSERT(fabs(reducedCoordinates[14] - 1.248209) < epsilon); + + free(reducedCoordinates); +} diff --git a/code/test/Algorithm/t.pam.c b/code/test/Algorithm/t.pam.c new file mode 100644 index 0000000..06f1fe5 --- /dev/null +++ b/code/test/Algorithm/t.pam.c @@ -0,0 +1,541 @@ +#include "Algorithm/pam.h" +#include +#include "Util/types.h" +#include "lut.h" +#include + +// 3 "regular flowers", dissimilarity = euclidian +void t_pam1() +{ + uint32_t nbClusters = 3; + Result_t* result = (Result_t*)malloc(sizeof(Result_t)); + result->medoids_ranks = (uint32_t*)malloc(nbClusters*sizeof(uint32_t)); + result->nbClusters = nbClusters; + +// double M[] = +// { +// -4,4, +// -3,5, +// -5,5, +// -5,3, +// -3,3, +// 0,0, +// 1,1, +// -1,1, +// -1,-1, +// 1,-1, +// 4,-4, +// 5,-3, +// 3,-3, +// 3,-5, +// 5,-5 +// }; + + uint32_t nbSeries = 15; + Real dissimilarities[] = + { + 0,1.414214,1.414214,1.414214,1.414214,5.656854,5.830952,4.242641,5.830952,7.071068,11.31371,11.40175,9.899495,11.40175,12.72792, + 1.414214,0,2,2.828427,2,5.830952,5.656854,4.472136,6.324555,7.211103,11.40175,11.31371,10,11.6619,12.80625, + 1.414214,2,0,2,2.828427,7.071068,7.211103,5.656854,7.211103,8.485281,12.72792,12.80625,11.31371,12.80625,14.14214, + 1.414214,2.828427,2,0,2,5.830952,6.324555,4.472136,5.656854,7.211103,11.40175,11.6619,10,11.31371,12.80625, + 1.414214,2,2.828427,2,0,4.242641,4.472136,2.828427,4.472136,5.656854,9.899495,10,8.485281,10,11.31371, + 5.656854,5.830952,7.071068,5.830952,4.242641,0,1.414214,1.414214,1.414214,1.414214,5.656854,5.830952,4.242641,5.830952,7.071068, + 5.830952,5.656854,7.211103,6.324555,4.472136,1.414214,0,2,2.828427,2,5.830952,5.656854,4.472136,6.324555,7.211103, + 4.242641,4.472136,5.656854,4.472136,2.828427,1.414214,2,0,2,2.828427,7.071068,7.211103,5.656854,7.211103,8.485281, + 5.830952,6.324555,7.211103,5.656854,4.472136,1.414214,2.828427,2,0,2,5.830952,6.324555,4.472136,5.656854,7.211103, + 7.071068,7.211103,8.485281,7.211103,5.656854,1.414214,2,2.828427,2,0,4.242641,4.472136,2.828427,4.472136,5.656854, + 11.31371,11.40175,12.72792,11.40175,9.899495,5.656854,5.830952,7.071068,5.830952,4.242641,0,1.414214,1.414214,1.414214,1.414214, + 11.40175,11.31371,12.80625,11.6619,10,5.830952,5.656854,7.211103,6.324555,4.472136,1.414214,0,2,2.828427,2, + 9.899495,10,11.31371,10,8.485281,4.242641,4.472136,5.656854,4.472136,2.828427,1.414214,2,0,2,2.828427, + 11.40175,11.6619,12.80625,11.31371,10,5.830952,6.324555,7.211103,5.656854,4.472136,1.414214,2.828427,2,0,2, + 12.72792,12.80625,14.14214,12.80625,11.31371,7.071068,7.211103,8.485281,7.211103,5.656854,1.414214,2,2.828427,2,0 + }; + + pam(dissimilarities, nbSeries, nbClusters, 0, NSTART, MAXITER, result); + // check that centers (medoids_ranks) span {0, 5, 10} + uint32_t* ctrs = result->medoids_ranks; + LUT_ASSERT(ctrs[0] != ctrs[1] && ctrs[1] != ctrs[2] && ctrs[2] != ctrs[0]); + LUT_ASSERT(ctrs[0] == 0 || ctrs[1] == 0 || ctrs[2] == 0); + LUT_ASSERT(ctrs[0] == 5 || ctrs[1] == 5 || ctrs[2] == 5); + LUT_ASSERT(ctrs[0] == 10 || ctrs[1] == 10 || ctrs[2] == 10); + + free(result->medoids_ranks); + free(result); +} + +// 4 well-separated Gaussian clusters, dissimilarity = euclidian +void t_pam2() +{ + uint32_t nbClusters = 4; + Result_t* result = (Result_t*)malloc(sizeof(Result_t)); + result->medoids_ranks = (uint32_t*)malloc(nbClusters*sizeof(uint32_t)); + result->nbClusters = nbClusters; + +// double M[] = +// { +// -4.450371,-4.543001, +// -4.711869,-4.961091, +// -5.083656,-4.674564, +// -3.586104,-5.887045, +// -3.185154,-3.541619, +// -5.033892,-4.596002, +// -3.004485,-5.171559, +// -4.528517,-4.003823, +// -3.721287,-5.419952, +// -4.121808,-4.629665, +// -4.05129,-4.85515, +// -4.035312,-5.660147, +// -3.290654,-4.240134, +// -1.902941,-4.663231, +// -3.070627,-3.537133, +// -5.799731,-6.077648, +// -2.999374,-4.396087, +// -3.826953,-3.367948, +// -6.482025,-2.427264, +// -5.412339,-3.98535, +// -3.37746,-3.841064, +// -4.712918,-3.058541, +// -2.440538,-4.408247, +// -3.116167,-6.130969, +// -4.604153,-3.708026, +// -3.472353,-3.137196, +// -3.843901,-3.447817, +// -3.340786,-2.312214, +// -4.328582,-4.133865, +// -2.906439,-5.249392, +// -3.55544,-4.535076, +// -4.346427,-4.156633, +// -2.092725,-4.128729, +// -5.015867,-5.179254, +// -4.543845,-2.916083, +// -4.145448,-5.715884, +// -4.390567,-2.307922, +// -3.003025,-5.588462, +// -2.844272,-4.292232, +// -3.51101,-5.665364, +// -4.669003,-3.983029, +// -4.040262,-3.338078, +// -4.002328,-3.652771, +// -3.732904,-6.027206, +// -4.094534,-3.500277, +// -3.587201,-4.003284, +// -4.816506,-4.769324, +// -3.062788,-3.027322, +// -2.899946,-6.049017, +// -4.912952,-4.773183, +// -1.916896,-0.009493825, +// 2.634858,-0.4243543, +// 0.3020768,1.64798, +// 1.319387,0.4383175, +// -0.001776739,-0.3686283, +// -0.3792117,-0.614869, +// -0.7154037,-0.6211681, +// -1.422143,0.2300399, +// 0.1448215,0.2528107, +// -0.665172,-1.395703, +// 1.447993,0.2860408, +// -0.3756387,-0.06096208, +// -1.001823,-0.2453904, +// -0.05310829,-2.201463, +// -0.6424461,-0.4816693, +// 0.9660234,-0.6773616, +// 0.3242067,0.6265039, +// -1.54016,0.3410867, +// -0.151697,0.9412011, +// -0.1419021,1.402804, +// 0.6756108,-2.120431, +// -0.4478024,-0.7631725, +// 0.640236,1.548211, +// 1.094596,1.688888, +// -0.4296057,-0.3780608, +// -0.3501862,-0.4554224, +// -0.7654625,-0.5809421, +// -0.3401964,-0.455078, +// 1.656617,-0.7471582, +// 1.436579,-0.3640174, +// 0.2339464,0.3475537, +// 0.08126267,1.06486, +// 0.2915553,-0.236505, +// 0.4851901,-1.010106, +// -0.07553644,-2.15231, +// -0.4303397,0.9054603, +// 0.004220171,1.033742, +// -0.3602884,1.916468, +// -0.4638079,-1.552088, +// -1.60057,-1.106041, +// -0.7134006,-1.567929, +// -1.337527,-3.620209, +// -0.1994646,-0.1307016, +// -0.2420102,-0.1121753, +// -0.536283,0.03036439, +// 2.467503,0.3452919, +// -0.3630185,1.174053, +// 0.1055285,-0.2248235, +// 1.267688,-0.3149153, +// -1.620448,-0.6095385, +// 5.14672,4.479654, +// 4.129114,5.259524, +// 5.365162,3.888272, +// 3.454389,2.743306, +// 2.861091,2.602548, +// 3.93366,4.617158, +// 4.57284,3.714136, +// 4.092174,3.671644, +// 4.50261,1.516262, +// 4.317581,3.683757, +// 4.259846,2.438663, +// 4.119361,6.446651, +// 5.691461,3.578193, +// 3.861858,3.574928, +// 3.537764,4.3348, +// 2.586984,4.144694, +// 4.565765,3.690908, +// 4.949011,3.678565, +// 4.21298,4.516202, +// 4.258206,3.375235, +// 3.862015,3.229653, +// 2.276514,3.281311, +// 3.461244,5.803409, +// 5.741595,4.279209, +// 3.847961,3.979272, +// 2.904032,5.174558, +// 4.973815,3.879027, +// 2.342122,2.615265, +// 2.576959,5.048676, +// 4.996508,3.129088, +// 4.908488,5.593342, +// 4.494416,4.222817, +// 6.292328,2.357233, +// 3.34451,3.270198, +// 2.269291,3.963629, +// 4.25654,3.247725, +// 2.894098,3.785049, +// 2.346439,4.385733, +// 5.85847,6.073889, +// 1.42734,4.093241, +// 4.07797,2.895063, +// 4.444542,2.00364, +// 5.394777,5.063008, +// 2.639821,4.398103, +// 4.273526,2.889649, +// 3.477858,5.404986, +// 5.729747,3.629496, +// 3.810896,4.770437, +// 3.71945,5.236858, +// 3.833841,3.280717, +// 4.152189,-5.99135, +// 3.19188,-5.967943, +// 5.042668,-6.489929, +// 5.237402,-4.916319, +// 5.335625,-3.950791, +// 4.027703,-4.435844, +// 3.654064,-5.122268, +// 5.109319,-3.817966, +// 5.21631,-4.550999, +// 4.518432,-6.290373, +// 4.224753,-3.722504, +// 4.315041,-4.396765, +// 5.56141,-4.3007, +// 4.428661,-3.642649, +// 3.759849,-5.697695, +// 3.478439,-5.001031, +// 4.693304,-5.403166, +// 4.822672,-3.103692, +// 4.885982,-3.900518, +// 5.715825,-4.795573, +// 6.714095,-5.538454, +// 4.872663,-6.734268, +// 5.04218,-6.48153, +// 5.145617,-4.279071, +// 3.550852,-5.84931, +// 4.806485,-4.733755, +// 4.280439,-4.219329, +// 4.628427,-5.355216, +// 4.133676,-5.390665, +// 4.283339,-4.694953, +// 5.662802,-4.493008, +// 3.031885,-4.058671, +// 4.413487,-4.646903, +// 6.535346,-4.918966, +// 3.408803,-3.448405, +// 4.701184,-6.628794, +// 5.478372,-4.380599, +// 5.902022,-6.036273, +// 4.379025,-2.736512, +// 4.590189,-3.72093, +// 4.625894,-5.511869, +// 5.09324,-4.854936, +// 5.402295,-7.326092, +// 7.355636,-3.345965, +// 4.646836,-5.001939, +// 5.450266,-7.242952, +// 4.197233,-5.91857, +// 3.848639,-4.45381, +// 5.578822,-4.595297, +// 5.741669,-4.29464 +// }; + + uint32_t nbSeries = 200; + Real dissimilarities[] = + { + 0,0.4931329,0.6468061,1.59794,1.61355,0.5859224,1.576601,0.5448115,1.140442,0.3398006,0.5066584,1.191759,1.198613,2.550266,1.707473,2.043505,1.458416,1.330188,2.933251,1.111916,1.282129,1.507499,2.014345,2.074064,0.8490186,1.712545,1.251893,2.491503,0.4268785,1.697855,0.8949661,0.4001053,2.393766,0.8512363,1.629601,1.211871,2.235879,1.785441,1.625559,1.463591,0.6011401,1.272803,0.9966205,1.648521,1.101768,1.018016,0.4304379,2.054914,2.161458,0.5166866,5.193379,8.195347,7.804742,7.622575,6.100441,5.657257,5.415788,5.652618,6.641958,4.922725,7.623015,6.057402,5.510167,4.981839,5.567289,6.654359,7.037072,5.685389,6.968147,7.342718,5.669615,5.505239,7.938334,8.341648,5.789066,5.78963,5.410773,5.796952,7.190531,7.219424,6.772028,7.20998,6.405605,6.069688,4.985437,6.770996,7.137468,7.64549,4.983799,4.464758,4.77661,3.246744,6.126875,6.110853,6.019614,8.470679,7.027884,6.277171,7.111463,4.845678,13.17241,13.02678,12.93952,10.7506,10.22332,12.41775,12.23105,11.85139,10.81067,12.02317,11.16295,13.93602,12.99271,11.61869,11.9426,11.18036,12.21016,12.4877,12.53486,11.77021,11.38024,10.31847,13.02466,13.47989,11.89502,12.1868,12.63906,9.868066,11.89049,12.16982,13.79615,12.52393,12.76788,11.03659,10.84051,11.68357,11.10395,11.22136,14.79833,10.44663,11.31625,11.04436,13.75508,11.41114,11.46083,12.72082,13.05467,12.44944,12.7433,11.39468,8.723632,7.773961,9.690631,9.694963,9.803899,8.478751,8.125111,9.587145,9.666684,9.137436,8.71384,8.766631,10.01471,8.924564,8.291021,7.942029,9.184045,9.384079,9.358433,10.16933,11.20876,9.577088,9.688468,9.599617,8.107158,9.258822,8.736808,9.115057,8.625799,8.735032,10.1133,7.497916,8.864467,10.99215,7.935033,9.38624,9.930072,10.45954,9.012305,9.077859,9.127831,9.548708,10.23819,11.86654,9.108776,10.26218,8.756327,8.299489,10.02933,10.19507, + 0.4931329,0,0.4693864,1.457648,2.084649,0.4868151,1.720307,0.9746689,1.091699,0.6767681,0.6690197,0.9728352,1.593622,2.824676,2.172863,1.558892,1.803294,1.82241,3.090911,1.201136,1.742156,1.90255,2.337644,1.978605,1.257686,2.20522,1.744525,2.982686,0.9117083,1.828303,1.232402,0.8835719,2.748225,0.3741792,2.051899,0.9436867,2.672553,1.820368,1.983757,1.392143,0.9790013,1.756481,1.488338,1.447402,1.5859,1.477251,0.2184572,2.541443,2.113444,0.2752164,5.685964,8.634603,8.29575,8.095039,6.578425,6.136902,5.899717,6.145741,7.125462,5.393306,8.091742,6.543253,6.000189,5.414757,6.051894,7.11258,7.522185,6.178416,7.458701,7.834778,6.090508,5.98371,8.427101,8.828207,6.272315,6.270991,5.895746,6.27819,7.636415,7.677011,7.255535,7.699752,6.881567,6.528377,5.420777,7.262776,7.62755,8.138616,5.446772,4.953948,5.244168,3.630998,6.610178,6.594817,6.507699,8.927546,7.520139,6.755705,7.572453,5.337873,13.64989,13.51384,13.41111,11.227,10.70319,12.90302,12.7069,12.33026,11.26334,12.50057,11.62962,14.42661,13.45915,12.09845,12.4286,11.66999,12.68588,12.96056,13.01814,12.24568,11.85748,10.80623,13.5157,13.95199,12.37743,12.67806,13.11336,10.35181,12.38234,12.63739,14.28101,13.00384,13.21553,11.51778,11.33081,12.158,11.59076,11.71251,15.2808,10.93942,11.789,11.50423,14.23471,11.90134,11.93195,13.21087,13.5213,12.936,13.23198,11.87251,8.923729,7.967622,9.873618,9.949371,10.09816,8.755341,8.367485,9.88749,9.936645,9.325526,9.022046,9.044532,10.29448,9.235127,8.50368,8.190405,9.415557,9.713773,9.65627,10.42901,11.44054,9.747174,9.871838,9.881052,8.310324,9.521068,9.02285,9.348607,8.855969,8.999144,10.38522,7.796159,9.130763,11.24729,8.260358,9.559644,10.20676,10.66821,9.359118,9.384363,9.353992,9.805684,10.38699,12.17511,9.358794,10.41518,8.960405,8.575525,10.29719,10.47476, + 0.6468061,0.4693864,0,1.926856,2.210854,0.09299721,2.137745,0.8706733,1.55295,0.9628953,1.048041,1.438888,1.844881,3.180735,2.312149,1.575249,2.102803,1.812883,2.646846,0.7635759,1.898901,1.658004,2.6565,2.447882,1.078943,2.22706,1.744104,2.935692,0.9287043,2.251821,1.534568,0.9009759,3.040329,0.5092227,1.83947,1.401635,2.466043,2.272495,2.271788,1.858736,0.8063235,1.695542,1.487726,1.911588,1.535353,1.64012,0.2834581,2.607166,2.580254,0.1971432,5.638373,8.811341,8.30546,8.193932,6.660824,6.213929,5.959165,6.120606,7.184427,5.502175,8.201831,6.591718,6.0232,5.60559,6.107758,7.250948,7.572734,6.1411,7.474024,7.832964,6.300218,6.065486,8.454931,8.86929,6.334044,6.34089,5.950171,6.34858,7.801012,7.816282,7.314271,7.721228,6.9706,6.666355,5.607408,7.265674,7.646649,8.108754,5.576097,4.986607,5.361932,3.891677,6.670982,6.652587,6.543313,9.067467,7.516031,6.835775,7.703642,5.340247,13.72808,13.54848,13.50925,11.31031,10.77383,12.9479,12.79133,12.40383,11.41152,12.57954,11.74304,14.43527,13.57244,12.16866,12.46986,11.68837,12.77076,13.05485,13.07278,12.33165,11.93741,10.83827,13.52047,14.04835,12.43634,12.68102,13.2029,10.40595,12.37847,12.74781,14.32734,13.07298,13.37382,11.58245,11.34391,12.24753,11.62797,11.71731,15.33817,10.92096,11.88422,11.6355,14.30447,11.91492,12.03221,13.22486,13.63404,12.97386,13.25636,11.95024,9.329242,8.375997,10.28776,10.32389,10.44439,9.114485,8.749182,10.2289,10.30071,9.73709,9.356971,9.402801,10.65163,9.568125,8.902492,8.568317,9.804071,10.0301,9.999641,10.80016,11.82934,10.16714,10.2858,10.23692,8.714055,9.890318,9.375154,9.735905,9.245107,9.367017,10.74799,8.138878,9.497183,11.62157,8.580519,9.978081,10.56612,11.06975,9.659108,9.720735,9.745586,10.17849,10.816,12.51004,9.735998,10.84251,9.363891,8.935022,10.66277,10.83199, + 1.59794,1.457648,1.926856,0,2.379451,1.939815,0.9220632,2.105865,0.4862611,1.366742,1.131903,0.5032602,1.673203,2.081047,2.405786,2.221818,1.602251,2.530584,4.511812,2.636585,2.056592,3.044691,1.870605,0.5294707,2.405109,2.752201,2.452814,3.583238,1.903921,0.9319575,1.352317,1.890084,2.306915,1.595365,3.12152,0.5849461,3.668417,0.6550819,1.758904,0.2340549,2.190422,2.58911,2.272713,0.2029666,2.44032,1.883761,1.662285,2.907211,0.7050159,1.732402,6.109981,8.27897,8.479065,8.004627,6.580298,6.170899,5.997531,6.488563,7.184541,5.357611,7.965496,6.652092,6.205383,5.105445,6.154933,6.918285,7.59716,6.555571,7.643304,8.062532,5.68767,6.008577,8.552483,8.905262,6.349203,6.322475,6.009222,6.327889,7.341972,7.465331,7.31184,7.859933,6.85309,6.352949,5.125654,7.489791,7.796648,8.443974,5.342339,5.176905,5.187214,3.192905,6.678683,6.673236,6.657112,8.688393,7.761918,6.759356,7.389717,5.631685,13.55473,13.5562,13.25451,11.13784,10.66018,12.9184,12.59964,12.26069,10.96523,12.41243,11.44012,14.54284,13.25383,12.04164,12.45936,11.77891,12.57737,12.81987,13.00205,12.13767,11.77237,10.88251,13.65034,13.79705,12.35352,12.82501,12.98647,10.365,12.55282,12.44797,14.28136,12.94234,12.86668,11.48427,11.45956,12.03956,11.64227,11.86276,15.24021,11.16874,11.65605,11.25852,14.16192,12.02275,11.78152,13.31952,13.31727,12.97295,13.30836,11.79421,7.738995,6.778467,8.649808,8.876742,9.129421,7.750873,7.280447,8.938202,8.90323,8.114565,8.105228,8.040461,9.284045,8.323086,7.348392,7.119887,8.293536,8.857458,8.701869,9.365746,10.3061,8.501089,8.648739,8.878543,7.137055,8.471459,8.041379,8.231729,7.735722,7.959222,9.353373,6.865911,8.095147,10.16764,7.407812,8.320416,9.188803,9.489299,8.565578,8.458357,8.220563,8.740495,9.102866,11.23293,8.280381,9.13753,7.783401,7.571628,9.255511,9.462721, + 1.61355,2.084649,2.210854,2.379451,0,2.128275,1.639922,1.420654,1.95335,1.435676,1.573391,2.282747,0.7064372,1.703551,0.1146144,3.642453,0.8744314,0.6648819,3.480107,2.270958,0.3558779,1.602319,1.142583,2.590269,1.428724,0.4960257,0.6653927,1.239216,1.287705,1.730367,1.060222,1.314078,1.240201,2.45629,1.495773,2.376887,1.724828,2.054931,0.8243909,2.148598,1.548113,0.8789991,0.8246995,2.545225,0.9103202,0.6121904,2.041708,0.5286538,2.523567,2.121801,3.752917,6.602262,6.252416,6.010889,4.494636,4.054525,3.824748,4.163366,5.048409,3.309874,6.009744,4.473069,3.953739,3.406718,3.978524,5.043435,5.448748,4.2168,5.412719,5.805919,4.114034,3.900366,6.3671,6.758287,4.195372,4.190662,3.823678,4.19768,5.590327,5.608704,5.178408,5.647045,4.797007,4.458697,3.405862,5.231206,5.577278,6.145777,3.371047,2.905675,3.16307,1.849297,4.533067,4.519201,4.446974,6.860073,5.495635,4.672228,5.499037,3.323462,11.56551,11.44372,11.32745,9.142418,8.620201,10.82789,10.62226,10.24649,9.202384,10.41619,9.54944,12.37423,11.37919,10.01527,10.35546,9.612335,10.60123,10.87638,10.93896,10.16103,9.77306,8.73969,11.46753,11.86812,10.29701,10.63249,11.02881,8.273934,10.34384,10.55642,12.20469,10.92073,11.16329,9.435961,9.277915,10.07343,9.520365,9.66651,13.20019,8.919988,9.704836,9.431975,12.15133,9.84731,9.848508,11.15515,11.44117,10.86439,11.16849,9.788286,7.735488,6.82302,8.740113,8.534005,8.530598,7.268076,7.019498,8.299074,8.461881,8.179296,7.412114,7.548787,8.779441,7.614484,7.271982,6.821536,8.095397,8.019791,8.079111,8.988873,10.09864,8.667261,8.736824,8.363347,7.120338,8.080067,7.49629,8.021295,7.54879,7.557021,8.898958,6.238503,7.678606,9.817596,6.594615,8.46906,8.704055,9.423379,7.606904,7.777409,8.055703,8.381921,9.384376,10.54261,7.966969,9.39523,7.755613,7.092695,8.827089,8.958527, + 0.5859224,0.4868151,0.09299721,1.939815,2.128275,0,2.109445,0.7785106,1.549783,0.9127046,1.0162,1.459303,1.779191,3.131673,2.230608,1.667869,2.044316,1.721864,2.607779,0.7184134,1.820356,1.570608,2.600141,2.456378,0.9864969,2.136941,1.653604,2.842937,0.8432271,2.225527,1.479706,0.8158746,2.978054,0.5835309,1.749935,1.429499,2.3768,2.260397,2.210591,1.860834,0.7133578,1.603019,1.397787,1.934144,1.443262,1.563403,0.2780235,2.519128,2.581662,0.2145216,5.545423,8.729969,8.213395,8.106079,6.572128,6.124987,5.869296,6.027886,7.094368,5.415499,8.11475,6.501223,5.931728,5.526483,6.017684,7.166221,7.482231,6.048223,7.38217,7.740622,6.223091,5.976855,8.363436,8.778279,6.244235,6.251519,5.86005,6.259235,7.718582,7.731538,7.224185,7.629558,6.882267,6.58171,5.527831,7.173477,7.554905,8.015911,5.491,4.895664,5.275971,3.822994,6.581078,6.562532,6.452267,8.982611,7.42365,6.746913,7.618241,5.248189,13.63863,13.45705,13.421,11.22125,10.68409,12.85688,12.70227,12.31418,11.32716,12.49017,11.6559,14.34302,13.4852,12.07884,12.37871,11.59644,12.68173,12.96637,12.98218,12.2427,11.84812,10.74682,13.42814,13.95996,12.34596,12.58866,13.11413,10.31542,12.28596,12.66041,14.23635,12.98307,13.29025,11.49238,11.25183,12.15879,11.53668,11.62501,15.24763,10.82822,11.79585,11.54972,14.21456,11.82285,11.94416,13.13277,13.54676,12.88256,13.16458,11.86083,9.291451,8.339397,10.253,10.27629,10.38957,9.063009,8.70388,10.17301,10.2503,9.701431,9.299758,9.351055,10.59942,9.510456,8.862483,8.521961,9.760628,9.968893,9.944223,10.75157,11.78573,10.13469,10.25097,10.18444,8.675748,9.841341,9.321944,9.6921,9.201945,9.317756,10.69719,8.083655,9.447516,11.57374,8.520332,9.945046,10.51447,11.03035,9.594826,9.663781,9.703106,10.13044,10.78737,12.45243,9.689235,10.81314,9.325388,8.883668,10.61271,10.77977, + 1.576601,1.720307,2.137745,0.9220632,1.639922,2.109445,0,1.919969,0.7586199,1.241797,1.093579,1.140755,0.9743947,1.213176,1.635764,2.938435,0.7754885,1.982288,4.429948,2.684185,1.381784,2.717276,0.9490417,0.9658891,2.168148,2.087471,1.917265,2.879053,1.682273,0.1251837,0.8418205,1.682523,1.385208,2.011396,2.730714,1.264154,3.181453,0.4169061,0.8938034,0.707397,2.045294,2.105822,1.817253,1.123711,1.995342,1.305535,1.856128,2.145029,0.8836633,1.949603,5.275392,7.371441,7.578882,7.082837,5.664309,5.258848,5.093717,5.628594,6.272313,4.441787,7.043434,5.747089,5.317687,4.187134,5.251123,5.996895,6.685635,5.703815,6.745683,7.170539,4.780427,5.096126,7.64456,7.991757,5.441289,5.411769,5.107542,5.416976,6.4266,6.544884,6.399066,6.958071,5.934529,5.430978,4.206495,6.599726,6.896236,7.565177,4.422173,4.301095,4.270271,2.277155,5.768742,5.764428,5.75778,7.770347,6.873436,5.843148,6.468265,4.767346,12.63282,12.63708,12.33416,10.21578,9.738672,11.9982,11.67782,11.33864,10.05403,11.4904,10.52074,13.62835,12.33603,11.1197,11.54001,10.86541,11.65556,11.89886,12.08075,11.21581,10.85031,9.966943,12.73796,12.87676,11.43214,11.91439,12.06509,9.445678,11.64499,11.52895,13.36032,12.02031,11.963,10.56281,10.54819,11.11786,10.72446,10.95327,14.31824,10.27023,10.7346,10.3427,13.23986,11.1102,10.86059,12.405,12.39941,12.05374,12.39139,10.87215,7.203474,6.247333,8.154433,8.245838,8.428981,7.070569,6.658732,8.225936,8.244184,7.605657,7.373035,7.360418,8.61005,7.588756,6.784765,6.485167,7.701273,8.095706,7.992184,8.728412,9.725503,8.030661,8.152597,8.198823,6.59028,7.82323,7.346895,7.635121,7.141523,7.303392,8.693808,6.138101,7.436503,9.543174,6.640747,7.842249,8.519653,8.948385,7.774681,7.731972,7.637964,8.103913,8.678477,10.51974,7.653201,8.704797,7.240357,6.890607,8.60263,8.790005, + 0.5448115,0.9746689,0.8706733,2.105865,1.420654,0.7785106,1.919969,0,1.630044,0.7463846,0.9759627,1.728196,1.260217,2.707115,1.530766,2.432434,1.578654,0.946852,2.510325,0.8840147,1.162507,0.9631003,2.126785,2.553328,0.3053144,1.366209,0.8819535,2.066941,0.2385051,2.045135,1.108651,0.2377133,2.438992,1.272457,1.087849,1.754392,1.701503,2.199592,1.70876,1.948342,0.1420172,0.8255961,0.6325443,2.174184,0.6647552,0.9413163,0.817881,1.761226,2.614395,0.8600611,4.77234,8.007904,7.434885,7.343746,5.805688,5.357401,5.097273,5.251205,6.321315,4.661301,7.356739,5.726478,5.153968,4.824706,5.244723,6.42303,6.707373,5.273378,6.603773,6.962328,5.534448,5.210955,7.585584,8.001647,5.472406,5.481751,5.086914,5.489592,6.990118,6.987886,6.451011,6.851395,6.117662,5.839486,4.822565,6.395008,6.776634,7.24044,4.74688,4.119468,4.526444,3.213966,5.808766,5.789565,5.675615,8.237663,6.645433,5.979567,6.870519,4.469679,12.86777,12.67928,12.65583,10.4523,9.912137,12.08014,11.93321,11.54249,10.58455,11.71974,10.89683,13.56459,12.72537,11.30645,11.60162,10.81798,11.9128,12.20011,12.20674,11.47419,11.0781,9.969033,12.64983,13.19408,11.57131,11.8104,12.3464,9.540336,11.50806,11.89977,13.45967,12.21028,12.55204,10.71895,10.47332,11.39132,10.75926,10.84664,14.47238,10.0516,11.03024,10.7984,13.4417,11.04434,11.18016,12.35426,12.78669,12.1051,12.38625,11.09025,8.905331,7.966323,9.888797,9.808456,9.864285,8.567119,8.258665,9.639627,9.760177,9.33143,8.75779,8.852283,10.09429,8.964456,8.459681,8.068815,9.327387,9.394412,9.415065,10.27489,11.34687,9.789663,9.886216,9.678049,8.287462,9.363496,8.811592,9.256127,8.772509,8.838918,10.20305,7.560601,8.965098,11.10165,7.956729,9.59572,10.01398,10.62671,8.997243,9.123093,9.277793,9.659327,10.4718,11.90235,9.229482,10.49133,8.933363,8.389233,10.12463,10.2743, + 1.140442,1.091699,1.55295,0.4862611,1.95335,1.549783,0.7586199,1.630044,0,0.8859863,0.6541434,0.3953548,1.255953,1.96952,1.992076,2.180022,1.25278,2.054723,4.071592,2.217598,1.615892,2.561171,1.632135,0.9336566,1.926174,2.29629,1.975944,3.130945,1.422262,0.8325065,0.900284,1.40953,2.078334,1.316766,2.63552,0.5171921,3.183186,0.7377639,1.428604,0.3231766,1.721313,2.106168,1.789389,0.6073642,1.955625,1.422999,1.273901,2.481593,1.034564,1.355868,5.70341,8.084341,8.132842,7.728371,6.273008,5.853058,5.662479,6.099875,6.864913,5.05316,7.699339,6.317605,5.845646,4.87998,5.819442,6.668061,7.275002,6.160104,7.294261,7.704674,5.497231,5.692214,8.220595,8.58652,6.021282,6.000906,5.670354,6.006809,7.124385,7.222607,6.993425,7.517458,6.555229,6.094357,4.895813,7.1303,7.451817,8.069658,5.056832,4.807003,4.887276,2.986869,6.354479,6.346484,6.312702,8.458083,7.399923,6.452432,7.138016,5.249153,13.29074,13.25443,13.00794,10.86872,10.37729,12.62307,12.33791,11.9878,10.75842,12.145,11.20073,14.22294,13.02177,11.76486,12.15932,11.45761,12.31597,12.5681,12.71534,11.87551,11.50314,10.56814,13.32489,13.55064,12.0681,12.49554,12.7309,10.06626,12.2172,12.21008,13.99163,12.6681,12.679,11.20019,11.13277,11.78025,11.33558,11.53121,14.96262,10.81708,11.40035,11.03587,13.89227,11.69863,11.53111,13.00027,13.0849,12.67193,12.99739,11.52309,7.894182,6.934852,8.829029,8.972834,9.175298,7.811229,7.381356,8.97474,8.979739,8.285565,8.125324,8.101202,9.34993,8.34149,7.486289,7.211903,8.414608,8.852361,8.740352,9.457745,10.43605,8.693871,8.82753,8.94,7.284803,8.555335,8.091299,8.349965,7.855017,8.037392,9.429758,6.889007,8.171423,10.26886,7.397646,8.508779,9.258185,9.643025,8.533223,8.483354,8.347687,8.832617,9.320575,11.26941,8.378557,9.350974,7.934203,7.63133,9.336599,9.529631, + 0.3398006,0.6767681,0.9628953,1.366742,1.435676,0.9127046,1.241797,0.7463846,0.8859863,0,0.2362551,1.034106,0.9179062,2.219121,1.516116,2.216322,1.14648,1.295711,3.228187,1.442432,1.08441,1.678643,1.695787,1.806994,1.040228,1.627653,1.214083,2.445521,0.5371903,1.364252,0.5742121,0.523653,2.090003,1.049471,1.764789,1.086476,2.337247,1.47342,1.321348,1.202392,0.84709,1.294158,0.9841733,1.450643,1.129717,0.8235031,0.7085974,1.920684,1.872834,0.8040566,5.119338,7.958465,7.679816,7.435795,5.927148,5.48868,5.260384,5.559219,6.484034,4.733587,7.428785,5.9082,5.381094,4.738194,5.41404,6.442572,6.884356,5.601185,6.840784,7.227055,5.414008,5.333674,7.800205,8.193593,5.63103,5.625783,5.259012,5.63274,6.961613,7.006526,6.614023,7.07767,6.227169,5.858808,4.744428,6.653161,7.007017,7.549893,4.780423,4.332732,4.581645,2.961625,5.968706,5.954875,5.879784,8.256465,6.914596,6.105162,6.903892,4.734788,12.99559,12.8792,12.74982,10.57163,10.05315,12.26353,12.05056,11.67824,10.59023,11.84636,10.96419,13.80586,12.79333,11.44789,11.79113,11.04524,12.02937,12.30067,12.37399,11.58892,11.20314,10.17458,12.89774,13.29115,11.73162,12.06172,12.45505,9.709346,11.77046,11.97255,13.64024,12.35337,12.54077,10.86985,10.70938,11.5,10.95584,11.09575,14.63462,10.33838,11.12915,10.83435,13.58357,11.27919,11.27039,12.58766,12.85562,12.29999,12.60292,11.21902,8.385297,7.435121,9.351374,9.363599,9.481767,8.151815,7.79146,9.266744,9.338449,8.798391,8.395715,8.440062,9.688804,8.607248,7.953691,7.609315,8.848984,9.073715,9.037252,9.839032,10.87395,9.237416,9.349229,9.274054,7.768993,8.9289,8.412261,8.780264,8.290485,8.405401,9.785564,7.176445,8.535313,10.66108,7.622694,9.04664,9.603411,10.12204,8.709086,8.759263,8.792074,9.217801,9.898448,11.54901,8.776543,9.922392,8.418297,7.972386,9.700691,9.869165, + 0.5066584,0.6690197,1.048041,1.131903,1.573391,1.0162,1.093579,0.9759627,0.6541434,0.2362551,0,0.8051554,0.9781684,2.156905,1.642824,2.133435,1.147722,1.504027,3.435564,1.615242,1.217546,1.914564,1.671599,1.581825,1.273402,1.812881,1.422532,2.640329,0.7727509,1.21083,0.590182,0.7583085,2.088939,1.017571,2.000648,0.8658679,2.569724,1.279299,1.33183,0.9738319,1.068722,1.517112,1.203376,1.21453,1.355563,0.9700797,0.770014,2.078003,1.658587,0.865552,5.294906,8.021005,7.825759,7.540887,6.043793,5.609291,5.390245,5.724646,6.610493,4.840824,7.528211,6.041081,5.527127,4.798699,5.545048,6.528963,7.013808,5.771192,6.986023,7.378706,5.460978,5.452468,7.938101,8.324937,5.758553,5.749415,5.391245,5.756114,7.032482,7.091331,6.740281,7.219731,6.339731,5.946765,4.80749,6.80411,7.15026,7.712218,4.8765,4.479046,4.684798,2.981542,6.095652,6.083291,6.018599,8.339021,7.067859,6.222465,6.99323,4.892261,13.10504,13.00868,12.84979,10.68044,10.1685,12.38887,12.15764,11.79077,10.66603,11.95621,11.05779,13.94598,12.88575,11.56219,11.91843,11.1832,12.13626,12.40281,12.49482,11.6956,11.31302,10.30743,13.04006,13.39168,11.85096,12.20539,12.55939,9.832742,11.91719,12.06693,13.76403,12.4675,12.60987,10.98723,10.84991,11.60503,11.08564,11.23943,14.75287,10.49234,11.23168,10.91889,13.69664,11.419,11.37033,12.72629,12.94828,12.42843,12.73707,11.32994,8.281788,7.328153,9.239728,9.288893,9.430379,8.089867,7.709983,9.219138,9.27259,8.689073,8.35319,8.378879,9.628677,8.566197,7.856448,7.531142,8.76175,9.045154,8.988111,9.767297,10.78705,9.11965,9.237765,9.214932,7.666872,8.858607,8.355955,8.694111,8.202466,8.336169,9.72084,7.127816,8.467339,10.58683,7.591569,8.930376,9.541471,10.02315,8.692459,8.715596,8.702,9.14453,9.771174,11.50633,8.699365,9.796998,8.31679,7.910117,9.633618,9.808987, + 1.191759,0.9728352,1.438888,0.5032602,2.282747,1.459303,1.140755,1.728196,0.3953548,1.034106,0.8051554,0,1.60342,2.353901,2.331911,1.813141,1.634324,2.301649,4.054372,2.168213,1.934382,2.688402,2.027451,1.032715,2.033312,2.584997,2.220596,3.419213,1.554203,1.20128,1.223136,1.535365,2.473639,1.092129,2.790788,0.1234357,3.370997,1.034773,1.813772,0.5243283,1.792845,2.322074,2.007647,0.4755862,2.160682,1.716391,1.184833,2.806702,1.200115,1.247781,6.034697,8.479663,8.498333,8.115669,6.653539,6.230722,6.034327,6.443831,7.241311,5.435378,8.088497,6.689102,6.206581,5.274509,6.190975,7.059852,7.650319,6.499276,7.658999,8.064981,5.89257,6.070468,8.591925,8.962381,6.395432,6.37725,6.040715,6.383308,7.51901,7.615155,7.370145,7.884916,6.938132,6.4852,5.290061,7.490195,7.81831,8.420861,5.44351,5.164093,5.270801,3.382217,6.729673,6.720798,6.680204,8.851661,7.758352,6.832957,7.529496,5.598233,13.67937,13.63441,13.3993,11.25672,10.76255,13.0049,12.72704,12.37491,11.15334,12.53313,11.59312,14.59703,13.41481,12.15121,12.53995,11.83173,12.70515,12.95877,13.09933,12.26461,11.89102,10.94481,13.69713,13.94198,12.45249,12.86644,13.12098,10.44768,12.58575,12.60256,14.37472,13.05485,13.07435,11.58503,11.505,12.16984,11.71445,11.90153,15.34844,11.17896,11.79055,11.42985,14.2798,12.07169,11.92207,13.37479,13.4779,13.05221,13.37464,11.91061,8.194197,7.233744,9.115825,9.3025,9.525564,8.155435,7.708166,9.328339,9.317871,8.576929,8.484288,8.445385,9.692532,8.701099,7.795251,7.542605,8.732399,9.219509,9.093172,9.789391,10.7501,8.9725,9.114578,9.284225,7.588522,8.890196,8.439649,8.669104,8.173432,8.374459,9.768092,7.246379,8.50934,10.59661,7.765735,8.790031,9.599346,9.94445,8.907789,8.840805,8.662475,9.163997,9.583518,11.62365,8.707063,9.616728,8.236601,7.975709,9.672925,9.871878, + 1.198613,1.593622,1.844881,1.673203,0.7064372,1.779191,0.9743947,1.260217,1.255953,0.9179062,0.9781684,1.60342,0,1.450779,0.736629,3.109972,0.3304018,1.023877,3.670333,2.136928,0.4084022,1.849053,0.8665784,1.898869,1.417187,1.117805,0.9663589,1.928571,1.043355,1.079918,0.396362,1.059071,1.203098,1.964258,1.823074,1.705435,2.223343,1.378666,0.449412,1.442164,1.402124,1.172867,0.9227544,1.840981,1.092526,0.3795231,1.615013,1.234032,1.850597,1.707628,4.448092,7.047826,6.897651,6.568134,5.079888,4.649628,4.441714,4.844975,5.655885,3.87091,6.552941,5.095369,4.60399,3.825948,4.597723,5.550914,6.062291,4.904264,6.057993,6.461995,4.497154,4.491221,6.996915,7.374531,4.806371,4.792743,4.445928,4.79915,6.056102,6.113183,5.785299,6.285919,5.372268,4.968911,3.833534,5.88715,6.218518,6.818415,3.900852,3.560748,3.712534,2.049149,5.142264,5.131692,5.081704,7.360876,6.155035,5.25897,6.015465,3.996349,12.13359,12.0539,11.87409,9.708967,9.201427,11.42989,11.18503,10.82138,9.688708,10.98514,10.0805,13.00445,11.90817,10.59404,10.9616,10.23972,11.16354,11.42794,11.53161,10.72283,10.34207,9.357643,12.1021,12.41615,10.88662,11.2699,11.58543,8.872691,10.98685,11.08975,12.80325,11.49908,11.63438,10.0215,9.910333,10.63147,10.13187,10.30448,13.78715,9.576252,10.25708,9.940722,12.72734,10.47806,10.39474,11.78308,11.97074,11.47268,11.78791,10.35961,7.646088,6.708843,8.631676,8.554821,8.63113,7.320973,7.000519,8.410574,8.512641,8.073741,7.533212,7.607307,8.852271,7.742403,7.199588,6.811724,8.068224,8.19253,8.183685,9.02359,10.08864,8.535833,8.629019,8.436361,7.028204,8.112171,7.571122,7.997203,7.512948,7.587637,8.957026,6.325143,7.714872,9.84942,6.746076,8.341173,8.770151,9.366504,7.815679,7.897927,8.018044,8.406406,9.224451,10.68377,7.973963,9.242326,7.673695,7.142489,8.876584,9.032487, + 2.550266,2.824676,3.180735,2.081047,1.703551,3.131673,1.213176,2.707115,1.96952,2.219121,2.156905,2.353901,1.450779,0,1.622217,4.145546,1.128509,2.319392,5.095837,3.574269,1.688244,3.235893,0.5950025,1.904252,2.865129,2.189027,2.290101,2.755845,2.482733,1.162151,1.657461,2.495449,0.5671959,3.155406,3.166529,2.47728,3.425751,1.437441,1.011803,1.894771,2.84847,2.514791,2.329905,2.282366,2.481037,1.808939,2.915496,2.005354,1.707167,3.012019,4.653758,6.209645,6.685319,6.034004,4.696599,4.32562,4.212899,4.916835,5.325486,3.494111,5.97696,4.849075,4.508806,3.079315,4.367414,4.911019,5.739467,5.01745,5.871671,6.316489,3.621431,4.162678,6.711912,7.023862,4.53138,4.485165,4.237799,4.488956,5.292077,5.443862,5.447408,6.06202,4.940822,4.364458,3.1055,5.760111,6.007726,6.758122,3.427874,3.570019,3.316007,1.186418,4.842071,4.844667,4.888516,6.647261,6.03699,4.871695,5.381518,4.063524,11.54513,11.61235,11.2229,9.140994,8.688358,10.96319,10.58848,10.26701,8.900406,10.40995,9.403024,12.63715,11.20696,10.05486,10.51503,9.886302,10.56578,10.79513,11.03025,10.12801,9.774064,8.976836,11.76117,11.76461,10.38103,10.94939,10.96631,8.425975,10.69536,10.40782,12.3123,10.94934,10.79117,9.511837,9.582809,10.02609,9.715195,9.997049,13.24859,9.368382,9.638418,9.205309,12.15962,10.13629,9.756779,11.41587,11.27064,11.02914,11.38521,9.798825,6.199072,5.259227,7.181804,7.144826,7.273542,5.935001,5.575932,7.06302,7.120135,6.62432,6.199484,6.223688,7.47315,6.413327,5.756501,5.391972,6.637617,6.904059,6.831632,7.619916,8.661369,7.085054,7.1792,7.059019,5.581276,6.709797,6.199293,6.567923,6.080288,6.186362,7.567657,4.97172,6.316449,8.442161,5.448892,6.890421,7.386722,7.924815,6.570794,6.561148,6.583758,6.998807,7.775429,9.351815,6.558529,7.7926,6.228001,5.755391,7.482071,7.65349, + 1.707473,2.172863,2.312149,2.405786,0.1146144,2.230608,1.635764,1.530766,1.992076,1.516116,1.642824,2.331911,0.736629,1.622217,0,3.728569,0.8619047,0.7750177,3.587401,2.384222,0.4318804,1.710605,1.075106,2.594237,1.543019,0.5668627,0.7784155,1.254357,1.392315,1.720113,1.109475,1.418255,1.142925,2.545687,1.598773,2.429443,1.803664,2.052443,0.7882965,2.173316,1.659407,0.9898561,0.93885,2.57664,1.024571,0.695806,2.136911,0.5098711,2.517676,2.218554,3.711513,6.49938,6.185509,5.922536,4.411039,3.972825,3.748323,4.112066,4.970189,3.220549,5.919002,4.398491,3.887868,3.299914,3.902809,4.947003,5.372222,4.169282,5.345617,5.742857,4.005164,3.817599,6.295333,6.682841,4.117612,4.110686,3.748713,4.117561,5.489152,5.512129,5.100097,5.577879,4.711519,4.362304,3.299742,5.167954,5.508864,6.089967,3.27657,2.840999,3.071527,1.73509,4.455036,4.442005,4.376064,6.763439,5.433821,4.589047,5.404041,3.267082,11.48014,11.36739,11.23829,9.056475,8.537035,10.74953,10.53582,10.16229,9.104434,10.33087,9.457588,12.30333,11.28725,9.931805,10.27804,9.540389,10.51471,10.788,10.85851,10.07435,9.687668,8.665049,11.39785,11.77924,10.21583,10.56362,10.94132,8.194501,10.27674,10.46504,12.12567,10.83728,11.06384,9.353808,9.207396,9.986073,9.444166,9.597729,13.11871,8.857444,9.616422,9.336912,12.06754,9.776358,9.759103,11.08351,11.34932,10.78754,11.09451,9.703337,7.628384,6.717725,8.633919,8.421728,8.416424,7.154996,6.908989,8.184765,8.348727,8.07305,7.297735,7.435526,8.665743,7.50003,7.164037,6.710683,7.98503,7.905191,7.964902,8.876115,9.987295,8.562565,8.630591,8.249675,7.013569,7.967484,7.382653,7.910807,7.438922,7.444553,8.785583,6.124758,7.565947,9.704853,6.480037,8.364175,8.590508,9.31419,7.49255,7.66302,7.945818,8.269543,9.281521,10.42802,7.855246,9.291863,7.648074,6.979723,8.713936,8.844794, + 2.043505,1.558892,1.575249,2.221818,3.642453,1.667869,2.938435,2.432434,2.180022,2.216322,2.133435,1.813141,3.109972,4.145546,3.728569,0,3.266443,3.351765,3.713601,2.127859,3.296924,3.208765,3.751143,2.684093,2.654151,3.75006,3.27739,4.49721,2.437739,3.009509,2.723301,2.408815,4.1881,1.19229,3.401874,1.693377,4.024497,2.839167,3.45289,2.325559,2.380331,3.255914,3.018391,2.067442,3.090394,3.032866,1.636595,4.098213,2.899927,1.577341,7.20409,10.15392,9.844663,9.650889,8.136902,7.695712,7.45812,7.677904,8.684032,6.948691,9.645001,8.100697,7.552162,6.931701,7.610031,8.656704,9.080103,7.703512,9.009136,9.379136,7.588782,7.542333,9.981327,10.38512,7.830935,7.829876,7.4537,7.837079,9.165765,9.220074,8.814107,9.252108,8.439356,8.073427,6.940798,8.808755,9.179201,9.6692,6.996626,6.507675,6.79767,5.094141,8.168792,8.153228,8.062983,10.46906,9.063388,8.314304,9.119073,6.882342,15.20794,15.07028,14.96577,12.78468,12.26196,14.4609,14.26427,13.88879,12.79866,14.05863,13.18039,15.97643,15.00942,13.65718,13.98599,13.22245,14.24318,14.51617,14.57683,13.80287,13.41548,12.36187,15.06404,15.50699,13.93627,14.2256,14.66986,11.91035,13.9271,14.18883,15.83913,14.56259,14.74331,13.07667,12.88163,13.71463,13.14745,13.26056,16.83964,12.47708,13.34461,13.04808,15.79339,13.45241,13.4864,14.76227,15.07175,14.49293,14.78624,13.43074,9.952294,8.992281,10.85023,11.09806,11.33665,9.963632,9.501947,11.14063,11.12132,10.32036,10.29743,10.25349,11.49926,10.51424,9.567128,9.340426,10.51469,11.03086,10.90524,11.58671,12.52544,10.69257,10.84943,11.09214,9.353371,10.69102,10.25003,10.45315,9.957134,10.17743,11.57155,9.059454,10.31295,12.38938,9.576534,10.51537,11.40507,11.70183,10.71309,10.65385,10.44097,10.96138,11.27138,13.43599,10.50181,11.31019,9.99823,9.784063,11.4747,11.67831, + 1.458416,1.803294,2.102803,1.602251,0.8744314,2.044316,0.7754885,1.578654,1.25278,1.14648,1.147722,1.634324,0.3304018,1.128509,0.8619047,3.266443,0,1.319832,4.00064,2.447673,0.6715655,2.173767,0.5589678,1.738809,1.746065,1.344811,1.26982,2.111655,1.354827,0.8583507,0.5731733,1.368171,0.9452475,2.163237,2.139113,1.747955,2.509154,1.192381,0.186662,1.368515,1.719965,1.484194,1.248373,1.788467,1.414868,0.7069897,1.855067,1.370233,1.655917,1.95038,4.518181,6.893419,6.886967,6.482528,5.020559,4.600311,4.412089,4.887608,5.612327,3.801422,6.457662,5.067277,4.606354,3.673807,4.56922,5.436294,6.022674,4.956826,6.049455,6.464695,4.322513,4.439435,6.970038,7.333996,4.769512,4.748372,4.421051,4.754238,5.915483,5.994603,5.740774,6.269949,5.303993,4.858709,3.685561,5.891209,6.20521,6.842012,3.810174,3.575061,3.636503,1.834045,5.102255,5.094601,5.065599,7.236534,6.162534,5.199986,5.904556,4.029812,12.04731,12.00192,11.77268,9.624032,9.128305,11.37126,11.09568,10.74143,9.551735,10.90054,9.970461,12.97079,11.7949,10.5173,10.907,10.20551,11.07388,11.33035,11.46503,10.63325,10.25819,9.31544,12.0735,12.31525,10.81816,11.24489,11.49127,8.814229,10.96809,10.98009,12.7406,11.42114,11.48665,9.950718,9.881482,10.53927,10.08286,10.28096,13.71429,9.574157,10.16118,9.81674,12.64659,10.44693,10.29451,11.748,11.8578,11.4195,11.74463,10.27746,7.327326,6.387672,8.310151,8.253188,8.346886,7.027189,6.69295,8.129275,8.217144,7.752788,7.255462,7.314414,8.561316,7.466148,6.883406,6.505999,7.758319,7.928095,7.900913,8.72435,9.780413,8.211946,8.307566,8.145832,6.709494,7.813159,7.281959,7.687866,7.202054,7.288843,8.662718,6.04069,7.417103,9.549046,6.477872,8.017704,8.47776,9.051246,7.562735,7.619534,7.70647,8.105612,8.89792,10.40812,7.670175,8.916337,7.35589,6.848256,8.580509,8.741631, + 1.330188,1.82241,1.812883,2.530584,0.6648819,1.721864,1.982288,0.946852,2.054723,1.295711,1.504027,2.301649,1.023877,2.319392,0.7750177,3.351765,1.319832,0,2.816788,1.701362,0.6525963,0.9384383,1.733311,2.852981,0.8483471,0.4230698,0.08164664,1.162296,0.9155652,2.094558,1.198293,0.9443928,1.893762,2.166644,0.8474176,2.369438,1.200549,2.368447,1.34906,2.319038,1.042772,0.2153904,0.3344852,2.66092,0.2985142,0.6790677,1.715538,0.8366453,2.836806,1.775973,3.863617,7.100686,6.496801,6.400975,4.860853,4.41207,4.150487,4.327659,5.374466,3.726475,6.416907,4.77993,4.210906,3.950012,4.297871,5.496533,5.760883,4.357335,5.663592,6.02824,4.672192,4.266558,6.64262,7.056432,4.525638,4.535495,4.140064,4.543378,6.077671,6.060393,5.504167,5.909648,5.173785,4.914672,3.943463,5.458846,5.835475,6.320033,3.822054,3.173801,3.596426,2.502175,4.861938,4.842713,4.730437,7.3081,5.712146,5.034247,5.939392,3.532349,11.92106,11.73594,11.71101,9.50607,8.965309,11.13504,10.98692,10.59568,9.655938,10.77311,9.955554,12.62815,11.78342,10.3596,10.65699,9.878177,10.96655,11.25482,11.26057,10.52807,10.13156,9.025794,11.71459,12.24892,10.62478,10.87569,11.40053,8.59397,10.5759,10.95741,12.5145,11.26343,11.62659,9.772147,9.534999,10.44557,9.815187,9.911122,13.52611,9.12562,10.08529,9.862636,12.49485,10.10597,10.23598,11.41598,11.84461,11.1611,11.44513,10.14359,8.399342,7.484918,9.403028,9.19565,9.181097,7.926917,7.683961,8.947596,9.120319,8.842285,8.059509,8.206736,9.434585,8.260183,7.936453,7.485701,8.75996,8.653661,8.729196,9.648976,10.76219,9.328206,9.399782,9.018712,7.783904,8.740806,8.151973,8.685775,8.213586,8.218138,9.556213,6.89353,8.339099,10.47773,7.236203,9.130292,9.360264,10.08826,8.230236,8.42454,8.720494,9.043284,10.04221,11.18261,8.629892,10.05398,8.419812,7.752019,9.485515,9.613391, + 2.933251,3.090911,2.646846,4.511812,3.480107,2.607779,4.429948,2.510325,4.071592,3.228187,3.435564,4.054372,3.670333,5.095837,3.587401,3.713601,4.00064,2.816788,0,1.889937,3.411327,1.878364,4.500878,5.004641,2.273049,3.092269,2.828643,3.143344,2.74769,4.555131,3.606628,2.747998,4.70754,3.118184,1.998871,4.03418,2.094859,4.700703,4.087952,4.394567,2.389027,2.606106,2.766001,4.529596,2.617531,3.296035,2.873882,3.471491,5.093955,2.822291,5.165851,9.334302,7.914015,8.311052,6.799382,6.366247,6.042839,5.715213,7.148279,5.907613,8.381361,6.548842,5.898575,6.43288,6.155162,7.650855,7.459912,5.664432,7.170746,7.407197,7.164209,6.259476,8.156653,8.622521,6.389914,6.441087,6.007328,6.450703,8.310249,8.182986,7.266628,7.434492,7.119046,7.109882,6.412386,6.908686,7.351866,7.506241,6.081518,5.057097,5.832279,5.281001,6.689152,6.65563,6.433644,9.369158,7.100121,6.945977,8.032438,5.190285,13.52528,13.10278,13.42542,11.20121,10.61098,12.57419,12.64622,12.20698,11.67106,12.40871,11.79258,13.82518,13.57421,11.95919,12.08808,11.19989,12.62876,12.95954,12.75127,12.20744,11.78982,10.45466,12.90785,13.94251,12.15534,12.07832,13.07691,10.1633,11.74542,12.75264,13.93104,12.83378,13.64095,11.35878,10.83647,12.14587,11.24742,11.15162,14.98524,10.25061,11.82542,11.79079,14.04146,11.3927,11.99798,12.67057,13.63128,12.5599,12.75966,11.78975,11.21558,10.3015,12.21981,11.98083,11.91545,10.69994,10.48825,11.67447,11.88954,11.65906,10.78484,10.97522,12.18828,10.97817,10.75136,10.28762,11.56477,11.32492,11.46307,12.42564,13.55792,12.1441,12.21656,11.77418,10.60043,11.52173,10.91064,11.48978,11.02156,11.00161,12.31926,9.65277,11.11931,13.2537,9.943399,11.94642,12.11885,12.89921,10.86545,11.14753,11.52825,11.8271,12.8544,13.86812,11.42281,12.86742,11.23547,10.52756,12.25416,12.36551, + 1.111916,1.201136,0.7635759,2.636585,2.270958,0.7184134,2.684185,0.8840147,2.217598,1.442432,1.615242,2.168213,2.136928,3.574269,2.384222,2.127859,2.447673,1.701362,1.889937,0,2.039987,1.161105,3.001739,3.142624,0.8544427,2.117288,1.657992,2.662839,1.093885,2.806659,1.936562,1.079585,3.322709,1.258013,1.377539,2.144705,1.964124,2.893918,2.586338,2.537222,0.7433388,1.517087,1.448702,2.643799,1.404245,1.825226,0.9846989,2.537362,3.251283,0.9327742,5.293917,8.79989,8.024272,8.055121,6.508061,6.057434,5.777449,5.80441,6.988851,5.407575,8.081394,6.385074,5.782728,5.648327,5.918416,7.185144,7.360513,5.806188,7.207306,7.537221,6.367185,5.918534,8.200851,8.633491,6.151436,6.171367,5.760508,6.179761,7.775347,7.747369,7.117204,7.462189,6.825558,6.605522,5.642827,6.981428,7.38447,7.768827,5.51441,4.777029,5.284311,4.091139,6.483238,6.460168,6.316793,8.991461,7.219077,6.677456,7.621997,5.076863,13.53329,13.28559,13.34723,11.13075,10.57592,12.70239,12.60896,12.20513,11.33905,12.38897,11.61116,14.13082,13.43509,11.96531,12.22003,11.40556,12.58918,12.88771,12.84224,12.15309,11.75031,10.57936,13.21213,13.88212,12.21427,12.37198,13.02769,10.18331,12.05995,12.60791,14.08087,12.86537,13.31269,11.37213,11.05413,12.07496,11.37436,11.41375,15.10693,10.58512,11.72203,11.53369,14.09491,11.62409,11.87778,12.93113,13.49563,12.71738,12.97839,11.75957,9.772626,8.82968,10.75082,10.69035,10.74802,9.450784,9.137409,10.52299,10.64369,10.19477,9.640676,9.736076,10.97828,9.846964,9.330656,8.948605,10.20462,10.27291,10.29867,11.15762,12.22549,10.64602,10.74839,10.56204,9.154951,10.24619,9.695602,10.13378,9.648902,9.72161,11.08677,8.444542,9.848071,11.98411,8.837468,10.45328,10.89788,11.49874,9.870683,10.00602,10.15364,10.54151,11.31887,12.78397,10.11041,11.34055,9.802103,9.272818,11.00807,11.15829, + 1.282129,1.742156,1.898901,2.056592,0.3558779,1.820356,1.381784,1.162507,1.615892,1.08441,1.217546,1.934382,0.4084022,1.688244,0.4318804,3.296924,0.6715655,0.6525963,3.411327,2.039987,0,1.547834,1.095226,2.304765,1.233886,0.7102357,0.6100907,1.529289,0.9951712,1.485008,0.7164706,1.019059,1.316547,2.11545,1.488638,2.026019,1.837637,1.787066,0.6984573,1.829182,1.299322,0.8320461,0.652621,2.214849,0.793934,0.2651541,1.71246,0.8724647,2.258999,1.796269,4.100509,6.915336,6.608221,6.354013,4.842834,4.404296,4.177831,4.51632,5.400581,3.65189,6.349645,4.827018,4.309584,3.706697,4.331955,5.373533,5.801853,4.567938,5.768501,6.161735,4.403176,4.249271,6.722065,7.111937,4.547772,4.541691,4.17743,4.548612,5.908823,5.938419,5.530531,6.00257,5.143395,4.788986,3.708718,5.587039,5.932916,6.500192,3.705237,3.261547,3.50205,2.051854,4.885329,4.871925,4.802108,7.189518,5.851346,5.020797,5.831905,3.678294,11.91201,11.79701,11.66945,9.488313,8.968816,11.18007,10.9676,10.59416,9.528717,10.76274,9.887539,12.72947,11.71711,10.36362,10.70818,9.967293,10.94648,11.2194,11.28976,10.50611,10.11954,9.093714,11.82302,12.21049,10.64727,10.98811,11.37293,8.625416,10.69965,10.89524,12.55647,11.2691,11.4858,9.785444,9.633225,10.41772,9.873704,10.02214,13.55023,9.275737,10.04783,9.764439,12.49939,10.20253,10.1902,11.5102,11.77924,11.21742,11.52279,10.13522,7.830667,6.90506,8.82695,8.681706,8.713776,7.429011,7.147294,8.48681,8.623044,8.267057,7.603138,7.712546,8.95068,7.808642,7.374839,6.953336,8.220548,8.233218,8.263656,9.143245,10.23331,8.74272,8.823967,8.534325,7.213499,8.232488,7.667236,8.147815,7.669317,7.708241,9.063739,6.413039,7.832512,9.971239,6.797613,8.546106,8.872253,9.535604,7.834736,7.968554,8.175895,8.531161,9.446138,10.74451,8.107834,9.460528,7.854426,7.252032,8.987984,9.130402, + 1.507499,1.90255,1.658004,3.044691,1.602319,1.570608,2.717276,0.9631003,2.561171,1.678643,1.914564,2.688402,1.849053,3.235893,1.710605,3.208765,2.173767,0.9384383,1.878364,1.161105,1.547834,0,2.642994,3.462575,0.6585289,1.243056,0.9522211,1.561969,1.141943,2.839576,1.876142,1.157637,2.83032,2.142242,0.2210882,2.717258,0.8169083,3.053561,2.239159,2.870559,0.9255299,0.7284276,0.9263082,3.126243,0.759953,1.469619,1.713916,1.650426,3.497115,1.726271,4.136959,7.805687,6.877609,6.97257,5.424987,4.975193,4.681977,4.652307,5.879003,4.375989,7.010211,5.272331,4.656827,4.737975,4.817573,6.157953,6.241168,4.650146,6.066521,6.387314,5.469579,4.843545,7.062465,7.501019,5.052894,5.08032,4.660569,5.089078,6.775948,6.713923,6.006076,6.323496,5.745314,5.587165,4.725099,5.835562,6.244852,6.610302,4.508252,3.674094,4.268262,3.421803,5.379917,5.354445,5.194768,7.946353,6.069306,5.589936,6.579903,3.944741,12.41116,12.13968,12.24034,10.0183,9.455874,11.56199,11.49323,11.08265,10.28858,11.2698,10.52282,12.97528,12.34088,10.84111,11.07859,10.25549,11.47384,11.77886,11.70677,11.03968,10.63348,9.436412,12.05616,12.7726,11.08239,11.21614,11.91481,9.053489,10.90272,11.51346,12.93934,11.73853,12.26565,10.24573,9.902631,10.9645,10.23237,10.25923,13.96981,9.426068,10.61721,10.4635,12.9663,10.47207,10.77669,11.77795,12.40077,11.5736,11.82871,10.64111,9.337638,8.423209,10.34146,10.12226,10.08808,8.848469,8.617735,9.851551,10.04077,9.780723,8.9623,9.126603,10.34914,9.16022,8.874283,8.418527,9.694033,9.535697,9.635756,10.57242,11.69301,10.26617,10.33822,9.933801,8.722286,9.66568,9.06796,9.619534,9.148826,9.143877,10.47441,7.809112,9.263593,11.40108,8.131072,10.06837,10.27668,11.02469,9.097644,9.326658,9.655683,9.969342,10.97859,12.07198,9.559382,10.99089,9.357914,8.674504,10.40584,10.52741, + 2.014345,2.337644,2.6565,1.870605,1.142583,2.600141,0.9490417,2.126785,1.632135,1.695787,1.671599,2.027451,0.8665784,0.5950025,1.075106,3.751143,0.5589678,1.733311,4.500878,3.001739,1.095226,2.642994,0,1.850472,2.274102,1.637136,1.700545,2.281184,1.907877,0.961555,1.122092,1.922426,0.4462118,2.688265,2.578847,2.148634,2.866004,1.307401,0.4200716,1.651136,2.268671,1.924676,1.734916,2.07153,1.886826,1.216071,2.403248,1.514645,1.703872,2.499202,4.429812,6.452213,6.648295,6.134023,4.718695,4.317266,4.161497,4.748772,5.330061,3.496763,6.095656,4.812764,4.404461,3.251111,4.318698,5.052145,5.743913,4.833928,5.818539,6.249164,3.86581,4.154223,6.706009,7.047853,4.504026,4.47151,4.177816,4.476492,5.494566,5.602485,5.456236,6.026141,4.986759,4.484111,3.268407,5.681231,5.965911,6.658038,3.473487,3.407362,3.324216,1.355596,4.829059,4.825947,4.829851,6.832643,5.956355,4.897294,5.523252,3.886224,11.68594,11.68872,11.39128,9.267949,8.789684,11.04936,10.73129,10.39043,9.127274,10.5429,9.579945,12.6831,11.39792,10.1711,10.59155,9.921128,10.70909,10.95454,11.13172,10.26917,9.902509,9.02108,11.79445,11.93395,10.48312,10.97245,11.11987,8.497268,10.70554,10.58872,12.41128,11.07199,11.04693,9.613808,9.605769,10.17176,9.776934,10.01245,13.36969,9.34001,9.789244,9.408328,12.29215,10.1667,9.916549,11.4598,11.46119,11.10534,11.44437,9.924112,6.780137,5.844381,7.767353,7.694732,7.789608,6.4683,6.136286,7.572897,7.658179,7.208999,6.700475,6.755589,8.002671,6.911732,6.333046,5.948587,7.202887,7.379437,7.344092,8.165555,9.224135,7.674196,7.764636,7.587255,6.162258,7.25433,6.723632,7.132112,6.647213,6.729988,8.103783,5.483578,6.858179,8.990402,5.92757,7.478972,7.918959,8.499928,7.021477,7.064243,7.152094,7.547009,8.368026,9.853602,7.112197,8.38453,6.807429,6.289342,8.021542,8.182996, + 2.074064,1.978605,2.447882,0.5294707,2.590269,2.456378,0.9658891,2.553328,0.9336566,1.806994,1.581825,1.032715,1.898869,1.904252,2.594237,2.684093,1.738809,2.852981,5.004641,3.142624,2.304765,3.462575,1.850472,0,2.843371,3.014888,2.780091,3.825355,2.336317,0.9061814,1.655245,2.326272,2.248645,2.124763,3.517636,1.109826,4.029862,0.5541797,1.858732,0.6104827,2.650462,2.941801,2.631872,0.625405,2.806732,2.179201,2.178355,3.104107,0.2312316,2.252115,6.237845,8.101836,8.496849,7.926517,6.550115,6.157783,6.010123,6.582717,7.168452,5.331991,7.874616,6.659992,6.253838,4.982304,6.167162,6.812204,7.58285,6.661179,7.668356,8.099629,5.519239,5.994449,8.548706,8.88148,6.349297,6.313675,6.027323,6.318367,7.194782,7.347464,7.293458,7.874231,6.808618,6.260433,5.007511,7.531601,7.814724,8.50624,5.291613,5.248519,5.156998,3.076927,6.671609,6.669832,6.679658,8.550985,7.806611,6.727695,7.283177,5.720435,13.44844,13.49954,13.127,11.04196,10.5831,12.85388,12.49187,12.16764,10.79472,12.31217,11.30682,14.51032,13.10886,11.95397,12.4019,11.75224,12.46922,12.69937,12.92589,12.03118,11.67546,10.84767,13.62688,13.66864,12.27665,12.8085,12.87042,10.30968,12.54576,12.31114,14.20755,12.84998,12.6716,11.40712,11.44133,11.92966,11.59529,11.85078,15.14935,11.18829,11.54231,11.10568,14.06205,11.9997,11.66101,13.28757,13.17258,12.91607,13.26473,11.69968,7.269697,6.310154,8.166728,8.441415,8.728458,7.342229,6.844963,8.544507,8.480948,7.636263,7.725919,7.630879,8.868497,7.944568,6.889654,6.69071,7.843312,8.496445,8.307184,8.932378,9.848103,8.011578,8.165875,8.466795,6.672966,8.044913,7.639644,7.78335,7.287543,7.537562,8.930466,6.48791,7.674513,9.727315,7.054884,7.833187,8.77097,9.018687,8.228016,8.074417,7.766775,8.307986,8.601891,10.83582,7.844676,8.638304,7.316485,7.163895,8.82956,9.04618, + 0.8490186,1.257686,1.078943,2.405109,1.428724,0.9864969,2.168148,0.3053144,1.926174,1.040228,1.273402,2.033312,1.417187,2.865129,1.543019,2.654151,1.746065,0.8483471,2.273049,0.8544427,1.233886,0.6585289,2.274102,2.843371,0,1.267604,0.8035495,1.882654,0.5072258,2.293042,1.335594,0.5173697,2.546421,1.52775,0.7942362,2.059588,1.416302,2.469747,1.854314,2.241904,0.2825456,0.674414,0.6043562,2.477432,0.550337,1.058947,1.082334,1.684983,2.895611,1.109016,4.571706,7.948948,7.263462,7.230525,5.686251,5.236196,4.964984,5.062959,6.18393,4.567539,7.251279,5.584032,4.996662,4.793928,5.109256,6.341277,6.563298,5.077733,6.437366,6.784708,5.51329,5.09386,7.425068,7.84872,5.339992,5.354966,4.951182,5.363114,6.925603,6.904552,6.313076,6.688315,6.001618,5.760225,4.788384,6.221332,6.612221,7.045943,4.668033,3.973895,4.440492,3.267807,5.674375,5.653179,5.524774,8.150933,6.466986,5.857798,6.781719,4.301525,12.73254,12.51746,12.53359,10.32278,9.775133,11.92489,11.80278,11.40551,10.49887,11.58602,10.78667,13.3872,12.61304,11.16758,11.44456,10.64789,11.78268,12.07579,12.05735,11.34522,10.94566,9.807874,12.47069,13.07021,11.42509,11.6307,12.21887,9.393335,11.32467,11.78638,13.30435,12.06989,12.47079,10.57719,10.30041,11.26474,10.60047,10.66863,14.32314,9.860967,10.9078,10.70056,13.30074,10.87127,11.06085,12.18055,12.67394,11.9456,12.21856,10.95638,9.049149,8.11698,10.03993,9.915451,9.942743,8.662485,8.378439,9.714094,9.856576,9.481037,8.828918,8.945746,10.18283,9.03305,8.597401,8.185363,9.450726,9.446176,9.492087,10.37712,11.4653,9.948275,10.03713,9.766479,8.431442,9.466374,8.899293,9.378367,8.898367,8.942122,10.29692,7.644085,9.066384,11.20512,8.01716,9.752958,10.10493,10.76106,9.035559,9.194351,9.404659,9.76498,10.64046,11.96527,9.341039,10.65772,9.07474,8.485628,10.22156,10.36244, + 1.712545,2.20522,2.22706,2.752201,0.4960257,2.136941,2.087471,1.366209,2.29629,1.627653,1.812881,2.584997,1.117805,2.189027,0.5668627,3.75006,1.344811,0.4230698,3.092269,2.117288,0.7102357,1.243056,1.637136,3.014888,1.267604,0,0.4842866,0.8354065,1.313955,2.186694,1.400347,1.342855,1.698973,2.559773,1.094069,2.665087,1.23726,2.495792,1.31476,2.528464,1.465403,0.6023909,0.739386,2.901731,0.7203735,0.8736702,2.114377,0.4240473,2.96755,2.179858,3.493131,6.682629,6.094606,5.978718,4.439579,3.991197,3.732447,3.942288,4.957428,3.303493,5.994027,4.364957,3.803427,3.544972,3.880746,5.074443,5.345961,3.978922,5.259285,5.630586,4.270763,3.844983,6.234294,6.644404,4.107449,4.115803,3.723129,4.12361,5.658499,5.638096,5.087252,5.503222,4.751948,4.492956,3.536716,5.059339,5.429851,5.93502,3.400575,2.762094,3.174022,2.188786,4.444188,4.425592,4.319021,6.885464,5.315526,4.613366,5.516634,3.133465,11.50238,11.32639,11.28977,9.086256,8.547349,10.72283,10.56721,10.17754,9.233348,10.35415,9.532949,12.22637,11.36098,9.941995,10.24561,9.473198,10.54677,10.83393,10.84614,10.10808,9.712348,8.616652,11.31411,11.82793,10.20936,10.47585,10.98022,8.179176,10.17854,10.53508,12.1021,10.84616,11.20436,9.355443,9.131713,10.02512,9.404741,9.510668,13.11138,8.734198,9.664136,9.439567,12.07764,9.702546,9.814351,11.01246,11.4222,10.75065,11.03842,9.724714,8.141243,7.24052,9.151306,8.889607,8.845474,7.611657,7.397725,8.608631,8.802937,8.590411,7.719328,7.8886,9.108382,7.917165,7.672086,7.196346,8.47423,8.295092,8.393117,9.33664,10.46565,9.087256,9.147778,8.69329,7.528677,8.43138,7.82795,8.398943,7.932831,7.910586,9.235219,6.569188,8.029053,10.16507,6.888189,8.88808,9.036677,9.812419,7.861595,8.083645,8.439234,8.736133,9.813574,10.83,8.330576,9.821933,8.158345,7.43844,9.167869,9.286435, + 1.251893,1.744525,1.744104,2.452814,0.6653927,1.653604,1.917265,0.8819535,1.975944,1.214083,1.422532,2.220596,0.9663589,2.290101,0.7784155,3.27739,1.26982,0.08164664,2.828643,1.657992,0.6100907,0.9522211,1.700545,2.780091,0.8035495,0.4842866,0,1.242062,0.8399866,2.030889,1.124875,0.8688808,1.878899,2.090784,0.879012,2.288025,1.264201,2.299878,1.308547,2.242394,0.9834863,0.2249446,0.2590471,2.581776,0.2560646,0.6119147,1.640836,0.8871046,2.767182,1.702782,3.941499,7.14952,6.569343,6.462321,4.923751,4.475451,4.21633,4.403583,5.441007,3.783582,6.476561,4.847642,4.281699,3.990427,4.364326,5.550747,5.828654,4.4343,5.73549,6.101911,4.710408,4.329065,6.713254,7.125621,4.591385,4.600051,4.206632,4.607866,6.127745,6.115005,5.570788,5.980899,5.235888,4.968246,3.984835,5.532036,5.90698,6.396179,3.875412,3.242908,3.651577,2.512296,4.927999,4.909187,4.7998,7.363525,5.786037,5.097615,5.995283,3.605491,11.98649,11.80622,11.77391,9.57053,9.03127,11.20421,11.05147,10.66152,9.711145,10.83832,10.01606,12.70095,11.84432,10.42582,10.72651,9.95,11.03104,11.31815,11.32868,10.59236,10.19656,9.096188,11.78772,12.31213,10.69235,10.94897,11.4645,8.661861,10.64978,11.01855,12.58359,11.32988,11.68083,9.838952,9.607322,10.5094,9.885088,9.984228,13.59408,9.200736,10.14831,9.920518,12.56134,10.17827,10.29835,11.48827,11.90559,11.23101,11.51642,10.20886,8.390889,7.473504,9.392846,9.19927,9.193296,7.933369,7.682661,8.960868,9.127126,8.832256,8.073329,8.213942,9.443903,8.274856,7.929626,7.485262,8.758269,8.673403,8.741613,9.654265,10.76299,9.315538,9.389667,9.02787,7.774931,8.745446,8.160891,8.684384,8.210749,8.222371,9.563986,6.902868,8.343996,10.48299,7.252704,9.117955,9.368824,10.08381,8.253634,8.438511,8.717668,9.047236,10.02662,11.2,8.631797,10.03915,8.412162,7.758041,9.492335,9.622903, + 2.491503,2.982686,2.935692,3.583238,1.239216,2.842937,2.879053,2.066941,3.130945,2.445521,2.640329,3.419213,1.928571,2.755845,1.254357,4.49721,2.111655,1.162296,3.143344,2.662839,1.529289,1.561969,2.281184,3.825355,1.882654,0.8354065,1.242062,0,2.072233,2.969119,2.233202,2.100761,2.203947,3.320514,1.346108,3.497491,1.04979,3.293612,2.041322,3.357467,2.134427,1.241637,1.494901,3.735628,1.406993,1.708929,2.866206,0.7672431,3.762716,2.920286,2.707395,6.266764,5.380854,5.411344,3.863484,3.413489,3.122863,3.185004,4.32768,2.828234,5.448242,3.722934,3.1213,3.289543,3.260665,4.606664,4.697684,3.206597,4.555766,4.902471,4.020973,3.281598,5.545396,5.973393,3.495128,3.520137,3.103159,3.528809,5.23674,5.15933,4.45568,4.807811,4.183596,4.041483,3.269163,4.338678,4.731226,5.173502,2.975701,2.117359,2.730772,2.392467,3.824513,3.80034,3.654164,6.387376,4.584884,4.029179,5.022672,2.420469,10.87047,10.63629,10.68829,8.469516,7.913165,10.04658,9.946978,9.542298,8.727892,9.72637,8.963284,11.50528,10.78325,9.302501,9.56542,8.76528,9.927287,10.22791,10.18266,9.491669,9.088049,7.927268,10.58919,11.22214,9.553057,9.749334,10.36649,7.521668,9.444703,9.955814,11.42577,10.20279,10.70517,8.709564,8.417789,9.414472,8.720688,8.786753,12.44801,7.985292,9.063867,8.901569,11.43258,8.988661,9.221558,10.29801,10.84336,10.06531,10.33612,9.097041,8.347497,7.485992,9.366729,8.964746,8.829782,7.668405,7.538192,8.583214,8.845114,8.808692,7.695863,7.934547,9.121578,7.882535,7.866416,7.330182,8.60817,8.201737,8.378688,9.390915,10.55979,9.328199,9.362548,8.711347,7.746336,8.499523,7.856218,8.530429,8.083591,7.987787,9.263933,6.607651,8.098119,10.21436,6.844551,9.12722,9.058464,9.964844,7.731462,8.055113,8.585207,8.808986,10.07871,10.74626,8.428329,10.07942,8.356288,7.501617,9.207165,9.29629, + 0.4268785,0.9117083,0.9287043,1.903921,1.287705,0.8432271,1.682273,0.2385051,1.422262,0.5371903,0.7727509,1.554203,1.043355,2.482733,1.392315,2.437739,1.354827,0.9155652,2.74769,1.093885,0.9951712,1.141943,1.907877,2.336317,0.5072258,1.313955,0.8399866,2.072233,0,1.807454,0.8710449,0.02892871,2.235863,1.251079,1.236661,1.592583,1.826995,1.967983,1.492735,1.736063,0.3723414,0.8464066,0.5812855,1.984835,0.6754344,0.7527932,0.8011731,1.681271,2.389311,0.8661504,4.777726,7.889864,7.407613,7.266664,5.7357,5.289693,5.039256,5.243191,6.265322,4.573632,7.27354,5.675764,5.117378,4.691892,5.189039,6.322995,6.656542,5.272617,6.572873,6.941397,5.394058,5.140235,7.548187,7.957091,5.413694,5.418355,5.031807,5.425928,6.876946,6.888311,6.395293,6.817145,6.044426,5.73849,4.69201,6.371114,6.743689,7.235598,4.647801,4.075509,4.433234,3.03484,5.75108,5.73359,5.632259,8.139387,6.625683,5.911171,6.775147,4.444645,12.80523,12.63995,12.58266,10.38605,9.852445,12.03516,11.86703,11.48195,10.48398,11.65639,10.81477,13.53939,12.64425,11.24761,11.55845,10.78701,11.84637,12.1288,12.15656,11.40699,11.01396,9.930363,12.62659,13.12205,11.51863,11.78802,12.27766,9.489417,11.48937,11.8198,13.41425,12.15234,12.44741,10.66286,10.44516,11.3222,10.71804,10.8231,14.42131,10.04071,10.95792,10.70685,13.3838,11.01604,11.10522,12.326,12.70589,12.0639,12.35238,11.02729,8.681804,7.740878,9.662886,9.597931,9.665941,8.361739,8.043605,9.443186,9.554003,9.106052,8.563222,8.64762,9.8914,8.771009,8.238221,7.855034,9.110739,9.209056,9.217518,10.06618,11.13165,9.561642,9.660368,9.475312,8.064009,9.154743,8.609446,9.039896,8.555078,8.63018,9.997836,7.360852,8.757111,10.89226,7.767688,9.368103,9.810058,10.40598,8.819014,8.928325,9.059886,9.449375,10.24111,11.71075,9.017299,10.2612,8.710609,8.183478,9.918144,10.07153, + 1.697855,1.828303,2.251821,0.9319575,1.730367,2.225527,0.1251837,2.045135,0.8325065,1.364252,1.21083,1.20128,1.079918,1.162151,1.720113,3.009509,0.8583507,2.094558,4.555131,2.806659,1.485008,2.839576,0.961555,0.9061814,2.293042,2.186694,2.030889,2.969119,1.807454,0,0.9651161,1.807674,1.384925,2.110593,2.850514,1.323917,3.294675,0.3525585,0.9591771,0.7338513,2.170324,2.222313,1.936536,1.134918,2.114468,1.419937,1.969472,2.227564,0.7996511,2.062249,5.332516,7.347582,7.607122,7.085736,5.679694,5.278796,5.120654,5.67691,6.291616,4.458049,7.042876,5.77276,5.354213,4.175089,5.277958,5.991613,6.705462,5.755013,6.775843,7.203775,4.756204,5.115766,7.667223,8.009245,5.464849,5.432916,5.135972,5.437927,6.410272,6.536719,6.417774,6.985423,5.946108,5.42906,4.195942,6.63425,6.924573,7.604764,4.43131,4.344267,4.285159,2.261797,5.790398,5.78707,5.787354,7.757561,6.908663,5.858177,6.463157,4.81477,12.62964,12.64659,12.32543,10.21486,9.742555,12.00566,11.67409,11.33867,10.03335,11.48859,10.51008,13.64402,12.32275,11.12108,11.54922,10.8824,11.65173,11.89187,12.08524,11.21233,10.84925,9.981778,12.75585,12.8679,11.43635,11.934,12.05929,9.455169,11.66696,11.51762,13.36555,12.02062,11.93642,10.56682,10.5673,11.11347,10.73626,10.97399,14.31923,10.29886,10.72913,10.32683,13.23842,11.12812,10.85338,12.42075,12.38622,12.06315,12.40419,10.87171,7.097516,6.140506,8.045324,8.15065,8.34374,6.981704,6.561735,8.142565,8.152718,7.49749,7.292825,7.27164,8.520827,7.509016,6.681345,6.389707,7.6013,8.021421,7.908305,8.6342,9.624876,7.919551,8.043551,8.110311,6.485099,7.730141,7.260321,7.53561,7.041533,7.211125,8.602558,6.056527,7.34468,9.447565,6.567026,7.731668,8.429702,8.843539,7.706657,7.650858,7.536905,8.009399,8.564331,10.43711,7.557328,8.591205,7.135122,6.801767,8.510435,8.700651, + 0.8949661,1.232402,1.534568,1.352317,1.060222,1.479706,0.8418205,1.108651,0.900284,0.5742121,0.590182,1.223136,0.396362,1.657461,1.109475,2.723301,0.5731733,1.198293,3.606628,1.936562,0.7164706,1.876142,1.122092,1.655245,1.335594,1.400347,1.124875,2.233202,0.8710449,0.9651161,0,0.8768578,1.518109,1.596187,1.896862,1.320006,2.378582,1.189447,0.7514879,1.131161,1.242892,1.291455,0.9890254,1.502646,1.166804,0.5327393,1.282638,1.5862,1.649754,1.378236,4.813078,7.430869,7.287703,6.964093,5.476113,5.045439,4.83575,5.220851,6.051099,4.267237,6.948202,5.488974,4.99223,4.208572,4.991557,5.943534,6.457056,5.276203,6.447874,6.849136,4.871581,4.887194,7.389863,7.769206,5.201117,5.188181,4.839334,5.19463,6.443125,6.505227,6.180576,6.677191,5.76863,5.362099,4.2175,6.274208,6.609306,7.199404,4.296093,3.947126,4.108668,2.399192,5.537245,5.526379,5.473441,7.752022,6.541078,5.655172,6.408769,4.376533,12.52968,12.44936,12.26906,10.10508,9.597789,11.82582,11.58095,11.21768,10.07725,11.38129,10.47434,13.39779,12.30164,10.99038,11.3573,10.63333,11.55945,11.82326,11.92787,11.11873,10.73823,9.752312,12.49472,12.81119,11.28293,11.66198,11.98104,9.26869,11.37781,11.48369,13.19935,11.89541,12.02009,10.41785,10.30318,11.02719,10.52716,10.6964,14.18351,9.963732,10.65251,10.33221,13.12363,10.8712,10.78978,12.1767,12.36426,11.86826,12.18256,10.75584,7.843996,6.897785,8.817535,8.801103,8.910243,7.583792,7.233377,8.694383,8.771764,8.262474,7.822511,7.871696,9.119863,8.033822,7.4071,7.049296,8.294297,8.499507,8.465239,9.274925,10.31844,8.710302,8.8152,8.704823,7.226797,8.364285,7.842238,8.224859,7.736572,7.84041,9.218338,6.60453,7.969712,10.09809,7.048513,8.517951,9.035133,9.575865,8.135759,8.186214,8.239439,8.654593,9.382473,10.97568,8.215552,9.404006,7.875151,7.404525,9.134461,9.300218, + 0.4001053,0.8835719,0.9009759,1.890084,1.314078,0.8158746,1.682523,0.2377133,1.40953,0.523653,0.7583085,1.535365,1.059071,2.495449,1.418255,2.408815,1.368171,0.9443928,2.747998,1.079585,1.019059,1.157637,1.922426,2.326272,0.5173697,1.342855,0.8688808,2.100761,0.02892871,1.807674,0.8768578,0,2.253875,1.222253,1.256161,1.572149,1.849239,1.963381,1.508264,1.724584,0.366325,0.8739391,0.6101489,1.968616,0.7030319,0.7745586,0.7722459,1.709701,2.381895,0.8373075,4.806391,7.916328,7.43654,7.294863,5.764111,5.318167,5.067924,5.272034,6.294006,4.601563,7.301552,5.704532,5.14628,4.71755,5.217743,6.350391,6.685299,5.301379,6.601794,6.970321,5.419132,5.168641,7.577074,7.985916,5.442344,5.446917,5.060522,5.454484,6.903699,6.915714,6.423981,6.846052,6.07275,5.765862,4.717819,6.400042,6.772602,7.264425,4.675296,4.10437,4.460972,3.056343,5.779743,5.762281,5.661109,8.166822,6.654604,5.939616,6.802727,4.473572,12.83376,12.66881,12.61093,10.4145,9.881036,12.06397,11.89548,11.51051,10.51129,11.68489,10.84278,13.56832,12.67228,11.27621,11.58727,10.81593,11.87481,12.15712,12.1853,11.43542,11.04245,9.959235,12.65552,13.15035,11.54734,11.81695,12.30605,9.518156,11.51829,11.84788,13.44305,12.18096,12.47452,10.69151,10.47408,11.35058,10.74688,10.85203,14.45004,10.0696,10.98621,10.73453,13.41241,11.04496,11.13345,12.35492,12.73394,12.09275,12.38128,11.05581,8.694404,7.752865,9.674677,9.613891,9.684241,8.378783,8.058555,9.461809,9.570866,9.118035,8.582168,8.664796,9.908885,8.790128,8.251459,7.870295,9.125272,9.229359,9.235961,10.08252,11.1465,9.57266,9.672181,9.492834,8.076644,9.171089,8.627095,9.054535,8.569422,8.646541,10.01488,7.378963,8.773623,10.90844,7.787501,9.379278,9.827352,10.41939,8.840264,8.947231,9.074096,9.465461,10.251,11.73011,9.032903,10.27135,8.723449,8.200452,9.934938,10.08904, + 2.393766,2.748225,3.040329,2.306915,1.240201,2.978054,1.385208,2.438992,2.078334,2.090003,2.088939,2.473639,1.203098,0.5671959,1.142925,4.1881,0.9452475,1.893762,4.70754,3.322709,1.316547,2.83032,0.4462118,2.248645,2.546421,1.698973,1.878899,2.203947,2.235863,1.384925,1.518109,2.253875,0,3.106181,2.734684,2.594751,2.931794,1.720311,0.7691265,2.091119,2.580395,2.101911,1.968024,2.508865,2.09814,1.499731,2.798097,1.467691,2.083054,2.892923,4.122986,6.006033,6.253434,5.700914,4.302374,3.909391,3.768288,4.41005,4.919807,3.083397,5.659229,4.415327,4.033656,2.806134,3.924838,4.611711,5.33421,4.50384,5.428791,5.865455,3.420079,3.74603,6.300533,6.633526,4.102862,4.065663,3.78793,4.070266,5.049018,5.160333,5.044849,5.630238,4.564449,4.046165,2.824054,5.301564,5.572099,6.28854,3.048352,3.062492,2.908648,0.9104486,4.423647,4.422425,4.440784,6.388469,5.577757,4.480267,5.083065,3.550739,11.24784,11.2628,10.94954,8.831497,8.357654,10.6211,10.29273,9.954837,8.681265,10.10579,9.137056,12.26494,10.954,9.736703,10.16532,9.50522,10.27045,10.51379,10.70032,9.830758,9.465976,8.602263,11.37954,11.49217,10.05144,10.56024,10.67989,8.071512,10.29712,10.1456,11.98064,10.63667,10.60079,9.181919,9.193119,9.732689,9.353944,9.6022,12.93503,8.943805,9.349392,8.963359,11.85541,9.75212,9.475588,11.04188,11.01731,10.67932,11.0225,9.488101,6.516771,5.595513,7.515923,7.372317,7.430481,6.128128,5.832041,7.208745,7.321223,6.95558,6.330525,6.413369,7.656067,6.539476,6.059231,5.639041,6.904664,6.990952,6.982437,7.836973,8.918935,7.436764,7.512825,7.239903,5.900031,6.925688,6.373808,6.832141,6.352996,6.401157,7.764077,5.125089,6.526814,8.664184,5.543433,7.239304,7.575286,8.219167,6.619805,6.695344,6.859513,7.222567,8.148525,9.48073,6.795895,8.160582,6.539657,5.95025,7.685722,7.83615, + 0.8512363,0.3741792,0.5092227,1.595365,2.45629,0.5835309,2.011396,1.272457,1.316766,1.049471,1.017571,1.092129,1.964258,3.155406,2.545687,1.19229,2.163237,2.166644,3.118184,1.258013,2.11545,2.142242,2.688265,2.124763,1.52775,2.559773,2.090784,3.320514,1.251079,2.110593,1.596187,1.222253,3.106181,0,2.311871,1.022546,2.938631,2.054016,2.34577,1.581423,1.2455,2.083682,1.832324,1.53786,1.915155,1.850403,0.455837,2.906085,2.287708,0.4189095,6.027441,9.007922,8.653996,8.467146,6.948613,6.506319,6.266589,6.494252,7.492665,5.765744,8.464688,6.908591,6.360469,5.787591,6.418264,7.486658,7.888169,6.523397,7.817936,8.190178,6.461371,6.35366,8.789214,9.192884,6.639672,6.639515,6.261822,6.646784,8.010338,8.051122,7.622739,8.060377,7.252551,6.902422,5.793898,7.619108,7.987653,8.486677,5.820445,5.315574,5.617196,3.995098,6.977508,6.96168,6.87072,9.30169,7.874865,7.125663,7.946374,5.693081,14.02044,13.878,13.78353,11.59794,11.07262,13.2689,13.07806,12.70019,11.6375,12.87114,12.00298,14.7856,13.83256,12.46795,12.79382,12.03077,13.05708,13.33266,13.38557,12.61696,12.2281,11.1696,13.87373,14.3243,12.74543,13.03557,13.48504,10.71889,12.73819,13.01062,14.64724,13.37327,13.58948,11.88651,11.69042,12.52962,11.95518,12.07032,15.64878,11.29133,12.1611,11.87827,14.6043,12.26113,12.30447,13.57091,13.89469,13.30068,13.59416,12.24289,9.203952,8.245553,10.14357,10.25664,10.42413,9.074073,8.670118,10.21629,10.25145,9.598825,9.354741,9.36366,10.6137,9.568712,8.791016,8.496176,9.711753,10.05509,9.984076,10.73855,11.73546,10.01005,10.142,10.20128,8.592883,9.83245,9.345735,9.645899,9.151985,9.311809,10.7007,8.125394,9.44437,11.55414,8.600633,9.824573,10.52459,10.95147,9.707264,9.716121,9.647496,10.11431,10.63706,12.5066,9.66433,10.66765,9.242716,8.89414,10.61077,10.79385, + 1.629601,2.051899,1.83947,3.12152,1.495773,1.749935,2.730714,1.087849,2.63552,1.764789,2.000648,2.790788,1.823074,3.166529,1.598773,3.401874,2.139113,0.8474176,1.998871,1.377539,1.488638,0.2210882,2.578847,3.517636,0.7942362,1.094069,0.879012,1.346108,1.236661,2.850514,1.896862,1.256161,2.734684,2.311871,0,2.828004,0.6271793,3.084759,2.186855,2.936885,1.074262,0.6570205,0.914303,3.215075,0.7369959,1.448163,1.873192,1.485229,3.538033,1.893426,3.917796,7.598847,6.656848,6.754961,5.207678,4.758125,4.463586,4.432055,5.659106,4.166012,6.7938,5.052292,4.436048,4.547241,4.598617,5.947312,6.020618,4.43072,5.845477,6.166837,5.279752,4.627374,6.841389,7.279956,4.8341,4.862265,4.44174,4.871058,6.568863,6.502192,5.786071,6.102419,5.528221,5.378098,4.533115,5.614723,6.023787,6.391846,4.301998,3.455304,4.060766,3.282723,5.160619,5.134947,4.974143,7.732759,5.848805,5.372108,6.367102,3.723761,12.19032,11.91892,12.0203,9.797981,9.23517,11.34098,11.2727,10.86181,10.07393,11.04911,10.30428,12.75586,12.12176,10.62022,10.85761,10.0351,11.25332,11.55871,11.48568,10.81928,10.4129,9.215475,11.83685,12.55239,10.86132,10.99679,11.69442,8.83246,10.68378,11.29435,12.71837,11.51755,12.05116,10.02478,9.68242,10.74427,10.0114,10.03955,13.74874,9.207913,10.39736,10.2467,12.74528,10.25194,10.55711,11.55802,12.1816,11.35272,11.60829,10.42046,9.223788,8.315966,10.23101,9.983673,9.933507,8.705234,8.48958,9.695203,9.896139,9.670093,8.805602,8.981775,10.19967,9.001875,8.757208,8.288791,9.566113,9.368396,9.481073,10.4304,11.55933,10.16116,10.22762,9.784857,8.609758,9.525366,8.920003,9.491046,9.023465,9.004641,10.32775,7.66141,9.123022,11.25877,7.970443,9.96267,10.12865,10.90191,8.924676,9.169425,9.530069,9.830186,10.87998,11.90724,9.424405,10.89055,9.242369,8.532197,10.261,10.37749, + 1.211871,0.9436867,1.401635,0.5849461,2.376887,1.429499,1.264154,1.754392,0.5171921,1.086476,0.8658679,0.1234357,1.705435,2.47728,2.429443,1.693377,1.747955,2.369438,4.03418,2.144705,2.026019,2.717258,2.148634,1.109826,2.059588,2.665087,2.288025,3.497491,1.592583,1.323917,1.320006,1.572149,2.594751,1.022546,2.828004,0,3.416766,1.149507,1.92869,0.6364461,1.81022,2.380131,2.068071,0.51683,2.216191,1.801287,1.160299,2.898365,1.289284,1.215626,6.126118,8.600745,8.602729,8.230347,6.764846,6.340732,6.141769,6.539908,7.350627,5.547637,8.204248,6.796293,6.309411,5.394293,6.298255,7.177314,7.759104,6.593513,7.763171,8.167257,6.01414,6.180771,8.698841,9.071311,6.503832,6.486637,6.147514,6.492766,7.63886,7.733142,7.479596,7.990216,7.050573,6.602056,5.40955,7.592379,7.923206,8.519403,5.558027,5.265649,5.383723,3.503751,6.838497,6.829229,6.785679,8.97045,7.859898,6.944245,7.646731,5.696524,13.79469,13.74511,13.51634,11.37169,10.87602,13.11654,12.84266,12.48936,11.27355,12.64817,11.71092,14.70491,13.53309,12.26524,12.65101,11.93971,12.8208,13.07535,13.21207,12.38022,12.00592,11.05401,13.8042,14.059,12.56545,12.97293,13.23719,10.55919,12.6912,12.72041,14.48697,13.16909,13.19554,11.69825,11.61214,12.28575,11.82467,12.0078,15.46212,11.28162,11.90685,11.54898,14.39446,12.17919,12.03887,13.4829,13.59616,13.16307,13.48403,12.0253,8.302207,7.341656,9.220662,9.416855,9.643977,8.27278,7.822069,9.447369,9.433953,8.682905,8.604291,8.562706,9.809477,8.821204,7.905317,7.657328,8.844282,9.340809,9.212072,9.904124,10.86099,9.075429,9.219475,9.401506,7.697456,9.005647,8.55776,8.781285,8.285509,8.490392,9.884188,7.36617,8.625432,10.71048,7.887215,8.89361,9.716012,10.05258,9.030132,8.960534,8.773714,9.278717,9.68257,11.74272,8.821223,9.716463,8.345143,8.093099,9.788623,9.988744, + 2.235879,2.672553,2.466043,3.668417,1.724828,2.3768,3.181453,1.701503,3.183186,2.337247,2.569724,3.370997,2.223343,3.425751,1.803664,4.024497,2.509154,1.200549,2.094859,1.964124,1.837637,0.8169083,2.866004,4.029862,1.416302,1.23726,1.264201,1.04979,1.826995,3.294675,2.378582,1.849239,2.931794,2.938631,0.6271793,3.416766,0,3.561912,2.515654,3.47074,1.69809,1.088089,1.399768,3.776982,1.228555,1.876074,2.497984,1.510144,4.027126,2.52,3.376659,7.273543,6.137594,6.336041,4.79816,4.35401,4.043756,3.905482,5.208369,3.835455,6.388852,4.600922,3.967068,4.338765,4.169366,5.599267,5.553373,3.891281,5.340863,5.640979,5.069646,4.234577,6.33867,6.786862,4.406084,4.444821,4.015451,4.454047,6.245352,6.142833,5.332699,5.601153,5.119867,5.045526,4.317836,5.099924,5.520949,5.838546,3.998841,3.037862,3.750886,3.323124,4.722884,4.693808,4.508114,7.353412,5.32403,4.955217,5.998994,3.249318,11.70602,11.39523,11.55712,9.330501,8.757812,10.82818,10.79851,10.37844,9.680547,10.57034,9.867103,12.20907,11.67449,10.13462,10.34332,9.503814,10.7797,11.0935,10.98133,10.34889,9.938302,8.699971,11.28914,12.08516,10.3635,10.44982,11.22364,8.340676,10.13242,10.84796,12.20256,11.02694,11.6571,9.536605,9.148008,10.27802,9.496875,9.496961,13.24,8.650025,9.939174,9.831008,12.25086,9.715818,10.10353,11.01821,11.73344,10.83361,11.07683,9.943529,9.303028,8.419576,10.31868,9.975045,9.863967,8.683048,8.522713,9.619151,9.865267,9.758595,8.730681,8.952702,10.14953,8.919657,8.827222,8.317097,9.596732,9.247542,9.412265,10.40805,11.56503,10.26645,10.31483,9.737774,8.695261,9.511595,8.87918,9.519888,9.064548,8.996365,10.28809,7.626135,9.109457,11.23357,7.882314,10.06627,10.08424,10.94705,8.780059,9.091236,9.568796,9.819872,11.00374,11.79198,9.430397,11.00893,9.31596,8.514068,10.22843,10.32518, + 1.785441,1.820368,2.272495,0.6550819,2.054931,2.260397,0.4169061,2.199592,0.7377639,1.47342,1.279299,1.034773,1.378666,1.437441,2.052443,2.839167,1.192381,2.368447,4.700703,2.893918,1.787066,3.053561,1.307401,0.5541797,2.469747,2.495792,2.299878,3.293612,1.967983,0.3525585,1.189447,1.963381,1.720311,2.054016,3.084759,1.149507,3.561912,0,1.305916,0.5137726,2.313634,2.47792,2.178419,0.8515982,2.356249,1.689394,1.9899,2.561838,0.4719488,2.076657,5.683711,7.645504,7.955488,7.416557,6.021143,5.623258,5.46875,6.029441,6.635466,4.800499,7.370302,6.120165,5.705544,4.491522,5.625981,6.314448,7.049559,6.107334,7.125067,7.55406,5.05565,5.46009,8.01283,8.351666,5.811262,5.778032,5.484701,5.782931,6.719411,6.856012,6.761233,7.333452,6.28472,5.755779,4.514126,6.984965,7.273041,7.956635,4.768642,4.696699,4.626777,2.578353,6.135724,6.132937,6.136451,8.070695,7.259562,6.199333,6.785962,5.167321,12.9532,12.98254,12.64259,10.54118,10.07375,12.33987,11.99717,11.66582,10.33497,11.81378,10.82516,13.98472,12.63415,11.44964,11.88499,11.22419,11.97469,12.21117,12.41672,11.53574,11.17533,10.32213,13.09815,13.18481,11.76765,12.27746,12.37996,9.791411,12.01187,11.83166,13.69762,12.34799,12.22856,10.89803,10.91053,11.43589,11.07424,11.31819,14.64707,10.64723,11.05037,10.63514,13.56381,11.47054,11.17258,12.76157,12.69772,12.39905,12.74281,11.19844,7.166547,6.206517,8.096037,8.267794,8.497944,7.124581,6.673393,8.303299,8.284552,7.554137,7.464756,7.414461,8.660709,7.682196,6.763756,6.50803,7.69856,8.210701,8.067563,8.754829,9.717248,7.958601,8.094621,8.253174,6.559066,7.856142,7.411031,7.635016,7.139442,7.340944,8.734791,6.225785,7.476041,9.561838,6.75954,7.774132,8.566974,8.9163,7.913803,7.819499,7.629304,8.129426,8.583051,10.59862,7.672313,8.613679,7.207822,6.944979,8.639125,8.83989, + 1.625559,1.983757,2.271788,1.758904,0.8243909,2.210591,0.8938034,1.70876,1.428604,1.321348,1.33183,1.813772,0.449412,1.011803,0.7882965,3.45289,0.186662,1.34906,4.087952,2.586338,0.6984573,2.239159,0.4200716,1.858732,1.854314,1.31476,1.308547,2.041322,1.492735,0.9591771,0.7514879,1.508264,0.7691265,2.34577,2.186855,1.92869,2.515654,1.305916,0,1.526444,1.850744,1.529968,1.322878,1.949308,1.479983,0.7971413,2.02912,1.283646,1.757667,2.123854,4.381994,6.706812,6.722025,6.301917,4.845043,4.427134,4.243676,4.740611,5.439861,3.624687,6.275677,4.898754,4.44652,3.487392,4.400957,5.252203,5.850916,4.813351,5.885472,6.303668,4.135975,4.265832,6.800923,7.161596,4.599059,4.576196,4.253836,4.581936,5.729358,5.810039,5.568037,6.103866,5.126629,4.675218,3.499308,5.730887,6.03986,6.687161,3.629738,3.420323,3.458676,1.649816,4.930856,4.923884,4.900168,7.051353,6.003073,5.024453,5.720774,3.880718,11.866,11.82642,11.58945,9.443088,8.949255,11.19453,10.914,10.56114,9.365643,10.71954,9.786391,12.79905,11.61044,10.33752,10.73108,10.03396,10.89216,11.14759,11.28686,10.45157,10.07735,9.142264,11.903,12.13205,10.63973,11.07534,11.30893,8.637834,10.80011,10.79601,12.56303,11.2411,11.30013,9.771968,9.711218,10.35724,9.908145,10.1119,13.53492,9.410782,9.978709,9.631449,12.46605,10.27605,10.1115,11.57607,11.67337,11.24381,11.57091,10.09687,7.199824,6.264434,8.187411,8.105734,8.18702,6.873475,6.551132,7.967718,8.064734,7.629021,7.091946,7.160075,8.405686,7.301883,6.752017,6.362316,7.619004,7.758521,7.740171,8.574883,9.639265,8.09411,8.184689,7.9899,6.581952,7.663486,7.125084,7.547924,7.063873,7.138979,8.509442,5.880797,7.26642,9.400533,6.309753,7.898951,8.323113,8.918483,7.388929,7.456379,7.569074,7.957432,8.786932,10.24371,7.524652,8.803755,7.226878,6.69486,8.428544,8.585941, + 1.463591,1.392143,1.858736,0.2340549,2.148598,1.860834,0.707397,1.948342,0.3231766,1.202392,0.9738319,0.5243283,1.442164,1.894771,2.173316,2.325559,1.368515,2.319038,4.394567,2.537222,1.829182,2.870559,1.651136,0.6104827,2.241904,2.528464,2.242394,3.357467,1.736063,0.7338513,1.131161,1.724584,2.091119,1.581423,2.936885,0.6364461,3.47074,0.5137726,1.526444,0,2.042352,2.386706,2.071696,0.4244606,2.242343,1.663825,1.583416,2.675849,0.7215184,1.661755,5.876229,8.07712,8.247704,7.783808,6.353749,5.942698,5.76709,6.25453,6.956284,5.13116,7.746672,6.421828,5.972615,4.894455,5.92447,6.702536,7.368615,6.321526,7.411591,7.830063,5.485831,5.780546,8.32277,8.677362,6.119691,6.093791,5.778354,6.099273,7.133941,7.251407,7.083775,7.628914,6.628122,6.135229,4.913657,7.257152,7.565373,8.210433,5.119031,4.943401,4.96141,2.984407,6.449714,6.443932,6.425754,8.477653,7.529108,6.532903,7.173789,5.39774,13.33708,13.33134,13.04064,10.91891,10.43849,12.69462,12.38239,12.0411,10.76076,12.19397,11.22771,14.31515,13.04334,11.82126,12.23472,11.55088,12.36018,12.6048,12.77984,11.92028,11.55348,10.65544,13.42181,13.58327,12.13151,12.5959,12.77058,10.14041,12.32291,12.23602,14.05868,12.72254,12.66758,11.26243,11.23073,11.82277,11.41647,11.63333,15.01989,10.93699,11.44,11.05009,13.94313,11.79432,11.56664,13.09186,13.10672,12.74819,13.08197,11.57494,7.670129,6.709716,8.59333,8.78042,9.011255,7.638318,7.185627,8.816061,8.798177,8.05373,7.97601,7.928203,9.174482,8.193274,7.27093,7.02095,8.208503,8.71851,8.580451,9.267741,10.22589,8.45154,8.592042,8.766926,7.064257,8.369505,7.9245,8.145344,7.64962,7.854526,9.248418,6.73728,7.989676,10.07404,7.266272,8.268514,9.080727,9.420337,8.416105,8.331281,8.138351,8.642333,9.066699,11.11142,8.184778,9.09908,7.712401,7.458706,9.1526,9.353659, + 0.6011401,0.9790013,0.8063235,2.190422,1.548113,0.7133578,2.045294,0.1420172,1.721313,0.84709,1.068722,1.792845,1.402124,2.84847,1.659407,2.380331,1.719965,1.042772,2.389027,0.7433388,1.299322,0.9255299,2.268671,2.650462,0.2825456,1.465403,0.9834863,2.134427,0.3723414,2.170324,1.242892,0.366325,2.580395,1.2455,1.074262,1.81022,1.69809,2.313634,1.850744,2.042352,0,0.9007087,0.7439933,2.24832,0.7503756,1.081992,0.8000111,1.869039,2.719903,0.8269554,4.833537,8.124688,7.511318,7.443731,5.903126,5.454064,5.189707,5.319027,6.412117,4.767066,7.459397,5.815117,5.236234,4.947774,5.33598,6.533067,6.795582,5.337381,6.682372,7.035754,5.659874,5.30905,7.666983,8.08639,5.564916,5.576396,5.178014,5.584354,7.105233,7.097561,6.541625,6.931537,6.216396,5.950124,4.944843,6.470208,6.856166,7.305415,4.857277,4.206227,4.634598,3.351175,5.90061,5.880627,5.76079,8.346501,6.718407,6.076204,6.978493,4.546881,12.96015,12.76055,12.75311,10.54671,10.00361,12.16425,12.02739,11.6341,10.69396,11.81263,10.99829,13.63868,12.8262,11.39729,11.68492,10.89538,12.00709,12.29659,12.29335,11.56889,11.17144,10.05041,12.72302,13.29079,11.6592,11.88328,12.4417,9.627739,11.5791,12.00018,13.54383,12.30058,12.66293,10.80859,10.54937,11.48691,10.84175,10.92028,14.55917,10.11887,11.12734,10.90399,13.53183,11.12035,11.27841,12.43005,12.88738,12.18736,12.46485,11.18304,9.046921,8.107612,10.03001,9.950271,10.00468,8.708486,8.400674,9.779715,9.901616,9.47274,8.897572,8.993566,10.23534,9.104029,8.60149,8.210795,9.469403,9.53232,9.555341,10.41657,11.48888,9.930393,10.02744,9.819085,8.429059,9.505181,8.952562,9.398144,8.914517,8.980606,10.34438,7.70126,9.106721,11.24337,8.095478,9.736554,10.15516,10.76858,9.133489,9.262901,9.419791,9.801103,10.61165,12.0415,9.371395,10.6314,9.075047,8.530643,10.2661,10.41533, + 1.272803,1.756481,1.695542,2.58911,0.8789991,1.603019,2.105822,0.8255961,2.106168,1.294158,1.517112,2.322074,1.172867,2.514791,0.9898561,3.255914,1.484194,0.2153904,2.606106,1.517087,0.8320461,0.7284276,1.924676,2.941801,0.674414,0.6023909,0.2249446,1.241637,0.8464066,2.222313,1.291455,0.8739391,2.101911,2.083682,0.6570205,2.380131,1.088089,2.47792,1.529968,2.386706,0.9007087,0,0.3169707,2.706635,0.1710377,0.8048376,1.628195,1.025683,2.941005,1.679617,3.948184,7.283338,6.611859,6.556448,5.012684,4.562802,4.29375,4.425609,5.514473,3.894105,6.576868,4.916193,4.335531,4.145997,4.438944,5.669419,5.896312,4.448232,5.782142,6.137848,4.870536,4.419944,6.766305,7.185899,4.668891,4.68256,4.280901,4.690648,6.258378,6.232241,5.643823,6.030989,5.327701,5.089123,4.138248,5.57128,5.955725,6.415019,3.997598,3.306674,3.768479,2.717421,5.003898,4.983289,4.860481,7.477849,5.820777,5.184586,6.108506,3.646976,12.06307,11.85991,11.86095,9.651582,9.106027,11.26362,11.1319,10.73651,9.825746,10.91603,10.11249,12.7405,11.93906,10.4992,10.78423,9.995613,11.11172,11.40352,11.39323,10.67395,10.27527,9.149752,11.82537,12.39789,10.75954,10.98582,11.5473,8.727951,10.68294,11.11249,12.6432,11.4021,11.79826,9.909802,9.65015,10.59291,9.941041,10.02234,13.65906,9.226006,10.23512,10.02626,12.63322,10.22116,10.38767,11.53097,12.00001,11.28666,11.56472,10.2864,8.611394,7.695458,9.614249,9.410945,9.395887,8.142306,7.89848,9.162157,9.3357,9.053579,8.273951,8.422108,9.649806,8.474398,8.149204,7.700408,8.974395,8.866033,8.943946,9.864357,10.97715,9.538047,9.611037,9.233951,7.995705,8.956163,8.367238,8.900282,8.427715,8.433472,9.771556,7.108764,8.554467,10.69311,7.449882,9.340326,9.575555,10.30191,8.440751,8.638938,8.934631,9.258603,10.25018,11.3959,8.845005,10.26246,8.632223,7.967409,9.700896,9.82859, + 0.9966205,1.488338,1.487726,2.272713,0.8246995,1.397787,1.817253,0.6325443,1.789389,0.9841733,1.203376,2.007647,0.9227544,2.329905,0.93885,3.018391,1.248373,0.3344852,2.766001,1.448702,0.652621,0.9263082,1.734916,2.631872,0.6043562,0.739386,0.2590471,1.494901,0.5812855,1.936536,0.9890254,0.6101489,1.968024,1.832324,0.914303,2.068071,1.399768,2.178419,1.322878,2.071696,0.7439933,0.3169707,0,2.389671,0.1782033,0.5433143,1.381874,1.128682,2.637658,1.4438,4.197916,7.380712,6.828313,6.7125,5.175906,4.728194,4.47152,4.661928,5.696702,4.028768,6.7246,5.104309,4.540184,4.20745,4.620032,5.791164,6.085318,4.69182,5.994326,6.360953,4.922517,4.580877,6.971629,7.383221,4.846449,4.853986,4.462447,4.861733,6.361309,6.355911,5.826544,6.239531,5.487104,5.20783,4.203698,5.791077,6.165698,6.654388,4.115094,3.500611,3.894048,2.665,5.183314,5.164863,5.057564,7.605473,6.045064,5.350263,6.238137,3.864533,12.24097,12.06438,12.02569,9.824074,9.28631,11.46175,11.30508,10.91641,9.952531,11.09259,10.26495,12.95994,12.09365,10.68106,10.98427,10.2088,11.28458,11.57043,11.58548,10.8457,10.45063,9.354429,12.04675,12.56425,10.94875,11.20801,11.71747,8.918538,10.90881,11.26821,12.84108,11.58532,11.92057,10.09473,9.866243,10.76224,10.14307,10.24326,13.85075,9.459493,10.40026,10.16585,12.8168,10.43718,10.54955,11.74718,12.15503,11.48899,11.77503,10.46321,8.483224,7.557556,9.479527,9.325726,9.342708,8.068122,7.796138,9.113144,9.262295,8.919658,8.227377,8.350578,9.585661,8.430995,8.027023,7.601295,8.870057,8.842065,8.891762,9.785117,10.88106,9.394737,9.47655,9.16936,7.866086,8.874893,8.302122,8.797059,8.319546,8.350954,9.701584,7.045915,8.474329,10.61347,7.413948,9.198252,9.508597,10.18711,8.431287,8.592787,8.826237,9.17467,10.09655,11.36211,8.753759,10.11143,8.506859,7.891726,9.627398,9.765115, + 1.648521,1.447402,1.911588,0.2029666,2.545225,1.934144,1.123711,2.174184,0.6073642,1.450643,1.21453,0.4755862,1.840981,2.282366,2.57664,2.067442,1.788467,2.66092,4.529596,2.643799,2.214849,3.126243,2.07153,0.625405,2.477432,2.901731,2.581776,3.735628,1.984835,1.134918,1.502646,1.968616,2.508865,1.53786,3.215075,0.51683,3.776982,0.8515982,1.949308,0.4244606,2.24832,2.706635,2.389671,0,2.552674,2.029159,1.660259,3.073818,0.8332441,1.721942,6.285757,8.481765,8.67119,8.205403,6.777965,6.367153,6.191167,6.670288,7.380743,5.55534,8.166932,6.845969,6.394388,5.308221,6.348536,7.120446,7.793074,6.735226,7.834777,8.252293,5.890492,6.204993,8.747073,9.101805,6.544052,6.518247,6.202217,6.523731,7.544922,7.667807,7.508226,8.052655,7.051843,6.554663,5.328335,7.679114,7.988935,8.629976,5.541992,5.363275,5.385402,3.395801,6.874151,6.868328,6.849273,8.891219,7.950739,6.957097,7.59185,5.814945,13.75652,13.75506,13.45702,11.33927,10.86064,13.11788,12.80153,12.46192,11.16815,12.614,11.64281,14.73958,13.45668,12.24261,12.65835,11.97533,12.77927,13.0222,13.20229,12.33952,11.97381,11.07978,13.84627,13.99958,12.55385,13.02031,13.18865,10.56401,12.74714,12.65071,14.48139,13.14351,13.0692,11.68467,11.65518,12.24155,11.8405,12.05768,15.44121,11.36009,11.85819,11.46146,14.3634,12.21878,11.98387,13.51629,13.52012,13.17186,13.50617,11.99554,7.885175,6.925038,8.787763,9.038831,9.303211,7.922086,7.442192,9.114036,9.07015,8.255532,8.284683,8.21144,9.453312,8.502779,7.499995,7.28399,8.449285,9.041284,8.877387,9.528663,10.45843,8.634566,8.786837,9.048985,7.285929,8.636793,8.214749,8.388292,7.892292,8.126196,9.520139,7.045389,8.262502,10.32788,7.593036,8.455516,9.357293,9.634931,8.753974,8.636711,8.374669,8.903654,9.227079,11.4081,8.442229,9.263296,7.930882,7.743085,9.421179,9.631683, + 1.101768,1.5859,1.535353,2.44032,0.9103202,1.443262,1.995342,0.6647552,1.955625,1.129717,1.355563,2.160682,1.092526,2.481037,1.024571,3.090394,1.414868,0.2985142,2.617531,1.404245,0.793934,0.759953,1.886826,2.806732,0.550337,0.7203735,0.2560646,1.406993,0.6754344,2.114468,1.166804,0.7030319,2.09814,1.915155,0.7369959,2.216191,1.228555,2.356249,1.479983,2.242343,0.7503756,0.1710377,0.1782033,2.552674,0,0.7144256,1.460042,1.134984,2.814803,1.513307,4.114326,7.399055,6.770136,6.695004,5.153435,4.704169,4.439346,4.588784,5.661961,4.02365,6.712363,5.065479,4.489894,4.245002,4.585729,5.794661,6.046122,4.613123,5.939082,6.297897,4.965708,4.559649,6.921364,7.338563,4.814555,4.826104,4.42778,4.834076,6.376159,6.358407,5.791507,6.186902,5.467174,5.212948,4.239028,5.730344,6.112047,6.579188,4.120391,3.4572,3.894359,2.759615,5.150302,5.130417,5.012642,7.605836,5.981101,5.326267,6.236983,3.804928,12.20983,12.0151,12.00319,9.796355,9.253389,11.41686,11.27702,10.88387,9.953721,11.06228,10.2502,12.89998,12.07768,10.64719,10.93803,10.15324,11.25673,11.54649,11.54464,10.81855,10.42107,9.304847,11.98534,12.54073,10.90994,11.14597,11.69141,8.878648,10.84405,11.25147,12.79642,11.55059,11.92465,10.05876,9.808576,10.73666,10.09539,10.18211,13.81039,9.388962,10.37739,10.15918,12.7819,10.37959,10.5288,11.68952,12.13879,11.44118,11.7216,10.43269,8.614748,7.692933,9.61387,9.438761,9.440915,8.175942,7.916542,9.209334,9.369943,9.053608,8.322255,8.457224,9.689063,8.524384,8.155978,7.720246,8.991502,8.926021,8.989431,9.895502,10.99912,9.53254,9.610797,9.272914,7.998118,8.986079,8.405785,8.918007,8.442572,8.462625,9.807707,7.148263,8.584939,10.72413,7.503516,9.335539,9.613299,10.31322,8.507911,8.687526,8.949434,9.287104,10.23849,11.45121,8.869417,10.25236,8.637219,8.000202,9.735137,9.868227, + 1.018016,1.477251,1.64012,1.883761,0.6121904,1.563403,1.305535,0.9413163,1.422999,0.8235031,0.9700797,1.716391,0.3795231,1.808939,0.695806,3.032866,0.7069897,0.6790677,3.296035,1.825226,0.2651541,1.469619,1.216071,2.179201,1.058947,0.8736702,0.6119147,1.708929,0.7527932,1.419937,0.5327393,0.7745586,1.499731,1.850403,1.448163,1.801287,1.876074,1.689394,0.7971413,1.663825,1.081992,0.8048376,0.5433143,2.029159,0.7144256,0,1.44845,1.107931,2.158087,1.533089,4.329005,7.177935,6.860267,6.618341,5.105486,4.666107,4.436883,4.754841,5.660595,3.916342,6.614491,5.084883,4.561353,3.966909,4.590572,5.638582,6.060862,4.802493,6.020849,6.410606,4.660118,4.511557,6.977845,7.370213,4.807562,4.802665,4.43561,4.809657,6.172518,6.203437,5.790592,6.256493,5.40679,5.054056,3.969621,5.836227,6.186271,6.742138,3.970384,3.512937,3.76692,2.282056,5.145255,5.131377,5.057511,7.454499,6.099194,5.283277,6.097049,3.922452,12.17545,12.05575,11.93405,9.751947,9.231332,11.44008,11.23142,10.85713,9.793387,11.02616,10.15258,12.98431,11.98217,10.62628,10.96762,10.22302,11.21033,11.4838,11.55095,10.77,10.38298,9.351389,12.07691,12.47502,10.90884,11.24139,11.63709,8.88606,10.95148,11.16023,12.81686,11.53175,11.74995,10.0475,9.887881,10.68183,10.13239,10.27539,13.81196,9.52362,10.31223,10.02956,12.76219,10.45749,10.45483,11.76565,12.04429,11.4765,11.77996,10.39849,7.990654,7.058032,8.980982,8.87171,8.922981,7.627179,7.327212,8.698494,8.820532,8.422117,7.816998,7.912032,9.153444,8.02397,7.539905,7.135739,8.398002,8.45785,8.473805,9.336703,10.41506,8.889745,8.978191,8.737172,7.372897,8.425411,7.870606,8.326119,7.844537,7.900874,9.262957,6.619318,8.026534,10.16388,7.017974,8.694287,9.073422,9.704555,8.066316,8.182262,8.350494,8.722119,9.58395,10.96256,8.294376,9.600586,8.016591,7.449475,9.185121,9.333418, + 0.4304379,0.2184572,0.2834581,1.662285,2.041708,0.2780235,1.856128,0.817881,1.273901,0.7085974,0.770014,1.184833,1.615013,2.915496,2.136911,1.636595,1.855067,1.715538,2.873882,0.9846989,1.71246,1.713916,2.403248,2.178355,1.082334,2.114377,1.640836,2.866206,0.8011731,1.969472,1.282638,0.7722459,2.798097,0.455837,1.873192,1.160299,2.497984,1.9899,2.02912,1.583416,0.8000111,1.628195,1.381874,1.660259,1.460042,1.44845,0,2.471862,2.304521,0.09652344,5.573484,8.625635,8.208634,8.047902,6.522863,6.078575,5.833201,6.042792,7.059505,5.349289,8.049886,6.472247,5.917583,5.411457,5.983875,7.083912,7.452643,6.070481,7.373638,7.74255,6.097539,5.927463,8.347891,8.754977,6.2071,6.20949,5.826963,6.216918,7.620967,7.649039,7.189542,7.617469,6.829256,6.499208,5.415307,7.172282,7.544202,8.03478,5.412633,4.874617,5.204268,3.663845,6.544761,6.52802,6.430966,8.900342,7.426795,6.699172,7.540502,5.245818,13.59446,13.43882,13.36489,11.17351,10.64378,12.83244,12.65421,12.27251,11.24075,12.44533,11.59031,14.34043,13.42008,12.03913,12.35633,11.58755,12.63339,12.91248,12.95194,12.19362,11.80256,10.72957,13.42773,13.90502,12.31304,12.58918,13.06309,10.28485,12.2905,12.59683,14.21128,12.94418,13.19826,11.45583,11.24602,12.10757,11.51654,11.62424,15.21612,10.84116,11.74115,11.47345,14.17551,11.81687,11.88649,13.12681,13.48197,12.86231,13.15242,11.81658,9.051565,8.097588,10.00819,10.05498,10.18508,8.850494,8.47792,9.971313,10.03519,9.458047,9.10166,9.139143,10.38849,9.313566,8.626456,8.298181,9.53091,9.782028,9.741308,10.53236,11.55622,9.886405,10.00626,9.974179,8.436768,9.623057,9.113556,9.463088,8.971724,9.100149,10.48295,7.8805,9.230805,11.35284,8.330698,9.697631,10.30221,10.79315,9.417543,9.464937,9.471552,9.910116,10.5338,12.25508,9.466201,10.56056,9.086708,8.670887,10.39678,10.56884, + 2.054914,2.541443,2.607166,2.907211,0.5286538,2.519128,2.145029,1.761226,2.481593,1.920684,2.078003,2.806702,1.234032,2.005354,0.5098711,4.098213,1.370233,0.8366453,3.471491,2.537362,0.8724647,1.650426,1.514645,3.104107,1.684983,0.4240473,0.8871046,0.7672431,1.681271,2.227564,1.5862,1.709701,1.467691,2.906085,1.485229,2.898365,1.510144,2.561838,1.283646,2.675849,1.869039,1.025683,1.128682,3.073818,1.134984,1.107931,2.471862,0,3.02608,2.543844,3.228057,6.264072,5.760274,5.586959,4.054434,3.608533,3.361516,3.647207,4.587813,2.900128,5.59692,4.002507,3.462184,3.120931,3.512606,4.664079,4.982185,3.696562,4.92175,5.306372,3.846826,3.458977,5.886245,6.287008,3.735268,3.738031,3.355961,3.745523,5.241367,5.228526,4.717864,5.160523,4.363516,4.081336,3.112766,4.7325,5.089084,5.634231,2.98848,2.414416,2.765763,1.824292,4.072963,4.056459,3.966443,6.477549,4.994026,4.22992,5.109811,2.815319,11.12433,10.97248,10.9021,8.704811,8.172379,10.36283,10.18578,9.801511,8.824931,9.975391,9.137722,11.88863,10.96675,9.567676,9.887776,9.130046,10.16511,10.44786,10.48053,9.725723,9.332878,8.264804,10.97929,11.44126,9.841281,10.14267,10.59644,7.813567,9.850303,10.14168,11.74125,10.47262,10.79406,8.983998,8.792295,9.640994,9.049468,9.17677,12.74445,8.418056,9.277126,9.037177,11.70401,9.362514,9.425075,10.67164,11.02823,10.39483,10.6909,9.346381,7.800086,6.911448,8.814083,8.512429,8.449032,7.229038,7.035971,8.210264,8.418138,8.253629,7.320624,7.503847,8.717699,7.516676,7.326613,6.832509,8.111818,7.885829,7.996587,8.954929,10.09422,8.758586,8.810338,8.3033,7.190539,8.052165,7.439346,8.035787,7.574594,7.533032,8.847833,6.18132,7.649688,9.782765,6.485275,8.558613,8.647703,9.4563,7.447492,7.684343,8.080148,8.358287,9.494054,10.4233,7.958481,9.499664,7.814552,7.057101,8.782708,8.895198, + 2.161458,2.113444,2.580254,0.7050159,2.523567,2.581662,0.8836633,2.614395,1.034564,1.872834,1.658587,1.200115,1.850597,1.707167,2.517676,2.899927,1.655917,2.836806,5.093955,3.251283,2.258999,3.497115,1.703872,0.2312316,2.895611,2.96755,2.767182,3.762716,2.389311,0.7996511,1.649754,2.381895,2.083054,2.287708,3.538033,1.289284,4.027126,0.4719488,1.757667,0.7215184,2.719903,2.941005,2.637658,0.8332441,2.814803,2.158087,2.304521,3.02608,0,2.383264,6.119005,7.89119,8.336468,7.738752,6.377005,5.990331,5.850963,6.450616,6.998831,5.162126,7.683588,6.498379,6.10614,4.786246,6.007634,6.618187,7.413348,6.53318,7.51106,7.945844,5.312098,5.826934,8.381572,8.70813,6.185654,6.147322,5.869911,6.151786,6.990849,7.150151,7.123019,7.71329,6.631061,6.070401,4.812651,7.379953,7.655041,8.360551,5.114405,5.110909,4.986093,2.887951,6.50531,6.504668,6.522712,8.348454,7.655634,6.553938,7.088659,5.587937,13.25148,13.31506,12.92524,10.84816,10.39419,12.6675,12.29478,11.97418,10.58448,12.11691,11.1042,14.33221,12.90331,11.7619,12.21752,11.57662,12.27204,12.49928,12.73647,11.83451,11.48119,10.67009,13.45157,13.46657,12.08722,12.63546,12.67131,10.12665,12.37559,12.1075,14.01842,12.65651,12.45644,11.21789,11.26828,11.73221,11.41402,11.67941,14.95576,11.02682,11.34407,10.89893,13.86649,11.82503,11.46117,13.10994,12.96708,12.73169,13.08386,11.50599,7.05237,6.092366,7.954843,8.215804,8.498658,7.112991,6.619208,8.314199,8.253343,7.422303,7.494932,7.401754,8.64009,7.713564,6.669055,6.463905,7.620668,8.265214,8.076925,8.706471,9.627588,7.802757,7.953894,8.237948,6.453888,7.817864,7.409837,7.560275,7.064366,7.309793,8.702977,6.256844,7.446625,9.502723,6.823744,7.623209,8.542823,8.801977,7.997256,7.843602,7.544985,8.081884,8.399889,10.60582,7.619074,8.435136,7.098378,6.934557,8.602488,8.817899, + 0.5166866,0.2752164,0.1971432,1.732402,2.121801,0.2145216,1.949603,0.8600611,1.355868,0.8040566,0.865552,1.247781,1.707628,3.012019,2.218554,1.577341,1.95038,1.775973,2.822291,0.9327742,1.796269,1.726271,2.499202,2.252115,1.109016,2.179858,1.702782,2.920286,0.8661504,2.062249,1.378236,0.8373075,2.892923,0.4189095,1.893426,1.215626,2.52,2.076657,2.123854,1.661755,0.8269554,1.679617,1.4438,1.721942,1.513307,1.533089,0.09652344,2.543844,2.383264,0,5.62753,8.711013,8.272113,8.124149,6.59695,6.151941,5.904121,6.100655,7.130336,5.426879,8.127569,6.541578,5.98313,5.498348,6.054281,7.165062,7.522264,6.126295,7.437993,7.804213,6.186205,6.001479,8.41415,8.823207,6.278335,6.28187,5.897165,6.289366,7.705071,7.730284,7.260338,7.682768,6.904227,6.580326,5.501779,7.234695,7.609137,8.091859,5.492754,4.941641,5.282981,3.75673,6.61586,6.598689,6.498408,8.981643,7.488091,6.772941,7.620792,5.308156,13.66792,13.50608,13.441,11.24767,10.71621,12.9012,12.7285,12.34534,11.32298,12.51889,11.66837,14.40373,13.49811,12.11149,12.42457,11.65236,12.70775,12.98809,13.02211,12.26812,11.87625,10.79645,13.49042,13.98089,12.38382,12.65159,13.13807,10.35496,12.35183,12.67451,14.28025,13.0164,13.28161,11.52743,11.31002,12.18255,11.58419,11.68694,15.28668,10.90013,11.81688,11.5537,14.2478,11.88095,11.96287,13.19094,13.55994,12.93005,13.21814,11.88998,9.146623,8.192421,10.10255,10.15136,10.28152,8.947017,8.574126,10.06769,10.1317,9.552637,9.197912,9.235667,10.48501,9.409774,8.721938,8.394484,9.626892,9.877731,9.837716,10.6288,11.6522,9.980186,10.10065,10.0707,8.531942,9.719517,9.21006,9.559115,9.067677,9.196625,10.57946,7.976903,9.327294,11.44923,8.426544,9.791573,10.39874,10.88848,9.512564,9.56122,9.567405,10.00653,10.62646,12.35132,9.562525,10.65345,9.181906,8.76741,10.49328,10.66536, + 5.193379,5.685964,5.638373,6.109981,3.752917,5.545423,5.275392,4.77234,5.70341,5.119338,5.294906,6.034697,4.448092,4.653758,3.711513,7.20409,4.518181,3.863617,5.165851,5.293917,4.100509,4.136959,4.429812,6.237845,4.571706,3.493131,3.941499,2.707395,4.777726,5.332516,4.813078,4.806391,4.122986,6.027441,3.917796,6.126118,3.376659,5.683711,4.381994,5.876229,4.833537,3.948184,4.197916,6.285757,4.114326,4.329005,5.573484,3.228057,6.119005,5.62753,0,4.57062,2.769667,3.267118,1.948501,1.652559,1.348232,0.5496877,2.078336,1.867722,3.377842,1.542116,0.9449896,2.877226,1.359107,2.959268,2.329599,0.5146228,2.004931,2.2683,3.343224,1.651141,2.994222,3.457395,1.532277,1.628936,1.285438,1.638452,3.648855,3.372162,2.180276,2.268672,2.220088,2.602161,2.82529,1.745563,2.186099,2.476359,2.119212,1.141261,1.96904,3.656902,1.721703,1.67803,1.381188,4.39873,1.953283,2.033855,3.199196,0.6692794,8.369415,8.019775,8.259597,6.035612,5.445358,7.458881,7.482118,7.046963,6.598332,7.246296,6.644217,8.83845,8.411812,6.800153,6.973249,6.12717,7.46444,7.793744,7.619534,7.041894,6.624792,5.330485,7.919231,8.777554,7.010266,7.079246,7.912173,5.002858,6.766078,7.592486,8.830494,7.682276,8.54358,6.1999,5.77147,6.980027,6.127333,6.123238,9.872379,5.293047,6.661446,6.672376,8.898923,6.339604,6.835667,7.643295,8.468376,7.460251,7.700169,6.62544,8.521525,7.848739,9.509551,8.675304,8.254265,7.411533,7.561485,7.992005,8.456234,8.992379,7.176789,7.621363,8.622036,7.312038,8.036234,7.350175,8.531497,7.415918,7.837041,9.009161,10.25004,9.556186,9.503472,8.25278,7.999982,8.217207,7.491974,8.450917,8.097309,7.771515,8.806458,6.394237,7.847248,9.774626,6.339493,9.360241,8.590492,9.872059,6.86114,7.491122,8.548931,8.521755,10.34907,9.854536,8.246641,10.32463,8.502926,7.279652,8.787228,8.775881, + 8.195347,8.634603,8.811341,8.27897,6.602262,8.729969,7.371441,8.007904,8.084341,7.958465,8.021005,8.479663,7.047826,6.209645,6.49938,10.15392,6.893419,7.100686,9.334302,8.79989,6.915336,7.805687,6.452213,8.101836,7.948948,6.682629,7.14952,6.266764,7.889864,7.347582,7.430869,7.916328,6.006033,9.007922,7.598847,8.600745,7.273543,7.645504,6.706812,8.07712,8.124688,7.283338,7.380712,8.481765,7.399055,7.177935,8.625635,6.264072,7.89119,8.711013,4.57062,0,3.120326,1.573107,2.637223,3.020084,3.356037,4.109439,2.580471,3.440016,1.383224,3.032349,3.641081,3.222309,3.277805,1.687904,2.538387,4.244605,3.103164,3.323989,2.591395,3.101224,2.805268,2.614995,3.064813,2.985205,3.403924,2.975213,1.030125,1.199797,2.521947,2.956113,2.35082,2.228043,3.214353,3.341234,3.007707,3.801361,3.297501,4.289935,3.538163,5.098365,2.849494,2.893756,3.203577,0.7876311,3.397376,2.537187,1.371543,4.259333,5.509877,5.877013,5.104244,3.271957,3.035345,5.206124,4.569779,4.347525,2.693417,4.439384,3.29203,7.029542,5.03619,4.183275,4.844047,4.569299,4.545744,4.710547,5.18648,4.131845,3.854566,3.722951,6.282352,5.63696,4.567663,5.605379,4.897939,3.053683,5.473336,4.266655,6.432889,5.005413,4.595032,3.76209,4.403184,4.014227,4.217378,4.818727,7.253885,4.676192,3.619545,3.02822,6.142337,4.82246,3.697006,5.88998,5.1002,5.326249,5.764171,3.894241,5.770073,5.571503,6.526005,5.191434,4.441836,4.246418,4.8072,4.199947,4.867555,6.161009,3.66136,4.313127,4.857033,3.684447,5.392006,4.653772,5.387557,3.459101,4.14141,5.347889,6.541727,6.694982,6.518019,4.6003,5.501744,4.825651,4.136396,5.31862,5.187552,4.577719,5.071724,3.655939,4.58186,5.951079,3.121518,6.539478,4.872109,6.493689,2.896237,3.832849,5.463243,5.066922,7.435905,5.551717,5.000234,7.376978,5.712042,4.208298,5.105261,4.963002, + 7.804742,8.29575,8.30546,8.479065,6.252416,8.213395,7.578882,7.434885,8.132842,7.679816,7.825759,8.498333,6.897651,6.685319,6.185509,9.844663,6.886967,6.496801,7.914015,8.024272,6.608221,6.877609,6.648295,8.496849,7.263462,6.094606,6.569343,5.380854,7.407613,7.607122,7.287703,7.43654,6.253434,8.653996,6.656848,8.602729,6.137594,7.955488,6.722025,8.247704,7.511318,6.611859,6.828313,8.67119,6.770136,6.860267,8.208634,5.760274,8.336468,8.272113,2.769667,3.120326,0,1.580571,2.039371,2.363184,2.486825,2.232372,1.404003,3.193677,1.779888,1.838418,2.298914,3.865794,2.329706,2.418271,1.021715,2.258717,0.8399086,0.5071769,3.786878,2.525069,0.3525698,0.7935739,2.154112,2.202214,2.471383,2.198947,2.751629,2.309811,1.302209,0.6235286,1.884514,2.664385,3.819004,1.042962,0.6826462,0.7147123,3.290442,3.347341,3.372427,5.517437,1.84804,1.842329,1.821957,2.527067,0.8166753,1.883089,2.187547,2.965213,5.611501,5.262078,5.536582,3.337186,2.731256,4.690886,4.744304,4.296516,4.202598,4.502073,4.035978,6.131795,5.724612,4.04786,4.205791,3.384433,4.727853,5.07122,4.849935,4.316755,3.895491,2.562454,5.219955,6.042493,4.24361,4.38257,5.177133,2.257748,4.091433,4.922536,6.065056,4.919908,6.032094,3.447897,3.038447,4.26579,3.35941,3.416828,7.103674,2.691751,3.976504,4.157705,6.131722,3.609463,4.161028,4.919419,5.778063,4.696973,4.955652,3.890911,8.55469,8.145749,9.418002,8.21264,7.528801,7.133947,7.554606,7.279158,7.910564,8.988609,6.650525,7.255537,7.940238,6.709653,8.118813,7.368759,8.306716,6.558518,7.197084,8.41594,9.631137,9.547373,9.410499,7.654398,8.170917,7.811289,7.088912,8.231771,8.013967,7.488875,8.151632,6.325956,7.518593,9.054193,5.968658,9.373213,7.94593,9.508266,5.987092,6.871178,8.364139,8.077324,10.32212,8.642464,7.943447,10.27388,8.510283,7.057615,8.174506,8.056295, + 7.622575,8.095039,8.193932,8.004627,6.010889,8.106079,7.082837,7.343746,7.728371,7.435795,7.540887,8.115669,6.568134,6.034004,5.922536,9.650889,6.482528,6.400975,8.311052,8.055121,6.354013,6.97257,6.134023,7.926517,7.230525,5.978718,6.462321,5.411344,7.266664,7.085736,6.964093,7.294863,5.700914,8.467146,6.754961,8.230347,6.336041,7.416557,6.301917,7.783808,7.443731,6.556448,6.7125,8.205403,6.695004,6.618341,8.047902,5.586959,7.738752,8.124149,3.267118,1.573107,1.580571,0,1.548107,1.99861,2.294098,2.749431,1.189125,2.702241,0.199318,1.76703,2.419809,2.975262,2.166833,1.170302,1.012817,2.8612,1.554664,1.750886,2.638493,2.136946,1.301195,1.270613,1.930143,1.893739,2.320666,1.884774,1.232508,0.8108484,1.089229,1.387627,1.229563,1.671471,2.942306,1.811013,1.443674,2.237463,2.672358,3.303209,2.85609,4.850859,1.621942,1.655598,1.899984,1.151878,1.836245,1.383188,0.7550049,3.120999,5.566046,5.580197,5.316999,3.141847,2.657207,4.929211,4.616919,4.25943,3.360785,4.418375,3.556358,6.62872,5.382736,4.037633,4.483723,3.917145,4.595466,4.865529,5.000202,4.154773,3.775779,2.999783,5.776829,5.857334,4.351097,4.994304,5.019295,2.40522,4.778796,4.556474,6.281394,4.939963,5.330326,3.481475,3.651046,4.064435,3.698692,4.078839,7.236224,3.656518,3.693965,3.495258,6.164135,4.17414,3.838744,5.415422,5.443794,4.997487,5.365286,3.794958,7.026051,6.674309,7.86533,6.634981,5.949323,5.576058,6.030823,5.699081,6.33082,7.450447,5.074799,5.687879,6.360271,5.130484,6.603522,5.85218,6.745832,4.98185,5.616591,6.83537,8.051377,8.004483,7.857701,6.074026,6.671858,6.237803,5.519194,6.671939,6.472809,5.927519,6.571394,4.812022,5.952556,7.477079,4.412739,7.834578,6.365462,7.932267,4.409186,5.291264,6.80718,6.500807,8.772468,7.124401,6.37717,8.721586,6.977966,5.50727,6.593941,6.477458, + 6.100441,6.578425,6.660824,6.580298,4.494636,6.572128,5.664309,5.805688,6.273008,5.927148,6.043793,6.653539,5.079888,4.696599,4.411039,8.136902,5.020559,4.860853,6.799382,6.508061,4.842834,5.424987,4.718695,6.550115,5.686251,4.439579,4.923751,3.863484,5.7357,5.679694,5.476113,5.764111,4.302374,6.948613,5.207678,6.764846,4.79816,6.021143,4.845043,6.353749,5.903126,5.012684,5.175906,6.777965,5.153435,5.105486,6.522863,4.054434,6.377005,6.59695,1.948501,2.637223,2.039371,1.548107,0,0.4506569,0.7569939,1.541377,0.6384963,1.222692,1.590731,0.484181,1.007611,1.833553,0.6505655,1.015851,1.047164,1.694201,1.318381,1.776966,1.878209,0.5954864,2.021497,2.331395,0.4279329,0.3590576,0.7926494,0.349287,1.701045,1.438363,0.7539775,1.435891,0.3217145,0.8053759,1.785206,1.344235,1.402384,2.313049,1.270452,1.760658,1.394536,3.515253,0.3093373,0.3513975,0.6670024,2.570413,1.584411,0.1794275,1.2706,1.6365,7.071976,6.98143,6.850199,4.650722,4.126004,6.351828,6.131564,5.751889,4.882859,5.922726,5.103167,7.964409,6.927507,5.520807,5.886475,5.203053,6.110832,6.394534,6.451802,5.671329,5.279821,4.302634,7.077186,7.388417,5.807299,6.258645,6.542101,3.794401,5.999755,6.100563,7.723715,6.426283,6.859014,4.94355,4.891441,5.586705,5.063509,5.302648,8.709106,4.685153,5.224559,5.039584,7.656727,5.449749,5.375368,6.741104,6.98823,6.398943,6.728225,5.294306,6.990739,6.446066,7.932008,6.937614,6.428044,5.72529,5.996854,6.166136,6.68735,7.449788,5.395557,5.904304,6.812506,5.508901,6.522942,5.794053,6.884065,5.545798,6.030293,7.231101,8.47526,8.017576,7.925217,6.464304,6.531389,6.494129,5.75893,6.804766,6.505599,6.089278,7.006993,4.776979,6.148023,7.964895,4.595332,7.829911,6.791756,8.18395,4.979788,5.685426,6.918689,6.788678,8.80967,7.937006,6.56332,8.773887,6.959421,5.613769,7.000558,6.957064, + 5.657257,6.136902,6.213929,6.170899,4.054525,6.124987,5.258848,5.357401,5.853058,5.48868,5.609291,6.230722,4.649628,4.32562,3.972825,7.695712,4.600311,4.41207,6.366247,6.057434,4.404296,4.975193,4.317266,6.157783,5.236196,3.991197,4.475451,3.413489,5.289693,5.278796,5.045439,5.318167,3.909391,6.506319,4.758125,6.340732,4.35401,5.623258,4.427134,5.942698,5.454064,4.562802,4.728194,6.367153,4.704169,4.666107,6.078575,3.608533,5.990331,6.151941,1.652559,3.020084,2.363184,1.99861,0.4506569,0,0.336251,1.342228,1.013646,0.8315494,2.037233,0.5539185,0.7239883,1.61976,0.2950161,1.346686,1.426816,1.503879,1.572615,2.031581,1.838306,0.1633971,2.391273,2.73485,0.2421109,0.162067,0.3877379,0.1644851,2.040122,1.833036,1.141149,1.741702,0.7701219,0.950475,1.567145,1.521189,1.692613,2.531408,0.9410287,1.316421,1.009953,3.154431,0.5164563,0.5210808,0.6640765,3.004279,1.788995,0.6221805,1.673992,1.241248,7.515988,7.404964,7.299048,5.096453,4.566327,6.780484,6.577469,6.194149,5.326716,6.36695,5.55382,8.372707,7.377997,5.961633,6.312046,5.608187,6.556867,6.842772,6.885936,6.117727,5.724365,4.715198,7.479532,7.836853,6.243006,6.65561,6.989277,4.223674,6.388637,6.550998,8.154854,6.866982,7.303618,5.381436,5.289349,6.034055,5.483961,5.695191,9.145937,5.04281,5.673279,5.488642,8.097977,5.851875,5.824913,7.14952,7.438684,6.823381,7.14435,5.738066,7.031368,6.434912,7.994568,7.074519,6.61723,5.83273,6.048467,6.354825,6.84127,7.49655,5.554628,6.028163,6.991162,5.681821,6.554917,5.841223,6.975543,5.766614,6.206267,7.39106,8.634621,8.06407,7.988066,6.629488,6.545592,6.622437,5.891051,6.895458,6.570722,6.195682,7.179546,4.847201,6.263167,8.144714,4.730537,7.872593,6.963621,8.29732,5.209816,5.860252,7.002263,6.922853,8.858123,8.202851,6.671397,8.826908,7.005219,5.710708,7.165331,7.141841, + 5.415788,5.899717,5.959165,5.997531,3.824748,5.869296,5.093717,5.097273,5.662479,5.260384,5.390245,6.034327,4.441714,4.212899,3.748323,7.45812,4.412089,4.150487,6.042839,5.777449,4.177831,4.681977,4.161497,6.010123,4.964984,3.732447,4.21633,3.122863,5.039256,5.120654,4.83575,5.067924,3.768288,6.266589,4.463586,6.141769,4.043756,5.46875,4.243676,5.76709,5.189707,4.29375,4.47152,6.191167,4.439346,4.436883,5.833201,3.361516,5.850963,5.904121,1.348232,3.356037,2.486825,2.294098,0.7569939,0.336251,0,1.106361,1.226306,0.7761617,2.345915,0.6551878,0.4724879,1.713466,0.1574253,1.682366,1.62403,1.267342,1.660952,2.103656,2.045168,0.3029451,2.558117,2.934698,0.3752088,0.4010679,0.06421847,0.4103248,2.375364,2.167292,1.356351,1.86477,1.07793,1.262021,1.659466,1.553015,1.804602,2.562363,0.9643192,1.009267,0.946763,3.062888,0.7118641,0.6951079,0.6757061,3.326401,1.829479,0.9116022,2.0066,0.9051188,7.770642,7.619179,7.570226,5.357878,4.814942,7.003845,6.838156,6.445233,5.638819,6.622939,5.840863,8.563236,7.660454,6.209553,6.530777,5.798207,6.817972,7.11149,7.119097,6.380285,5.981771,4.917409,7.66287,8.105956,6.479842,6.833063,7.253893,4.452298,6.55643,6.833034,8.381425,7.113818,7.614406,5.623667,5.470719,6.299885,5.695897,5.868896,9.382942,5.178514,5.944772,5.789184,8.345308,6.037434,6.100431,7.341524,7.720629,7.039659,7.347408,5.993357,7.247918,6.622301,8.221785,7.340587,6.906616,6.086773,6.273129,6.644314,7.115391,7.715758,5.832961,6.289714,7.275806,5.965798,6.767497,6.063952,7.219531,6.069037,6.490736,7.667227,8.909385,8.282299,8.215449,6.908822,6.747918,6.885102,6.156721,7.139169,6.801594,6.448501,7.461411,5.085136,6.520127,8.428786,5.000234,8.088943,7.245425,8.550654,5.516147,6.14474,7.242128,7.187846,9.076466,8.51858,6.924216,9.047846,7.224712,5.959834,7.443855,7.428875, + 5.652618,6.145741,6.120606,6.488563,4.163366,6.027886,5.628594,5.251205,6.099875,5.559219,5.724646,6.443831,4.844975,4.916835,4.112066,7.677904,4.887608,4.327659,5.715213,5.80441,4.51632,4.652307,4.748772,6.582717,5.062959,3.942288,4.403583,3.185004,5.243191,5.67691,5.220851,5.272034,4.41005,6.494252,4.432055,6.539908,3.905482,6.029441,4.740611,6.25453,5.319027,4.425609,4.661928,6.670288,4.588784,4.754841,6.042792,3.647207,6.450616,6.100655,0.5496877,4.109439,2.232372,2.749431,1.541377,1.342228,1.106361,0,1.56713,1.793333,2.870683,1.086211,0.6345889,2.790423,1.055679,2.554744,1.790788,0.1620473,1.455948,1.7362,3.150442,1.391334,2.447648,2.908988,1.164009,1.27238,1.043514,1.280623,3.230121,2.919794,1.660254,1.719637,1.77607,2.275056,2.736593,1.199944,1.637208,1.992881,2.023459,1.347942,1.932617,3.851178,1.274785,1.228749,0.9080849,3.891353,1.418769,1.593951,2.744479,0.86268,7.823629,7.490806,7.710394,5.48608,4.896416,6.923253,6.933884,6.500179,6.062761,6.698701,6.096148,8.327936,7.862156,6.253714,6.438147,5.603358,6.916115,7.244579,7.079958,6.492967,6.076183,4.794822,7.410122,8.228907,6.467669,6.569935,7.363653,4.456342,6.261954,7.042979,8.297101,7.137782,8.002376,5.653631,5.250369,6.430697,5.591782,5.609991,9.33584,4.800404,6.111759,6.128919,8.356314,5.819991,6.286029,7.126716,7.918702,6.928197,7.176643,6.07717,8.353375,7.726849,9.324793,8.416326,7.946495,7.174349,7.376657,7.684162,8.180916,8.820783,6.892753,7.370387,8.324519,7.016383,7.873441,7.167971,8.314548,7.078946,7.540156,8.729684,9.97366,9.387554,9.318403,7.966653,7.854245,7.964614,7.233003,8.234348,7.903129,7.537114,8.514906,6.183156,7.605205,9.478074,6.071984,9.194495,8.299103,9.638987,6.515671,7.194324,8.33956,8.264817,10.18175,9.47825,8.012872,10.15262,8.329634,7.051212,8.502787,8.473071, + 6.641958,7.125462,7.184427,7.184541,5.048409,7.094368,6.272313,6.321315,6.864913,6.484034,6.610493,7.241311,5.655885,5.325486,4.970189,8.684032,5.612327,5.374466,7.148279,6.988851,5.400581,5.879003,5.330061,7.168452,6.18393,4.957428,5.441007,4.32768,6.265322,6.291616,6.051099,6.294006,4.919807,7.492665,5.659106,7.350627,5.208369,6.635466,5.439861,6.956284,6.412117,5.514473,5.696702,7.380743,5.661961,5.660595,7.059505,4.587813,6.998831,7.130336,2.078336,2.580471,1.404003,1.189125,0.6384963,1.013646,1.226306,1.56713,0,1.83676,1.303596,0.6077271,1.250199,2.462242,1.076685,1.240803,0.4145185,1.687292,0.7495363,1.185198,2.431875,1.176191,1.386902,1.72174,0.853209,0.8640757,1.234407,0.8581077,1.812585,1.431473,0.1300749,0.8145324,0.5108431,1.307979,2.415195,0.8699207,0.7934879,1.738646,1.904754,2.211983,2.012868,4.147003,0.5153781,0.5318398,0.7165095,2.324522,1.051945,0.4792477,1.25823,1.964643,6.548678,6.398575,6.361488,4.141957,3.591572,5.779517,5.620331,5.222069,4.53725,5.402158,4.659547,7.35939,6.4671,4.985261,5.307984,4.594661,5.600469,5.900511,5.892913,5.164249,4.762259,3.703501,6.465895,6.894618,5.253547,5.642414,6.038925,3.226348,5.377324,5.640198,7.156381,5.888966,6.497725,4.398026,4.275926,5.08682,4.476073,4.682752,8.156638,4.048921,4.738265,4.642521,7.120395,4.83823,4.898889,6.136289,6.526362,5.817994,6.133408,4.772534,7.41947,6.926928,8.333873,7.256327,6.679425,6.087713,6.419209,6.420082,6.985455,7.870306,5.6964,6.245741,7.076291,5.790154,6.962538,6.222207,7.258014,5.757464,6.303074,7.518129,8.757517,8.436335,8.326792,6.748771,6.988341,6.826196,6.091253,7.18002,6.910845,6.450403,7.278111,5.188836,6.498361,8.221075,4.934832,8.253298,7.065073,8.526308,5.1831,5.962542,7.301475,7.111675,9.223925,8.058972,6.919576,9.183366,7.382952,5.989202,7.282342,7.21138, + 4.922725,5.393306,5.502175,5.357611,3.309874,5.415499,4.441787,4.661301,5.05316,4.733587,4.840824,5.435378,3.87091,3.494111,3.220549,6.948691,3.801422,3.726475,5.907613,5.407575,3.65189,4.375989,3.496763,5.331991,4.567539,3.303493,3.783582,2.828234,4.573632,4.458049,4.267237,4.601563,3.083397,5.765744,4.166012,5.547637,3.835455,4.800499,3.624687,5.13116,4.767066,3.894105,4.028768,5.55534,4.02365,3.916342,5.349289,2.900128,5.162126,5.426879,1.867722,3.440016,3.193677,2.702241,1.222692,0.8315494,0.7761617,1.793333,1.83676,0,2.70069,1.365783,1.198562,1.011865,0.9143158,1.782361,2.251264,1.944747,2.39265,2.847007,1.524116,0.6688377,3.220359,3.551264,1.044551,0.9916365,0.8209098,0.9951803,2.410667,2.34131,1.961468,2.57129,1.503019,1.213267,0.9592316,2.313114,2.519978,3.326173,0.2549583,0.9792206,0.1788516,2.323895,1.348003,1.351484,1.43188,3.583953,2.587458,1.401762,2.214509,1.237177,8.264254,8.202269,8.017812,5.839707,5.331092,7.569924,7.317596,6.950564,5.931738,7.115387,6.241648,9.186635,8.071333,6.723182,7.10657,6.424369,7.296322,7.567512,7.664658,6.855764,6.472197,5.525212,8.297862,8.558696,7.018456,7.477134,7.72146,5.01315,7.213974,7.247644,8.939375,7.628178,7.905146,6.152087,6.110115,6.766437,6.285586,6.518804,9.917293,5.874275,6.395941,6.137158,8.856519,6.670169,6.538729,7.963295,8.133118,7.61948,7.950835,6.489223,6.657848,5.981825,7.650528,6.872781,6.52212,5.591559,5.704655,6.261957,6.674408,7.129344,5.415291,5.814542,6.870905,5.567396,6.171543,5.492532,6.691265,5.747491,6.090107,7.230231,8.462622,7.692067,7.644573,6.486839,6.132656,6.409495,5.694905,6.610593,6.24409,5.947505,7.045321,4.556274,6.030181,8.016286,4.561892,7.495533,6.830281,8.041327,5.219357,5.746781,6.703596,6.71756,8.484319,8.254507,6.420465,8.461023,6.640731,5.452202,7.016043,7.032172, + 7.623015,8.091742,8.201831,7.965496,6.009744,8.11475,7.043434,7.356739,7.699339,7.428785,7.528211,8.088497,6.552941,5.97696,5.919002,9.645001,6.457662,6.416907,8.381361,8.081394,6.349645,7.010211,6.095656,7.874616,7.251279,5.994027,6.476561,5.448242,7.27354,7.042876,6.948202,7.301552,5.659229,8.464688,6.7938,8.204248,6.388852,7.370302,6.275677,7.746672,7.459397,6.576868,6.7246,8.166932,6.712363,6.614491,8.049886,5.59692,7.683588,8.127569,3.377842,1.383224,1.779888,0.199318,1.590731,2.037233,2.345915,2.870683,1.303596,2.70069,0,1.856353,2.506795,2.905337,2.226952,1.077237,1.174228,2.98866,1.728654,1.942917,2.527387,2.16677,1.498514,1.446675,1.991585,1.94505,2.377193,1.935686,1.054051,0.6501585,1.215604,1.573058,1.269017,1.614617,2.875187,1.977831,1.625896,2.434785,2.652112,3.351362,2.8476,4.797698,1.699351,1.736286,2.000681,1.02123,2.01701,1.436382,0.627422,3.196466,5.591687,5.650128,5.32168,3.172345,2.713495,4.993707,4.638588,4.295812,3.293043,4.44736,3.541229,6.714858,5.370781,4.079647,4.55627,4.023246,4.616668,4.875073,5.053654,4.176173,3.806882,3.107746,5.873204,5.863481,4.404521,5.100749,5.033981,2.494945,4.894615,4.546963,6.335808,4.97784,5.268531,3.535812,3.76818,4.081606,3.786063,4.196985,7.276778,3.807257,3.704561,3.453904,6.196492,4.281297,3.842188,5.506719,5.432505,5.068838,5.447027,3.828884,6.835079,6.492569,7.670427,6.436161,5.750168,5.380622,5.840937,5.499834,6.131652,7.257879,4.876354,5.490777,6.161038,4.931428,6.414808,5.663553,6.549742,4.783173,5.417291,6.636052,7.852169,7.811088,7.662779,5.874748,6.485718,6.039687,5.321758,6.476028,6.279959,5.731447,6.37212,4.624418,5.7557,7.278273,4.217921,7.641871,6.166156,7.733694,4.210317,5.092073,6.611717,6.302179,8.577941,6.934819,6.180237,8.52666,6.786421,5.313123,6.394623,6.278398, + 6.057402,6.543253,6.591718,6.652092,4.473069,6.501223,5.747089,5.726478,6.317605,5.9082,6.041081,6.689102,5.095369,4.849075,4.398491,8.100697,5.067277,4.77993,6.548842,6.385074,4.827018,5.272331,4.812764,6.659992,5.584032,4.364957,4.847642,3.722934,5.675764,5.77276,5.488974,5.704532,4.415327,6.908591,5.052292,6.796293,4.600922,6.120165,4.898754,6.421828,5.815117,4.916193,5.104309,6.845969,5.065479,5.084883,6.472247,4.002507,6.498379,6.541578,1.542116,3.032349,1.838418,1.76703,0.484181,0.5539185,0.6551878,1.086211,0.6077271,1.365783,1.856353,0,0.652779,2.164664,0.4981774,1.476484,0.9810163,1.231971,1.026879,1.48231,2.312258,0.7059087,1.903008,2.285511,0.3216583,0.3952807,0.6498783,0.3957064,2.144978,1.837383,0.7338114,1.215003,0.6899008,1.281367,2.11277,0.9679693,1.158737,1.97749,1.49373,1.610169,1.544355,3.686932,0.1894754,0.1431061,0.1847894,2.87202,1.235079,0.5083034,1.662833,1.360326,7.14938,6.971397,6.968016,4.746897,4.191743,6.360413,6.224051,5.821829,5.126885,6.004101,5.266484,7.909112,7.074825,5.583554,5.885358,5.144383,6.204353,6.506608,6.481193,5.76888,5.365245,4.266696,7.008032,7.500509,5.844852,6.177937,6.643806,3.814238,5.901375,6.24791,7.739066,6.486,7.092916,4.993609,4.815909,5.692494,5.048067,5.213713,8.746457,4.528591,5.345345,5.243732,7.717044,5.38296,5.506436,6.687752,7.134088,6.392925,6.696018,5.374619,7.461282,6.900696,8.407715,7.421638,6.910087,6.207174,6.469569,6.648296,7.171493,7.921962,5.879668,6.387618,7.295473,5.992476,6.991067,6.265636,7.364328,6.023341,6.513589,7.715081,8.959198,8.489857,8.400979,6.948144,6.994448,6.977779,6.242682,7.284902,6.981379,6.571145,7.49038,5.252894,6.63073,8.447598,5.079051,8.301237,7.275212,8.666797,5.455767,6.168858,7.397818,7.272608,9.282598,8.400229,7.04546,9.247819,7.4312,6.094393,7.48437,7.439454, + 5.510167,6.000189,6.0232,6.205383,3.953739,5.931728,5.317687,5.153968,5.845646,5.381094,5.527127,6.206581,4.60399,4.508806,3.887868,7.552162,4.606354,4.210906,5.898575,5.782728,4.309584,4.656827,4.404461,6.253838,4.996662,3.803427,4.281699,3.1213,5.117378,5.354213,4.99223,5.14628,4.033656,6.360469,4.436048,6.309411,3.967068,5.705544,4.44652,5.972615,5.236234,4.335531,4.540184,6.394388,4.489894,4.561353,5.917583,3.462184,6.10614,5.98313,0.9449896,3.641081,2.298914,2.419809,1.007611,0.7239883,0.4724879,0.6345889,1.250199,1.198562,2.506795,0.652779,0,2.174001,0.4300923,2.0147,1.586995,0.7960917,1.459696,1.859034,2.515862,0.7583119,2.43174,2.852438,0.5873959,0.6846487,0.4104402,0.6940594,2.705379,2.441286,1.37066,1.69995,1.293409,1.672124,2.119988,1.284932,1.627361,2.255038,1.413123,1.048435,1.353623,3.391474,0.8105136,0.7714023,0.5410805,3.519251,1.556563,1.107542,2.270575,0.7178444,7.754393,7.52533,7.591157,5.365644,4.799257,6.928446,6.837742,6.425882,5.779464,6.613188,5.906717,8.42674,7.708427,6.184677,6.44872,5.670307,6.818539,7.128102,7.061652,6.385674,5.977695,4.815092,7.51711,8.120695,6.43181,6.680684,7.260789,4.400604,6.390213,6.882374,8.307982,7.083326,7.744565,5.590167,5.330669,6.312862,5.60559,5.714732,9.327214,4.972379,5.972164,5.892455,8.312375,5.901152,6.136593,7.210707,7.76716,6.951316,7.235017,5.984737,7.718801,7.094699,8.690807,7.79394,7.341202,6.546451,6.742493,7.078796,7.563295,8.186271,6.277533,6.745588,7.715022,6.405585,7.238863,6.533671,7.683562,6.488037,6.930094,8.113628,9.356918,8.753006,8.684434,7.352659,7.220163,7.340427,6.61018,7.603291,7.269608,6.908802,7.903131,5.550848,6.978459,8.868552,5.450956,8.559914,7.687189,9.01096,5.92952,6.584069,7.707593,7.641839,9.547202,8.914072,7.384585,9.518158,7.695138,6.421664,7.888382,7.865819, + 4.981839,5.414757,5.60559,5.105445,3.406718,5.526483,4.187134,4.824706,4.87998,4.738194,4.798699,5.274509,3.825948,3.079315,3.299914,6.931701,3.673807,3.950012,6.43288,5.648327,3.706697,4.737975,3.251111,4.982304,4.793928,3.544972,3.990427,3.289543,4.691892,4.175089,4.208572,4.71755,2.806134,5.787591,4.547241,5.394293,4.338765,4.491522,3.487392,4.894455,4.947774,4.145997,4.20745,5.308221,4.245002,3.966909,5.411457,3.120931,4.786246,5.498348,2.877226,3.222309,3.865794,2.975262,1.833553,1.61976,1.713466,2.790423,2.462242,1.011865,2.905337,2.164664,2.174001,0,1.817969,1.833443,2.853027,2.945485,3.14421,3.605361,0.7332105,1.491463,3.813237,4.056113,1.861866,1.771133,1.77018,1.769825,2.244585,2.365454,2.565129,3.269085,1.994957,1.307324,0.0540279,3.129741,3.235713,4.129372,0.7683506,1.89594,0.9150691,1.913784,2.075927,2.09781,2.28353,3.583217,3.389712,1.982995,2.302947,2.234005,8.46614,8.553205,8.151229,6.062448,5.618815,7.898602,7.509574,7.188654,5.880141,7.330671,6.33501,9.602051,8.148896,6.978084,7.457687,6.873412,7.486924,7.71984,7.957797,7.0489,6.695163,5.957176,8.742348,8.693543,7.308887,7.94672,7.88938,5.379405,7.712442,7.342574,9.239936,7.870918,7.813212,6.440721,6.588011,6.947425,6.672657,7.010634,10.16997,6.466454,6.560517,6.157252,9.080308,7.127842,6.681256,8.386047,8.212277,7.971068,8.340313,6.720317,5.661075,4.971551,6.660171,5.946423,5.665563,4.65247,4.719558,5.409596,5.769496,6.133365,4.540227,4.88877,5.994132,4.707788,5.173227,4.506596,5.725324,4.958553,5.22316,6.325346,7.545233,6.693993,6.654392,5.5985,5.127896,5.479795,4.780316,5.644726,5.263095,5.002227,6.158149,3.60089,5.092215,7.126889,3.679632,6.496503,5.945243,7.083032,4.464312,4.88559,5.731653,5.790149,7.484868,7.496624,5.471028,7.463494,5.64644,4.505185,6.119565,6.161236, + 5.567289,6.051894,6.107758,6.154933,3.978524,6.017684,5.251123,5.244723,5.819442,5.41404,5.545048,6.190975,4.597723,4.367414,3.902809,7.610031,4.56922,4.297871,6.155162,5.918416,4.331955,4.817573,4.318698,6.167162,5.109256,3.880746,4.364326,3.260665,5.189039,5.277958,4.991557,5.217743,3.924838,6.418264,4.598617,6.298255,4.169366,5.625981,4.400957,5.92447,5.33598,4.438944,4.620032,6.348536,4.585729,4.590572,5.983875,3.512606,6.007634,6.054281,1.359107,3.277805,2.329706,2.166833,0.6505655,0.2950161,0.1574253,1.055679,1.076685,0.9143158,2.226952,0.4981774,0.4300923,1.817969,0,1.62033,1.470532,1.21771,1.505123,1.949816,2.103049,0.3422429,2.401184,2.780042,0.2367187,0.2934361,0.1580763,0.3034171,2.314341,2.082351,1.206513,1.707485,0.9656418,1.245315,1.764207,1.403253,1.647619,2.414679,1.085222,1.143608,1.088575,3.214587,0.5651645,0.5448621,0.5229236,3.218019,1.679135,0.7908449,1.917399,0.9863255,7.624248,7.465192,7.428845,5.213878,4.667673,6.851188,6.693578,6.298145,5.51936,6.477086,5.706208,8.406927,7.523354,6.061744,6.377502,5.642026,6.67352,6.969357,6.968062,6.236354,5.836444,4.762388,7.506163,7.963789,6.329594,6.676107,7.110419,4.301005,6.399163,6.695922,8.229132,6.965597,7.493361,5.474699,5.314027,6.156983,5.541843,5.711833,9.232403,5.021337,5.803848,5.661644,8.197043,5.88094,5.96092,7.185375,7.583306,6.885992,7.192197,5.847452,7.303773,6.693374,8.271621,7.364695,6.91174,6.119296,6.324172,6.649336,7.133335,7.77018,5.847447,6.317013,7.28511,5.97561,6.825476,6.116071,7.258882,6.061561,6.500157,7.683579,8.926912,8.337351,8.265186,6.922567,6.81141,6.911663,6.181011,7.178688,6.849057,6.481908,7.473084,5.127929,6.550697,8.43862,5.021368,8.145031,7.257139,8.58392,5.504497,6.154127,7.284114,7.212736,9.13154,8.495499,6.957682,9.101433,7.2789,5.995643,7.458291,7.436106, + 6.654359,7.11258,7.250948,6.918285,5.043435,7.166221,5.996895,6.42303,6.668061,6.442572,6.528963,7.059852,5.550914,4.911019,4.947003,8.656704,5.436294,5.496533,7.650855,7.185144,5.373533,6.157953,5.052145,6.812204,6.341277,5.074443,5.550747,4.606664,6.322995,5.991613,5.943534,6.350391,4.611711,7.486658,5.947312,7.177314,5.599267,6.314448,5.252203,6.702536,6.533067,5.669419,5.791164,7.120446,5.794661,5.638582,7.083912,4.664079,6.618187,7.165062,2.959268,1.687904,2.418271,1.170302,1.015851,1.346686,1.682366,2.554744,1.240803,1.782361,1.077237,1.476484,2.0147,1.833443,1.62033,0,1.45327,2.705215,1.966989,2.356817,1.472002,1.416427,2.249291,2.36974,1.427362,1.33479,1.734168,1.324998,0.6941119,0.565338,1.259519,1.954005,0.8057677,0.5847388,1.805636,2.110724,1.962891,2.913255,1.676175,2.602146,1.900941,3.737204,1.287323,1.333709,1.660663,1.816662,2.279054,0.9722357,0.47156,2.58736,6.638752,6.726943,6.340144,4.230004,3.78802,6.069498,5.682814,5.355993,4.161662,5.500208,4.53419,7.790706,6.359206,5.144689,5.633437,5.087213,5.660381,5.902396,6.125017,5.221303,4.863284,4.169949,6.944531,6.882854,5.476295,6.164482,6.068201,3.568618,5.948329,5.543813,7.407074,6.038319,6.130113,4.608734,4.820508,5.121894,4.861129,5.247902,8.337591,4.792856,4.737766,4.391795,7.250221,5.344337,4.864477,6.580598,6.422,6.145878,6.523753,4.887817,6.195977,5.739746,7.099646,6.01776,5.45974,4.847687,5.194493,5.199066,5.750652,6.642703,4.460068,5.004986,5.852022,4.558814,5.745364,5.000635,6.018791,4.556404,5.07492,6.286516,7.527984,7.207492,7.09249,5.517365,5.781902,5.586007,4.850865,5.941003,5.678842,5.210147,6.051354,3.962454,5.257591,7.000612,3.694029,7.026448,5.837402,7.285741,3.98606,4.73264,6.063589,5.872482,7.992879,6.924492,5.678939,7.950812,6.15719,4.750898,6.052118,5.990951, + 7.037072,7.522185,7.572734,7.59716,5.448748,7.482231,6.685635,6.707373,7.275002,6.884356,7.013808,7.650319,6.062291,5.739467,5.372222,9.080103,6.022674,5.760883,7.459912,7.360513,5.801853,6.241168,5.743913,7.58285,6.563298,5.345961,5.828654,4.697684,6.656542,6.705462,6.457056,6.685299,5.33421,7.888169,6.020618,7.759104,5.553373,7.049559,5.850916,7.368615,6.795582,5.896312,6.085318,7.793074,6.046122,6.060862,7.452643,4.982185,7.413348,7.522264,2.329599,2.538387,1.021715,1.012817,1.047164,1.426816,1.62403,1.790788,0.4145185,2.251264,1.174228,0.9810163,1.586995,2.853027,1.470532,1.45327,0,1.886087,0.5705425,0.9054829,2.769321,1.589716,0.9743807,1.31231,1.255939,1.2749,1.626439,1.269351,1.913705,1.489464,0.2931896,0.5011761,0.8636264,1.644508,2.807419,0.8044607,0.5179137,1.460322,2.316728,2.589686,2.427378,4.560255,0.9206474,0.9307247,1.046817,2.161666,0.8786854,0.8789644,1.332827,2.304231,6.172795,5.995181,6.004195,3.778742,3.21567,5.380843,5.252081,4.844631,4.272087,5.029298,4.332803,6.948187,6.125348,4.605234,4.906976,4.18304,5.232723,5.541109,5.50021,4.799154,4.392319,3.295376,6.05321,6.533785,4.863939,5.228794,5.674307,2.833223,4.962912,5.300314,6.759076,5.506733,6.214008,4.013895,3.86261,4.725891,4.071946,4.268633,7.765441,3.638018,4.386012,4.344383,6.737451,4.425723,4.551807,5.72533,6.183675,5.415643,5.725648,4.40027,7.645223,7.190986,8.538589,7.406914,6.78719,6.272419,6.643517,6.530743,7.123146,8.089173,5.841929,6.415605,7.190664,5.922179,7.197161,6.451227,7.446203,5.843847,6.426797,7.646468,8.879041,8.652711,8.53132,6.878275,7.23515,6.98736,6.255707,7.369348,7.121684,6.632695,7.396621,5.411321,6.673158,8.326493,5.110735,8.473327,7.185854,8.68934,5.267962,6.090877,7.495607,7.265663,9.435611,8.075983,7.096795,9.391742,7.605151,6.183139,7.407981,7.318917, + 5.685389,6.178416,6.1411,6.555571,4.2168,6.048223,5.703815,5.273378,6.160104,5.601185,5.771192,6.499276,4.904264,5.01745,4.169282,7.703512,4.956826,4.357335,5.664432,5.806188,4.567938,4.650146,4.833928,6.661179,5.077733,3.978922,4.4343,3.206597,5.272617,5.755013,5.276203,5.301379,4.50384,6.523397,4.43072,6.593513,3.891281,6.107334,4.813351,6.321526,5.337381,4.448232,4.69182,6.735226,4.613123,4.802493,6.070481,3.696562,6.53318,6.126295,0.5146228,4.244605,2.258717,2.8612,1.694201,1.503879,1.267342,0.1620473,1.687292,1.944747,2.98866,1.231971,0.7960917,2.945485,1.21771,2.705215,1.886087,0,1.512602,1.755667,3.311904,1.553265,2.492243,2.959477,1.323066,1.431944,1.204281,1.440066,3.37693,3.059109,1.774118,1.775629,1.920623,2.4347,2.891738,1.245078,1.692596,1.968228,2.177761,1.448388,2.080354,3.966475,1.421284,1.375005,1.050865,4.007665,1.442045,1.740271,2.883461,0.9540097,7.863974,7.505444,7.763117,5.542218,4.948254,6.946041,6.98185,6.543378,6.155982,6.744374,6.167649,8.325148,7.92308,6.295993,6.460267,5.612553,6.964454,7.297129,7.10846,6.544242,6.125953,4.817874,7.406146,8.278451,6.501403,6.56607,7.412751,4.499333,6.253964,7.106404,8.316925,7.17523,8.087813,5.695585,5.256874,6.484618,5.614581,5.609351,9.359741,4.783797,6.1714,6.211339,8.389868,5.825085,6.347764,7.129066,7.979047,6.946434,7.185546,6.125464,8.514845,7.886447,9.486643,8.577625,8.105346,7.336222,7.538448,7.84304,8.341605,8.98236,7.053155,7.531973,8.484013,7.176139,8.034735,7.329704,8.476586,7.235477,7.699773,8.89014,10.13419,9.54908,9.480258,8.126837,8.014949,8.126126,7.394374,8.396388,8.065072,7.699016,8.674741,6.345193,7.766978,9.637528,6.233175,9.35594,8.458966,9.800857,6.671458,7.353989,8.501606,8.426188,10.34327,9.629618,8.174769,10.31425,8.49123,7.213195,8.663013,8.632206, + 6.968147,7.458701,7.474024,7.643304,5.412719,7.38217,6.745683,6.603773,7.294261,6.840784,6.986023,7.658999,6.057993,5.871671,5.345617,9.009136,6.049455,5.663592,7.170746,7.207306,5.768501,6.066521,5.818539,7.668356,6.437366,5.259285,5.73549,4.555766,6.572873,6.775843,6.447874,6.601794,5.428791,7.817936,5.845477,7.763171,5.340863,7.125067,5.885472,7.411591,6.682372,5.782142,5.994326,7.834777,5.939082,6.020849,7.373638,4.92175,7.51106,7.437993,2.004931,3.103164,0.8399086,1.554664,1.318381,1.572615,1.660952,1.455948,0.7495363,2.39265,1.728654,1.026879,1.459696,3.14421,1.505123,1.966989,0.5705425,1.512602,0,0.4617067,3.17144,1.729904,0.9978068,1.453369,1.348216,1.410658,1.641228,1.408946,2.473976,2.055776,0.7079111,0.2637454,1.258358,2.052614,3.094449,0.2809255,0.1813121,0.9973243,2.512748,2.508073,2.571234,4.71303,1.072967,1.057241,0.9887011,2.686134,0.3144464,1.19406,1.895384,2.135889,6.371331,6.080564,6.254675,4.031307,3.44049,5.495707,5.478176,5.046361,4.689699,5.243669,4.658767,6.96792,6.410634,4.800536,5.012847,4.214587,5.460342,5.788815,5.6419,5.03704,4.62027,3.372287,6.057591,6.772975,5.022663,5.220995,5.907765,3.003601,4.931218,5.593823,6.873709,5.688178,6.597773,4.200915,3.872499,4.975199,4.167054,4.255054,7.903581,3.525438,4.659148,4.717435,6.91033,4.443281,4.835188,5.753177,6.466708,5.510462,5.782599,4.621455,8.159884,7.675661,9.066594,7.959455,7.351347,6.810286,7.158874,7.09422,7.679828,8.608471,6.395581,6.96029,7.753523,6.480074,7.705526,6.963333,7.982796,6.411358,6.987163,8.205998,9.440605,9.173713,9.059431,7.437256,7.734333,7.535828,6.802566,7.905343,7.645715,7.171875,7.958582,5.927388,7.215803,8.891462,5.652061,8.991956,7.747208,9.237568,5.835496,6.649883,8.029165,7.816941,9.959667,8.645221,7.63851,9.91778,8.122171,6.71631,7.968165,7.88326, + 7.342718,7.834778,7.832964,8.062532,5.805919,7.740622,7.170539,6.962328,7.704674,7.227055,7.378706,8.064981,6.461995,6.316489,5.742857,9.379136,6.464695,6.02824,7.407197,7.537221,6.161735,6.387314,6.249164,8.099629,6.784708,5.630586,6.101911,4.902471,6.941397,7.203775,6.849136,6.970321,5.865455,8.190178,6.166837,8.167257,5.640979,7.55406,6.303668,7.830063,7.035754,6.137848,6.360953,8.252293,6.297897,6.410606,7.74255,5.306372,7.945844,7.804213,2.2683,3.323989,0.5071769,1.750886,1.776966,2.031581,2.103656,1.7362,1.185198,2.847007,1.942917,1.48231,1.859034,3.605361,1.949816,2.356817,0.9054829,1.755667,0.4617067,0,3.616838,2.187471,0.7955395,1.269161,1.803955,1.869863,2.079441,1.868434,2.803036,2.369232,1.120185,0.4049802,1.695647,2.493066,3.555734,0.5749321,0.3969359,0.5581607,2.972374,2.90207,3.025205,5.163349,1.534586,1.518283,1.42798,2.815551,0.3181503,1.646327,2.222049,2.497122,6.118539,5.754639,6.041962,3.838002,3.233784,5.190595,5.250814,4.803648,4.645898,5.008966,4.52199,6.602935,6.225789,4.555021,4.704949,3.868434,5.234267,5.576422,5.35334,4.821975,4.400992,3.062274,5.687529,6.548988,4.749442,4.848076,5.683506,2.764134,4.548031,5.420638,6.562548,5.426593,6.504633,3.955026,3.517339,4.769698,3.859065,3.884547,7.604177,3.114639,4.475953,4.625632,6.637161,4.087762,4.659046,5.396306,6.279684,5.192838,5.441508,4.396941,8.550598,8.089623,9.443252,8.298688,7.659262,7.174637,7.548902,7.404847,8.009881,8.994648,6.733235,7.314325,8.065837,6.807837,8.101898,7.356356,8.348679,6.704886,7.307862,8.528356,9.756319,9.558127,9.435964,7.761544,8.138156,7.88314,7.153005,8.272054,8.026941,7.534282,8.273765,6.316695,7.573013,9.19513,6.011799,9.378808,8.064443,9.584826,6.129658,6.97462,8.399082,8.1588,10.34078,8.874902,7.997046,10.29667,8.510618,7.086913,8.288782,8.190072, + 5.669615,6.090508,6.300218,5.68767,4.114034,6.223091,4.780427,5.534448,5.497231,5.414008,5.460978,5.89257,4.497154,3.621431,4.005164,7.588782,4.322513,4.672192,7.164209,6.367185,4.403176,5.469579,3.86581,5.519239,5.51329,4.270763,4.710408,4.020973,5.394058,4.756204,4.871581,5.419132,3.420079,6.461371,5.279752,6.01414,5.069646,5.05565,4.135975,5.485831,5.659874,4.870536,4.922517,5.890492,4.965708,4.660118,6.097539,3.846826,5.312098,6.186205,3.343224,2.591395,3.786878,2.638493,1.878209,1.838306,2.045168,3.150442,2.431875,1.524116,2.527387,2.312258,2.515862,0.7332105,2.103049,1.472002,2.769321,3.311904,3.17144,3.616838,0,1.761876,3.668812,3.832292,2.063337,1.955636,2.108725,1.950709,1.687677,1.914174,2.507193,3.240266,1.922674,1.126535,0.7518234,3.221668,3.224838,4.16769,1.273299,2.491984,1.494862,2.51039,2.173656,2.207967,2.468726,3.04806,3.454327,1.979475,1.900117,2.748578,7.971947,8.148032,7.6221,5.601567,5.20412,7.483982,7.01645,6.724659,5.279343,6.852193,5.799318,9.233326,7.591645,6.526047,7.061298,6.550202,6.993208,7.203492,7.520498,6.560285,6.227083,5.633978,8.399226,8.162082,6.875332,7.62776,7.380248,5.020366,7.416955,6.799088,8.798837,7.404057,7.183105,6.01514,6.289324,6.452918,6.308437,6.71728,9.69582,6.258979,6.06063,5.586842,8.594901,6.80804,6.168135,8.030224,7.655453,7.570607,7.962077,6.256742,5.202942,4.597277,6.177678,5.350414,5.006591,4.074022,4.228736,4.747567,5.150302,5.670599,3.893976,4.292685,5.350197,4.050004,4.723276,4.019167,5.188276,4.262032,4.571207,5.70615,6.938744,6.237206,6.171394,4.963938,4.708667,4.888107,4.17135,5.107699,4.759479,4.432141,5.522788,3.051033,4.511627,6.493712,3.038725,6.044053,5.308001,6.530635,3.754308,4.229127,5.206398,5.195476,7.03139,6.791515,4.906497,7.002682,5.179545,3.938624,5.492399,5.512906, + 5.505239,5.98371,6.065486,6.008577,3.900366,5.976855,5.096126,5.210955,5.692214,5.333674,5.452468,6.070468,4.491221,4.162678,3.817599,7.542333,4.439435,4.266558,6.259476,5.918534,4.249271,4.843545,4.154223,5.994449,5.09386,3.844983,4.329065,3.281598,5.140235,5.115766,4.887194,5.168641,3.74603,6.35366,4.627374,6.180771,4.234577,5.46009,4.265832,5.780546,5.30905,4.419944,4.580877,6.204993,4.559649,4.511557,5.927463,3.458977,5.826934,6.001479,1.651141,3.101224,2.525069,2.136946,0.5954864,0.1633971,0.3029451,1.391334,1.176191,0.6688377,2.16677,0.7059087,0.7583119,1.491463,0.3422429,1.416427,1.589716,1.553265,1.729904,2.187471,1.761876,0,2.554666,2.896824,0.3855414,0.3228607,0.3662183,0.3263453,2.10448,1.926193,1.303263,1.903053,0.9077601,0.9651172,1.438154,1.668724,1.852897,2.681069,0.7890773,1.202676,0.8474523,2.992368,0.6794786,0.6827501,0.7984545,3.118926,1.939079,0.772007,1.773088,1.182667,7.667196,7.564459,7.444897,5.246188,4.719836,6.938672,6.727045,6.346572,5.449992,6.51798,5.693304,8.534667,7.519176,6.114924,6.471017,5.770363,6.706317,6.989608,7.04235,6.266812,5.875132,4.876448,7.642031,7.983373,6.398779,6.818463,7.137503,4.381497,6.551852,6.692548,8.312347,7.020371,7.427402,5.536218,5.452086,6.182082,5.643989,5.858243,9.301316,5.205854,5.81939,5.620524,8.251067,6.014331,5.969426,7.311429,7.580083,6.982646,7.305228,5.88944,6.963746,6.351135,7.933537,7.040609,6.603707,5.78953,5.985568,6.3414,6.813941,7.430574,5.53086,5.990632,6.973144,5.663151,6.484893,5.777094,6.925353,5.766796,6.188068,7.365498,8.607908,7.997583,7.927138,6.606655,6.469778,6.585823,5.85673,6.845069,6.511807,6.151634,7.158991,4.792551,6.222178,8.126191,4.699348,7.804971,6.943005,8.253839,5.214626,5.842061,6.949281,6.888083,8.791789,8.219761,6.627404,8.762121,6.939343,5.663939,7.141805,7.126066, + 7.938334,8.427101,8.454931,8.552483,6.3671,8.363436,7.64456,7.585584,8.220595,7.800205,7.938101,8.591925,6.996915,6.711912,6.295333,9.981327,6.970038,6.64262,8.156653,8.200851,6.722065,7.062465,6.706009,8.548706,7.425068,6.234294,6.713254,5.545396,7.548187,7.667223,7.389863,7.577074,6.300533,8.789214,6.841389,8.698841,6.33867,8.01283,6.800923,8.32277,7.666983,6.766305,6.971629,8.747073,6.921364,6.977845,8.347891,5.886245,8.381572,8.41415,2.994222,2.805268,0.3525698,1.301195,2.021497,2.391273,2.558117,2.447648,1.386902,3.220359,1.498514,1.903008,2.43174,3.813237,2.401184,2.249291,0.9743807,2.492243,0.9978068,0.7955395,3.668812,2.554666,0,0.4756393,2.203425,2.235057,2.551329,2.230339,2.510328,2.071419,1.267536,0.7389718,1.818458,2.56301,3.769109,1.248703,0.8180425,1.066144,3.291012,3.473652,3.397449,5.533905,1.87719,1.880223,1.920431,2.187674,1.070754,1.851908,1.965943,3.125152,5.376035,5.093733,5.272648,3.057403,2.45842,4.501675,4.489611,4.052757,3.862507,4.252461,3.727531,6.008247,5.443868,3.806105,4.020043,3.245236,4.47224,4.806657,4.644726,4.053114,3.634158,2.383493,5.10537,5.786382,4.024868,4.274946,4.920631,2.008736,4.000519,4.63425,5.880566,4.691292,5.709699,3.205985,2.913428,3.995748,3.175427,3.310991,6.907368,2.663966,3.692158,3.83147,5.912653,3.481412,3.873016,4.788195,5.498625,4.520601,4.804964,3.633275,8.317379,7.937471,9.164775,7.93247,7.230885,6.876324,7.319729,6.983448,7.625012,8.745502,6.374103,6.989058,7.643802,6.426289,7.888924,7.137784,8.046676,6.255635,6.907605,8.124358,9.333412,9.30123,9.157174,7.365845,7.949528,7.537952,6.820234,7.972639,7.768662,7.228368,7.856366,6.095663,7.253748,8.750811,5.712366,9.12988,7.652343,9.230969,5.686597,6.585284,8.107416,7.799329,10.07127,8.309606,7.678366,10.02102,8.270734,6.80574,7.882406,7.756515, + 8.341648,8.828207,8.86929,8.905262,6.758287,8.778279,7.991757,8.001647,8.58652,8.193593,8.324937,8.962381,7.374531,7.023862,6.682841,10.38512,7.333996,7.056432,8.622521,8.633491,7.111937,7.501019,7.047853,8.88148,7.84872,6.644404,7.125621,5.973393,7.957091,8.009245,7.769206,7.985916,6.633526,9.192884,7.279956,9.071311,6.786862,8.351666,7.161596,8.677362,8.08639,7.185899,7.383221,9.101805,7.338563,7.370213,8.754977,6.287008,8.70813,8.823207,3.457395,2.614995,0.7935739,1.270613,2.331395,2.73485,2.934698,2.908988,1.72174,3.551264,1.446675,2.285511,2.852438,4.056113,2.780042,2.36974,1.31231,2.959477,1.453369,1.269161,3.832292,2.896824,0.4756393,0,2.568164,2.585626,2.934611,2.579771,2.500038,2.081195,1.593704,1.190065,2.086147,2.766937,4.015471,1.714405,1.272059,1.472576,3.596184,3.882723,3.725011,5.839668,2.232823,2.242843,2.32604,1.92097,1.545863,2.154192,2.011265,3.557278,4.920171,4.68591,4.803647,2.584652,1.98879,4.078609,4.024899,3.593995,3.412384,3.790401,3.252841,5.637865,4.969975,3.348864,3.601378,2.87371,4.007131,4.337664,4.209279,3.584997,3.167423,1.983114,4.74661,5.320185,3.581464,3.927334,4.454778,1.553865,3.672271,4.159218,5.45807,4.240233,5.240526,2.750028,2.560148,3.525318,2.762625,2.973229,6.474777,2.427269,3.217978,3.364701,5.465917,3.118905,3.39815,4.414672,5.024997,4.107826,4.413384,3.168183,8.266494,7.93887,9.081868,7.796897,7.056367,6.790836,7.276174,6.814942,7.478282,8.682814,6.251483,6.885233,7.471787,6.288185,7.852718,7.101952,7.952857,6.071851,6.753967,7.962663,9.154957,9.231649,9.074092,7.212996,7.928279,7.418117,6.712423,7.880822,7.704289,7.135931,7.686634,6.065272,7.152432,8.559527,5.634477,9.065942,7.487067,9.098871,5.511046,6.440908,8.020035,7.668819,9.991303,8.034325,7.575327,9.937285,8.215824,6.731826,7.720056,7.57614, + 5.789066,6.272315,6.334044,6.349203,4.195372,6.244235,5.441289,5.472406,6.021282,5.63103,5.758553,6.395432,4.806371,4.53138,4.117612,7.830935,4.769512,4.525638,6.389914,6.151436,4.547772,5.052894,4.504026,6.349297,5.339992,4.107449,4.591385,3.495128,5.413694,5.464849,5.201117,5.442344,4.102862,6.639672,4.8341,6.503832,4.406084,5.811262,4.599059,6.119691,5.564916,4.668891,4.846449,6.544052,4.814555,4.807562,6.2071,3.735268,6.185654,6.278335,1.532277,3.064813,2.154112,1.930143,0.4279329,0.2421109,0.3752088,1.164009,0.853209,1.044551,1.991585,0.3216583,0.5873959,1.861866,0.2367187,1.427362,1.255939,1.323066,1.348216,1.803955,2.063337,0.3855414,2.203425,2.568164,0,0.1108706,0.3923781,0.1180071,2.118622,1.866237,0.983269,1.530688,0.7349226,1.111905,1.809234,1.283521,1.476954,2.295576,1.174525,1.378808,1.223244,3.366875,0.3378632,0.3254031,0.422127,2.986047,1.553541,0.556642,1.698468,1.213131,7.395458,7.250124,7.195897,4.982805,4.439901,6.632518,6.463013,6.07014,5.283485,6.247731,5.470365,8.201816,7.288306,5.834619,6.160445,5.436463,6.442844,6.736893,6.745918,6.005232,5.606568,4.551273,7.304059,7.731357,6.106057,6.476474,6.878935,4.079519,6.203942,6.460867,8.00955,6.738996,7.25715,5.249166,5.112173,5.925055,5.327146,5.513634,9.009304,4.841569,5.5706,5.424925,7.970487,5.677422,5.726899,6.979391,7.348343,6.669999,6.981546,5.618152,7.245817,6.660476,8.203701,7.260218,6.782499,6.027703,6.259701,6.520171,7.020668,7.709638,5.731349,6.21785,7.160962,5.853229,6.771265,6.053484,7.176064,5.917388,6.376768,7.568404,8.812611,8.277404,8.19712,6.804483,6.765989,6.810927,6.077818,7.09618,6.778624,6.391198,7.351885,5.052605,6.455893,8.314468,4.915322,8.086821,7.136142,8.491459,5.355858,6.031012,7.205141,7.109447,9.071174,8.331773,6.866623,9.038785,7.218371,5.9089,7.340728,7.309187, + 5.78963,6.270991,6.34089,6.322475,4.190662,6.251519,5.411769,5.481751,6.000906,5.625783,5.749415,6.37725,4.792743,4.485165,4.110686,7.829876,4.748372,4.535495,6.441087,6.171367,4.541691,5.08032,4.47151,6.313675,5.354966,4.115803,4.600051,3.520137,5.418355,5.432916,5.188181,5.446917,4.065663,6.639515,4.862265,6.486637,4.444821,5.778032,4.576196,6.093791,5.576396,4.68256,4.853986,6.518247,4.826104,4.802665,6.20949,3.738031,6.147322,6.28187,1.628936,2.985205,2.202214,1.893739,0.3590576,0.162067,0.4010679,1.27238,0.8640757,0.9916365,1.94505,0.3952807,0.6846487,1.771133,0.2934361,1.33479,1.2749,1.431944,1.410658,1.869863,1.955636,0.3228607,2.235057,2.585626,0.1108706,0,0.4338313,0.009995677,2.027898,1.789102,0.992966,1.580318,0.6780538,1.00276,1.718971,1.363241,1.530757,2.371912,1.102535,1.409526,1.170297,3.315225,0.3579953,0.3598897,0.5202123,2.929252,1.629526,0.5107364,1.623964,1.279577,7.387215,7.261181,7.178641,4.970579,4.434353,6.639458,6.451465,6.063599,5.238051,6.238658,5.443173,8.222863,7.264403,5.829669,6.169472,5.457842,6.431068,6.720963,6.748299,5.992597,5.596643,4.567573,7.328026,7.715344,6.106632,6.502816,6.865307,4.083827,6.234042,6.437068,8.015061,6.734693,7.213462,5.247002,5.137088,5.910603,5.339192,5.541532,9.009957,4.88364,5.552866,5.388544,7.966033,5.700601,5.706857,6.999879,7.324763,6.680136,6.997428,5.609351,7.135676,6.552413,8.093093,7.149877,6.674283,5.916896,6.149265,6.411934,6.910834,7.599348,5.621734,6.107252,7.052172,5.744196,6.661367,5.943141,7.065194,5.81135,6.267865,7.45878,8.702946,8.167132,8.086506,6.695084,6.656735,6.700402,5.967385,6.985311,6.667956,6.280381,7.242798,4.941843,6.345163,8.205716,4.804991,7.976644,7.027027,8.380692,5.2506,5.922064,7.094295,6.999043,8.960867,8.230124,6.755816,8.928371,7.108094,5.798037,7.2313,7.200714, + 5.410773,5.895746,5.950171,6.009222,3.823678,5.86005,5.107542,5.086914,5.670354,5.259012,5.391245,6.040715,4.445928,4.237799,3.748713,7.4537,4.421051,4.140064,6.007328,5.760508,4.17743,4.660569,4.177816,6.027323,4.951182,3.723129,4.206632,3.103159,5.031807,5.135972,4.839334,5.060522,3.78793,6.261822,4.44174,6.147514,4.015451,5.484701,4.253836,5.778354,5.178014,4.280901,4.462447,6.202217,4.42778,4.43561,5.826963,3.355961,5.869911,5.897165,1.285438,3.403924,2.471383,2.320666,0.7926494,0.3877379,0.06421847,1.043514,1.234407,0.8209098,2.377193,0.6498783,0.4104402,1.77018,0.1580763,1.734168,1.626439,1.204281,1.641228,2.079441,2.108725,0.3662183,2.551329,2.934611,0.3923781,0.4338313,0,0.4435008,2.427776,2.2127,1.364156,1.850839,1.111721,1.322238,1.716157,1.523712,1.788747,2.530064,1.016916,0.9864747,0.988359,3.092636,0.7232359,0.7026696,0.6528544,3.363031,1.800546,0.9409813,2.050481,0.8554634,7.782257,7.620231,7.586727,5.371943,4.825609,7.007281,6.851654,6.456091,5.670173,6.635133,5.862742,8.558538,7.680512,6.219594,6.533168,5.794009,6.831595,7.127314,7.12501,6.394419,5.994512,4.916362,7.656696,8.121752,6.486851,6.825758,7.268468,4.457894,6.547089,6.853074,8.385433,7.123371,7.644952,5.632331,5.464691,6.314998,5.696864,5.86104,9.389529,5.162981,5.961665,5.815859,8.354802,6.032151,6.11853,7.337377,7.740513,7.041329,7.345832,6.005497,7.311348,6.684335,8.28556,7.40472,6.969875,6.150992,6.336865,6.707561,7.179342,7.779276,5.89675,6.353898,7.339341,6.029342,6.830783,6.127633,7.283679,6.131192,6.554266,7.731119,8.973333,8.34577,8.27923,6.972591,6.810747,6.949278,6.220851,7.203314,6.865493,6.512718,7.525081,5.149219,6.584342,8.492365,5.06427,8.152345,7.309095,8.61487,5.577834,6.208262,7.306214,7.251994,9.139928,8.578904,6.988433,9.111403,7.288252,6.024038,7.507662,7.492283, + 5.796952,6.27819,6.34858,6.327889,4.19768,6.259235,5.416976,5.489592,6.006809,5.63274,5.756114,6.383308,4.79915,4.488956,4.117561,7.837079,4.754238,4.543378,6.450703,6.179761,4.548612,5.089078,4.476492,6.318367,5.363114,4.12361,4.607866,3.528809,5.425928,5.437927,5.19463,5.454484,4.070266,6.646784,4.871058,6.492766,4.454047,5.782931,4.581936,6.099273,5.584354,4.690648,4.861733,6.523731,4.834076,4.809657,6.216918,3.745523,6.151786,6.289366,1.638452,2.975213,2.198947,1.884774,0.349287,0.1644851,0.4103248,1.280623,0.8581077,0.9951803,1.935686,0.3957064,0.6940594,1.769825,0.3034171,1.324998,1.269351,1.440066,1.408946,1.868434,1.950709,0.3263453,2.230339,2.579771,0.1180071,0.009995677,0.4435008,0,2.018062,1.779107,0.9868423,1.577288,0.6684941,0.9946451,1.717743,1.363521,1.528139,2.371631,1.103952,1.418553,1.173763,3.318542,0.3535895,0.356683,0.5235497,2.919549,1.62929,0.501685,1.613982,1.289535,7.379554,7.254751,7.170481,4.962715,4.426886,6.632754,6.443622,6.05605,5.228667,6.230959,5.434532,8.217148,7.255906,5.822217,6.162914,5.452182,6.423212,6.712877,6.741294,5.984698,5.588901,4.561554,7.322541,7.707247,6.099519,6.497524,6.857345,4.076989,6.229053,6.428581,8.00825,6.727271,7.204129,5.239727,5.131705,5.902604,5.332854,5.536376,9.002826,4.879692,5.544695,5.3795,7.958592,5.695074,5.698564,6.994132,7.316281,6.673648,6.991342,5.601674,7.129645,6.547308,8.086696,7.142288,6.665956,5.909741,6.143027,6.403611,6.902994,7.593216,5.613808,6.099847,7.043988,5.736079,6.655479,5.936974,7.058307,5.802617,6.259712,7.450859,8.695041,8.161013,8.080105,6.687083,6.651165,6.692937,5.959854,6.978436,6.661498,6.273247,7.234699,4.935263,6.337894,8.197523,4.797395,7.970589,7.018936,8.373472,5.241754,5.913923,7.087537,6.991494,8.954722,8.220892,6.748662,8.922146,7.101972,5.791044,7.223309,7.192449, + 7.190531,7.636415,7.801012,7.341972,5.590327,7.718582,6.4266,6.990118,7.124385,6.961613,7.032482,7.51901,6.056102,5.292077,5.489152,9.165765,5.915483,6.077671,8.310249,7.775347,5.908823,6.775948,5.494566,7.194782,6.925603,5.658499,6.127745,5.23674,6.876946,6.410272,6.443125,6.903699,5.049018,8.010338,6.568863,7.63886,6.245352,6.719411,5.729358,7.133941,7.105233,6.258378,6.361309,7.544922,6.376159,6.172518,7.620967,5.241367,6.990849,7.705071,3.648855,1.030125,2.751629,1.232508,1.701045,2.040122,2.375364,3.230121,1.812585,2.410667,1.054051,2.144978,2.705379,2.244585,2.314341,0.6941119,1.913705,3.37693,2.473976,2.803036,1.687677,2.10448,2.510328,2.500038,2.118622,2.027898,2.427776,2.018062,0,0.4418299,1.795101,2.401073,1.45745,1.200576,2.230428,2.662055,2.429408,3.34108,2.268064,3.276898,2.508117,4.149617,1.955776,2.001996,2.326661,1.360509,2.787468,1.636676,0.5814636,3.279953,6.284932,6.495651,5.936373,3.926235,3.559676,5.82759,5.329869,5.045567,3.63631,5.168533,4.114154,7.603683,5.915119,4.852166,5.41895,4.979538,5.306559,5.516057,5.851321,4.874669,4.547395,4.075884,6.794602,6.476991,5.209715,6.051674,5.692573,3.431589,5.868451,5.116654,7.12577,5.723089,5.579163,4.357538,4.750461,4.766413,4.698112,5.179038,8.011383,4.845827,4.37364,3.916557,6.908826,5.238359,4.480466,6.416058,5.978753,5.923241,6.329592,4.578655,5.807704,5.44184,6.66669,5.49581,4.878357,4.385025,4.809509,4.620715,5.209665,6.238366,3.930395,4.51518,5.279685,4.008503,5.378791,4.627577,5.558766,3.94679,4.513588,5.73296,6.966677,6.796207,6.659208,4.964628,5.442433,5.080809,4.352059,5.483234,5.262887,4.741809,5.484606,3.585733,4.775808,6.419188,3.219765,6.622917,5.273301,6.782197,3.371799,4.177219,5.614185,5.355765,7.5705,6.263594,5.200439,7.522441,5.761791,4.3063,5.494712,5.410386, + 7.219424,7.677011,7.816282,7.465331,5.608704,7.731538,6.544884,6.987886,7.222607,7.006526,7.091331,7.615155,6.113183,5.443862,5.512129,9.220074,5.994603,6.060393,8.182986,7.747369,5.938419,6.713923,5.602485,7.347464,6.904552,5.638096,6.115005,5.15933,6.888311,6.536719,6.505227,6.915714,5.160333,8.051122,6.502192,7.733142,6.142833,6.856012,5.810039,7.251407,7.097561,6.232241,6.355911,7.667807,6.358407,6.203437,7.649039,5.228526,7.150151,7.730284,3.372162,1.199797,2.309811,0.8108484,1.438363,1.833036,2.167292,2.919794,1.431473,2.34131,0.6501585,1.837383,2.441286,2.365454,2.082351,0.565338,1.489464,3.059109,2.055776,2.369232,1.914174,1.926193,2.071419,2.081195,1.866237,1.789102,2.2127,1.779107,0.4418299,0,1.397376,1.969409,1.152102,1.150031,2.341898,2.257645,2.001346,2.903334,2.241201,3.126479,2.464105,4.277668,1.652596,1.697376,2.011895,1.251369,2.367321,1.338309,0.1758841,3.06687,6.101335,6.234899,5.789277,3.704999,3.290858,5.57203,5.144654,4.831019,3.596665,4.968365,3.978173,7.320009,5.800435,4.625719,5.147219,4.653161,5.121936,5.355338,5.614708,4.684399,4.335574,3.740843,6.491257,6.331881,4.967789,5.72968,5.52408,3.113861,5.53152,4.987472,6.895236,5.512659,5.566283,4.104598,4.407032,4.582233,4.397626,4.836112,7.810235,4.457268,4.195063,3.828008,6.717138,4.91178,4.316783,6.119495,5.863399,5.656855,6.048248,4.362448,6.248313,5.872398,7.108493,5.930405,5.297878,4.826354,5.249589,5.041704,5.640672,6.679784,4.365014,4.954654,5.701904,4.438691,5.817706,5.066664,5.99994,4.355622,4.940164,6.160409,7.391006,7.23787,7.101008,5.393015,5.878655,5.518231,4.790717,5.924522,5.704517,5.182765,5.908428,4.02436,5.21585,6.83703,3.661026,7.064352,5.69816,7.219049,3.779777,4.605878,6.05575,5.791332,8.012327,6.627764,5.640573,7.964259,6.202763,4.748098,5.921309,5.829545, + 6.772028,7.255535,7.314271,7.31184,5.178408,7.224185,6.399066,6.451011,6.993425,6.614023,6.740281,7.370145,5.785299,5.447408,5.100097,8.814107,5.740774,5.504167,7.266628,7.117204,5.530531,6.006076,5.456236,7.293458,6.313076,5.087252,5.570788,4.45568,6.395293,6.417774,6.180576,6.423981,5.044849,7.622739,5.786071,7.479596,5.332699,6.761233,5.568037,7.083775,6.541625,5.643823,5.826544,7.508226,5.791507,5.790592,7.189542,4.717864,7.123019,7.260338,2.180276,2.521947,1.302209,1.089229,0.7539775,1.141149,1.356351,1.660254,0.1300749,1.961468,1.215604,0.7338114,1.37066,2.565129,1.206513,1.259519,0.2931896,1.774118,0.7079111,1.120185,2.507193,1.303263,1.267536,1.593704,0.983269,0.992966,1.364156,0.9868423,1.795101,1.397376,0,0.7333757,0.586893,1.380711,2.518948,0.8674883,0.7236222,1.677679,2.023734,2.340595,2.136946,4.26763,0.6454248,0.6617291,0.8329841,2.233558,1.019543,0.5866061,1.227797,2.086817,6.41947,6.268954,6.234265,4.013836,3.462209,5.649548,5.4918,5.09269,4.425762,5.27317,4.536586,7.231558,6.342042,4.855686,5.17816,4.467109,5.47199,5.772995,5.762841,5.036023,4.633506,3.574774,6.338912,6.766986,5.123523,5.516278,5.910808,3.096275,5.252643,5.515335,7.026352,5.759276,6.383009,4.268191,4.149533,4.959057,4.346582,4.557359,8.026592,3.931204,4.611542,4.52457,6.990685,4.711176,4.772887,6.008376,6.40117,5.688275,6.004501,4.643564,7.452136,6.97387,8.359125,7.262432,6.671049,6.105201,6.451058,6.412551,6.987114,7.900562,5.700167,6.258106,7.070229,5.789417,6.998358,6.255724,7.277132,5.741733,6.299805,7.516831,8.754279,8.465807,8.351975,6.747605,7.028725,6.835774,6.101682,7.199517,6.937942,6.467183,7.27348,5.21951,6.512538,8.212421,4.948637,8.284059,7.061121,8.536998,5.16654,5.960655,7.322707,7.118893,9.251847,8.022502,6.934743,9.210091,7.414307,6.009916,7.280073,7.203122, + 7.20998,7.699752,7.721228,7.859933,5.647045,7.629558,6.958071,6.851395,7.517458,7.07767,7.219731,7.884916,6.285919,6.06202,5.577879,9.252108,6.269949,5.909648,7.434492,7.462189,6.00257,6.323496,6.026141,7.874231,6.688315,5.503222,5.980899,4.807811,6.817145,6.985423,6.677191,6.846052,5.630238,8.060377,6.102419,7.990216,5.601153,7.333452,6.103866,7.628914,6.931537,6.030989,6.239531,8.052655,6.186902,6.256493,7.617469,5.160523,7.71329,7.682768,2.268672,2.956113,0.6235286,1.387627,1.435891,1.741702,1.86477,1.719637,0.8145324,2.57129,1.573058,1.215003,1.69995,3.269085,1.707485,1.954005,0.5011761,1.775629,0.2637454,0.4049802,3.240266,1.903053,0.7389718,1.190065,1.530688,1.580318,1.850839,1.577288,2.401073,1.969409,0.7333757,0,1.318246,2.113916,3.220989,0.5358592,0.08308922,0.9592728,2.673109,2.746155,2.750103,4.895184,1.228077,1.220621,1.2048,2.492373,0.4575029,1.289911,1.819721,2.387347,6.108983,5.829263,5.990931,3.767647,3.176781,5.240209,5.214684,4.78359,4.444331,4.980464,4.398625,6.728292,6.147452,4.537989,4.758142,3.970393,5.196815,5.525072,5.383573,4.773332,4.356652,3.119581,5.820492,6.509332,4.762543,4.985744,5.644165,2.741394,4.700988,5.331104,6.618856,5.426658,6.344097,3.938566,3.631849,4.711458,3.912987,4.019854,7.646339,3.314064,4.395829,4.463128,6.649709,4.201991,4.572191,5.511221,6.203446,5.257516,5.53552,4.357966,8.14632,7.69001,9.038273,7.896852,7.263958,6.769943,7.14461,7.008804,7.609637,8.589989,6.331458,6.910443,7.669501,6.407847,7.69832,6.952398,7.943946,6.313302,6.909436,8.129758,9.359392,9.153355,9.030985,7.362424,7.735877,7.480084,6.749499,7.867279,7.622063,7.129719,7.876768,5.912423,7.168849,8.801213,5.607323,8.974184,7.66693,9.181902,5.737698,6.575271,7.994187,7.756539,9.935867,8.507167,7.592793,9.89171,8.10614,6.681978,7.890534,7.795154, + 6.405605,6.881567,6.9706,6.85309,4.797007,6.882267,5.934529,6.117662,6.555229,6.227169,6.339731,6.938132,5.372268,4.940822,4.711519,8.439356,5.303993,5.173785,7.119046,6.825558,5.143395,5.745314,4.986759,6.808618,6.001618,4.751948,5.235888,4.183596,6.044426,5.946108,5.76863,6.07275,4.564449,7.252551,5.528221,7.050573,5.119867,6.28472,5.126629,6.628122,6.216396,5.327701,5.487104,7.051843,5.467174,5.40679,6.829256,4.363516,6.631061,6.904227,2.220088,2.35082,1.884514,1.229563,0.3217145,0.7701219,1.07793,1.77607,0.5108431,1.503019,1.269017,0.6899008,1.293409,1.994957,0.9656418,0.8057677,0.8636264,1.920623,1.258358,1.695647,1.922674,0.9077601,1.818458,2.086147,0.7349226,0.6780538,1.111721,0.6684941,1.45745,1.152102,0.586893,1.318246,0,0.7974665,1.950658,1.351006,1.30234,2.249487,1.517014,2.082361,1.668121,3.755444,0.5022897,0.5478595,0.8697906,2.252385,1.555037,0.1863933,0.9792767,1.948053,6.768661,6.703223,6.538751,4.345433,3.829196,6.068193,5.825544,5.451452,4.561269,5.619372,4.785798,7.701732,6.611422,5.22246,5.606666,4.946099,5.804605,6.084379,6.161639,5.364605,4.976186,4.039194,6.821106,7.077754,5.515506,6.008713,6.233872,3.512466,5.758143,5.78479,7.43661,6.127772,6.537335,4.649462,4.642474,5.278348,4.790211,5.058422,8.414964,4.476238,4.913619,4.718638,7.357154,5.195569,5.062502,6.479116,6.672323,6.120068,6.458186,4.991857,6.929844,6.423493,7.853559,6.808969,6.264069,5.620787,5.931032,6.003141,6.547371,7.383482,5.255686,5.78759,6.655002,5.358867,6.46944,5.732097,6.787472,5.362069,5.876542,7.085747,8.328246,7.950313,7.846577,6.316982,6.4905,6.372586,5.63685,6.708924,6.428628,5.984321,6.853328,4.703017,6.036715,7.804509,4.475883,7.765706,6.63902,8.069365,4.791392,5.533486,6.827588,6.662288,8.739674,7.718159,6.455837,8.700724,6.894939,5.51711,6.852318,6.795013, + 6.069688,6.528377,6.666355,6.352949,4.458697,6.58171,5.430978,5.839486,6.094357,5.858808,5.946765,6.4852,4.968911,4.364458,4.362304,8.073427,4.858709,4.914672,7.109882,6.605522,4.788986,5.587165,4.484111,6.260433,5.760225,4.492956,4.968246,4.041483,5.73849,5.42906,5.362099,5.765862,4.046165,6.902422,5.378098,6.602056,5.045526,5.755779,4.675218,6.135229,5.950124,5.089123,5.20783,6.554663,5.212948,5.054056,6.499208,4.081336,6.070401,6.580326,2.602161,2.228043,2.664385,1.671471,0.8053759,0.950475,1.262021,2.275056,1.307979,1.213267,1.614617,1.281367,1.672124,1.307324,1.245315,0.5847388,1.644508,2.4347,2.052614,2.493066,1.126535,0.9651172,2.56301,2.766937,1.111905,1.00276,1.322238,0.9946451,1.200576,1.150031,1.380711,2.113916,0.7974665,0,1.272417,2.123108,2.099678,3.046255,1.092859,2.087965,1.322039,3.183541,1.114497,1.155465,1.458076,2.401389,2.343076,0.8722452,1.046706,2.1434,7.201897,7.251651,6.91435,4.785838,4.323908,6.599851,6.247187,5.910086,4.745756,6.059667,5.112929,8.295205,6.939578,5.694245,6.155179,5.566822,6.225,6.473741,6.666071,5.785056,5.420194,4.650279,7.435112,7.456986,6.01682,6.640848,6.637121,4.073268,6.409706,6.122492,7.948024,6.59222,6.712811,5.147496,5.284038,5.6879,5.366223,5.707831,8.891295,5.189586,5.30645,4.975855,7.809402,5.821611,5.436872,7.078804,7.002234,6.668958,7.034558,5.44285,6.18544,5.648567,7.127346,6.151587,5.672244,4.927989,5.191496,5.409865,5.909434,6.644416,4.619679,5.112457,6.049465,4.741439,5.718118,4.988689,6.083354,4.816311,5.265116,6.456726,7.700986,7.212208,7.120578,5.692602,5.72854,5.70431,4.970214,6.003865,5.700943,5.291884,6.240053,3.97233,5.353299,7.203025,3.806942,7.024547,6.024292,7.389481,4.259392,4.919307,6.116477,6.001403,8.004349,7.25667,5.766631,7.968711,6.154046,4.813718,6.228859,6.198285, + 4.985437,5.420777,5.607408,5.125654,3.405862,5.527831,4.206495,4.822565,4.895813,4.744428,4.80749,5.290061,3.833534,3.1055,3.299742,6.940798,3.685561,3.943463,6.412386,5.642827,3.708718,4.725099,3.268407,5.007511,4.788384,3.536716,3.984835,3.269163,4.69201,4.195942,4.2175,4.717819,2.824054,5.793898,4.533115,5.40955,4.317836,4.514126,3.499308,4.913657,4.944843,4.138248,4.203698,5.328335,4.239028,3.969621,5.415307,3.112766,4.812651,5.501779,2.82529,3.214353,3.819004,2.942306,1.785206,1.567145,1.659466,2.736593,2.415195,0.9592316,2.875187,2.11277,2.119988,0.0540279,1.764207,1.805636,2.807419,2.891738,3.094449,3.555734,0.7518234,1.438154,3.769109,4.015471,1.809234,1.718971,1.716157,1.717743,2.230428,2.341898,2.518948,3.220989,1.950658,1.272417,0,3.078286,3.187051,4.07873,0.7148581,1.849434,0.8650851,1.935806,2.025404,2.046916,2.230775,3.564417,3.338763,1.935973,2.276021,2.183322,8.441262,8.521407,8.129565,6.035514,5.588601,7.867614,7.484824,7.161581,5.866673,7.304736,6.314474,9.567617,8.130002,6.950132,7.425533,6.836759,7.46223,7.697089,7.928457,7.023894,6.668571,5.920843,8.706451,8.671993,7.279433,7.90954,7.865938,5.345544,7.673977,7.322486,9.210625,7.843896,7.802928,6.410953,6.550032,6.922952,6.638596,6.972229,10.14312,6.423827,6.536635,6.140279,9.054565,7.090915,6.658505,8.351008,8.193327,7.939067,8.306728,6.693356,5.710682,5.023451,6.70902,5.988911,5.702211,4.695859,4.767658,5.445836,5.810107,6.182888,4.577991,4.930998,6.032474,4.744355,5.223019,4.554772,5.771473,4.989747,5.260503,6.366059,7.587164,6.743813,6.70322,5.637691,5.178658,5.522499,4.821524,5.690859,5.310782,5.046269,6.19737,3.645584,5.135594,7.16646,3.71759,6.546447,5.984244,7.12856,4.492706,4.922353,5.778415,5.832704,7.534896,7.526429,5.51554,7.513264,5.695724,4.549291,6.159542,6.199149, + 6.770996,7.262776,7.265674,7.489791,5.231206,7.173477,6.599726,6.395008,7.1303,6.653161,6.80411,7.490195,5.88715,5.760111,5.167954,8.808755,5.891209,5.458846,6.908686,6.981428,5.587039,5.835562,5.681231,7.531601,6.221332,5.059339,5.532036,4.338678,6.371114,6.63425,6.274208,6.400042,5.301564,7.619108,5.614723,7.592379,5.099924,6.984965,5.730887,7.257152,6.470208,5.57128,5.791077,7.679114,5.730344,5.836227,7.172282,4.7325,7.379953,7.234695,1.745563,3.341234,1.042962,1.811013,1.344235,1.521189,1.553015,1.199944,0.8699207,2.313114,1.977831,0.9679693,1.284932,3.129741,1.403253,2.110724,0.8044607,1.245078,0.2809255,0.5749321,3.221668,1.668724,1.248703,1.714405,1.283521,1.363241,1.523712,1.363521,2.662055,2.257645,0.8674883,0.5358592,1.351006,2.123108,3.078286,0,0.4530989,1.013432,2.457776,2.327139,2.489534,4.615698,1.061572,1.034916,0.8814856,2.951488,0.2769006,1.250878,2.09108,1.926546,6.624081,6.304482,6.518052,4.297534,3.703191,5.728978,5.737636,5.301405,4.970621,5.501062,4.934426,7.169698,6.679816,5.054604,5.244637,4.426836,5.720121,6.052067,5.881996,5.299269,4.881207,3.601627,6.255743,7.033844,5.268034,5.416939,6.168224,3.257296,5.119578,5.864741,7.104879,5.937851,6.877638,4.454377,4.079265,5.239565,4.398172,4.45228,8.140134,3.689569,4.927817,4.997046,7.156618,4.650208,5.105228,5.959844,6.735506,5.738129,5.99848,4.881094,8.280433,7.769437,9.200304,8.125048,7.538536,6.957275,7.281199,7.280012,7.852235,8.73329,6.564141,7.115633,7.93758,6.655463,7.820444,7.082739,8.127145,6.608134,7.166638,8.383145,9.621173,9.299854,9.193263,7.613847,7.840715,7.695784,6.960956,8.049049,7.776338,7.320069,8.140628,6.05224,7.368269,9.079907,5.804753,9.115784,7.928134,9.396088,6.032739,6.827092,8.169921,7.980733,10.08851,8.871079,7.789421,10.04879,8.245109,6.857946,8.146678,8.070609, + 7.137468,7.62755,7.646649,7.796648,5.577278,7.554905,6.896236,6.776634,7.451817,7.007017,7.15026,7.81831,6.218518,6.007726,5.508864,9.179201,6.20521,5.835475,7.351866,7.38447,5.932916,6.244852,5.965911,7.814724,6.612221,5.429851,5.90698,4.731226,6.743689,6.924573,6.609306,6.772602,5.572099,7.987653,6.023787,7.923206,5.520949,7.273041,6.03986,7.565373,6.856166,5.955725,6.165698,7.988935,6.112047,6.186271,7.544202,5.089084,7.655041,7.609137,2.186099,3.007707,0.6826462,1.443674,1.402384,1.692613,1.804602,1.637208,0.7934879,2.519978,1.625896,1.158737,1.627361,3.235713,1.647619,1.962891,0.5179137,1.692596,0.1813121,0.3969359,3.224838,1.852897,0.8180425,1.272059,1.476954,1.530757,1.788747,1.528139,2.429408,2.001346,0.7236222,0.08308922,1.30234,2.099678,3.187051,0.4530989,0,0.955024,2.627845,2.6747,2.698828,4.843506,1.182124,1.172074,1.139698,2.55768,0.39313,1.262637,1.848034,2.310826,6.190283,5.90525,6.073552,3.85049,3.259274,5.318022,5.296867,4.865171,4.524195,5.062377,4.481535,6.799556,6.230485,4.619415,4.835588,4.043351,5.279036,5.607677,5.462709,4.85582,4.438986,3.196073,5.890733,6.591701,4.842571,5.055221,5.726475,2.822587,4.768509,5.414186,6.696401,5.507454,6.42588,4.019859,3.703347,4.794157,3.990123,4.089234,7.72498,3.374286,4.478834,4.545015,6.730014,4.273794,4.655251,5.583362,6.286461,5.334198,5.609734,4.440145,8.158282,7.693164,9.054921,7.923978,7.298593,6.79005,7.156663,7.042805,7.639058,8.603533,6.358835,6.933512,7.703158,6.437726,7.708242,6.963382,7.963749,6.35105,6.941075,8.161088,9.392347,9.167536,9.047671,7.393237,7.743062,7.50505,6.773537,7.886829,7.637108,7.150442,7.909773,5.924478,7.191061,8.836874,5.628572,8.987543,7.699444,9.207019,5.775269,6.605908,8.012796,7.782972,9.951183,8.55717,7.614679,9.907729,8.118867,6.700208,7.922264,7.830069, + 7.64549,8.138616,8.108754,8.443974,6.145777,8.015911,7.565177,7.24044,8.069658,7.549893,7.712218,8.420861,6.818415,6.758122,6.089967,9.6692,6.842012,6.320033,7.506241,7.768827,6.500192,6.610302,6.658038,8.50624,7.045943,5.93502,6.396179,5.173502,7.235598,7.604764,7.199404,7.264425,6.28854,8.486677,6.391846,8.519403,5.838546,7.956635,6.687161,8.210433,7.305415,6.415019,6.654388,8.629976,6.579188,6.742138,8.03478,5.634231,8.360551,8.091859,2.476359,3.801361,0.7147123,2.237463,2.313049,2.531408,2.562363,1.992881,1.738646,3.326173,2.434785,1.97749,2.255038,4.129372,2.414679,2.913255,1.460322,1.968228,0.9973243,0.5581607,4.16769,2.681069,1.066144,1.472576,2.295576,2.371912,2.530064,2.371631,3.34108,2.903334,1.677679,0.9592728,2.249487,3.046255,4.07873,1.013432,0.955024,0,3.4701,3.267087,3.502244,5.622258,2.053477,2.032088,1.894297,3.234965,0.7424205,2.191373,2.762133,2.822891,6.074295,5.597389,6.055476,3.903258,3.293629,5.072644,5.250463,4.785923,4.879339,5.000577,4.649552,6.371014,6.275747,4.536189,4.58728,3.694781,5.235899,5.594072,5.260552,4.843397,4.421798,2.969094,5.45091,6.543357,4.686633,4.612042,5.683686,2.791297,4.293966,5.492332,6.424905,5.3747,6.667202,3.944377,3.3325,4.804929,3.752682,3.663829,7.480448,2.816728,4.544864,4.805621,6.559077,3.893478,4.734904,5.186629,6.326373,5.0541,5.260157,4.41043,9.104726,8.647649,9.99297,8.832956,8.177296,7.720514,8.103013,7.924666,8.539706,9.547468,7.267779,7.855929,8.586018,7.337426,8.657425,7.911234,8.894709,7.215614,7.833306,9.053765,10.27729,10.11034,9.985641,8.288528,8.695075,8.421462,7.693137,8.818428,8.578456,8.079243,8.795396,6.87089,8.115834,9.709425,6.556516,9.931767,8.587375,10.12238,6.641634,7.502498,8.946631,8.694417,10.89184,9.33963,8.540237,10.84701,9.06415,7.635149,8.813405,8.706994, + 4.983799,5.446772,5.576097,5.342339,3.371047,5.491,4.422173,4.74688,5.056832,4.780423,4.8765,5.44351,3.900852,3.427874,3.27657,6.996626,3.810174,3.822054,6.081518,5.51441,3.705237,4.508252,3.473487,5.291613,4.668033,3.400575,3.875412,2.975701,4.647801,4.43131,4.296093,4.675296,3.048352,5.820445,4.301998,5.558027,3.998841,4.768642,3.629738,5.119031,4.857277,3.997598,4.115094,5.541992,4.120391,3.970384,5.412633,2.98848,5.114405,5.492754,2.119212,3.297501,3.290442,2.672358,1.270452,0.9410287,0.9643192,2.023459,1.904754,0.2549583,2.652112,1.49373,1.413123,0.7683506,1.085222,1.676175,2.316728,2.177761,2.512748,2.972374,1.273299,0.7890773,3.291012,3.596184,1.174525,1.102535,1.016916,1.103952,2.268064,2.241201,2.023734,2.673109,1.517014,1.092859,0.7148581,2.457776,2.627845,3.4701,0,1.221141,0.250095,2.245108,1.445758,1.456894,1.584111,3.491795,2.728003,1.444221,2.128068,1.49205,8.237713,8.215412,7.973356,5.814007,5.321274,7.576101,7.287038,6.931402,5.837815,7.090539,6.183769,9.218745,8.012934,6.708031,7.118147,6.462248,7.26537,7.527173,7.661363,6.824656,6.448083,5.556177,8.337227,8.515341,7.013365,7.522639,7.685359,5.023949,7.267485,7.192249,8.939727,7.611406,7.80565,6.144731,6.155725,6.732004,6.305597,6.569262,9.905893,5.953669,6.356485,6.060948,8.836431,6.710982,6.493947,7.996099,8.075205,7.631999,7.974298,6.467285,6.404255,5.732698,7.396185,6.619807,6.275923,5.337576,5.450051,6.01614,6.423177,6.875614,5.166557,5.561437,6.622547,5.320404,5.918221,5.237988,6.436351,5.509478,5.842549,6.979116,8.210566,7.43861,7.390217,6.237154,5.880783,6.156216,5.442615,6.355678,5.989285,5.693243,6.795907,4.301492,5.776321,7.766854,4.311975,7.242243,6.581032,7.786637,4.985568,5.499705,6.448638,6.464487,8.231057,8.022574,6.166049,8.207449,6.38682,5.197806,6.765686,6.784507, + 4.464758,4.953948,4.986607,5.176905,2.905675,4.895664,4.301095,4.119468,4.807003,4.332732,4.479046,5.164093,3.560748,3.570019,2.840999,6.507675,3.575061,3.173801,5.057097,4.777029,3.261547,3.674094,3.407362,5.248519,3.973895,2.762094,3.242908,2.117359,4.075509,4.344267,3.947126,4.10437,3.062492,5.315574,3.455304,5.265649,3.037862,4.696699,3.420323,4.943401,4.206227,3.306674,3.500611,5.363275,3.4572,3.512937,4.874617,2.414416,5.110909,4.941641,1.141261,4.289935,3.347341,3.303209,1.760658,1.316421,1.009267,1.347942,2.211983,0.9792206,3.351362,1.610169,1.048435,1.89594,1.143608,2.602146,2.589686,1.448388,2.508073,2.90207,2.491984,1.202676,3.473652,3.882723,1.378808,1.409526,0.9864747,1.418553,3.276898,3.126479,2.340595,2.746155,2.082361,2.087965,1.849434,2.327139,2.6747,3.267087,1.221141,0,1.000205,2.527891,1.707156,1.683286,1.556959,4.319211,2.594293,1.920238,2.975362,0.4968997,8.759332,8.564443,8.571148,6.353745,5.801728,7.961325,7.83231,7.431931,6.642686,7.613584,6.849044,9.474215,8.666935,7.193718,7.483663,6.716087,7.812451,8.11107,8.087458,7.376116,6.974099,5.854966,8.565188,9.105399,7.452979,7.728994,8.250662,5.421525,7.438567,7.839499,9.340747,8.096022,8.619287,6.603429,6.377881,7.298014,6.642649,6.763021,10.3532,6.016707,6.946556,6.79805,9.326952,6.94813,7.104262,8.257354,8.726904,7.988551,8.278585,6.984014,7.547217,6.826834,8.550957,7.827904,7.496893,6.539498,6.613717,7.237205,7.637904,8.019943,6.385943,6.769292,7.842181,6.541101,7.058142,6.400569,7.620901,6.726711,7.062893,8.19404,9.42231,8.57786,8.545291,7.455143,7.002553,7.362789,6.654234,7.540285,7.158183,6.892074,8.014244,5.493421,6.97901,8.985072,5.529962,8.379314,7.799625,8.977532,6.197902,6.720352,7.627593,7.672112,9.366384,9.232057,7.362615,9.347511,7.534916,6.395422,7.982392,8.004726, + 4.77661,5.244168,5.361932,5.187214,3.16307,5.275971,4.270271,4.526444,4.887276,4.581645,4.684798,5.270801,3.712534,3.316007,3.071527,6.79767,3.636503,3.596426,5.832279,5.284311,3.50205,4.268262,3.324216,5.156998,4.440492,3.174022,3.651577,2.730772,4.433234,4.285159,4.108668,4.460972,2.908648,5.617196,4.060766,5.383723,3.750886,4.626777,3.458676,4.96141,4.634598,3.768479,3.894048,5.385402,3.894359,3.76692,5.204268,2.765763,4.986093,5.282981,1.96904,3.538163,3.372427,2.85609,1.394536,1.009953,0.946763,1.932617,2.012868,0.1788516,2.8476,1.544355,1.353623,0.9150691,1.088575,1.900941,2.427378,2.080354,2.571234,3.025205,1.494862,0.8474523,3.397449,3.725011,1.223244,1.170297,0.988359,1.173763,2.508117,2.464105,2.136946,2.750103,1.668121,1.322039,0.8650851,2.489534,2.698828,3.502244,0.250095,1.000205,0,2.145084,1.526353,1.530172,1.608077,3.711949,2.764278,1.573079,2.344089,1.319563,8.421061,8.370428,8.168173,5.996434,5.492711,7.736308,7.472921,7.109618,6.059621,7.272619,6.386389,9.358904,8.216132,6.883456,7.274243,6.597469,7.451507,7.719365,7.82853,7.010831,6.629571,5.696904,8.47138,8.709534,7.181745,7.651597,7.874881,5.180283,7.389582,7.39358,9.104363,7.788073,8.030388,6.314595,6.284471,6.92032,6.455108,6.693931,10.07903,6.052406,6.547941,6.273793,9.015495,6.843802,6.688754,8.135612,8.278127,7.787435,8.121286,6.647313,6.57576,5.88314,7.573534,6.82816,6.501442,5.541028,5.630992,6.242333,6.637784,7.047946,5.387723,5.769535,6.84407,5.544841,6.088097,5.418275,6.628839,5.745143,6.06581,7.19393,8.422159,7.608887,7.567706,6.45588,6.042687,6.363301,5.654057,6.54818,6.173124,5.894548,7.015129,4.497885,5.980389,7.985848,4.530866,7.411483,6.800674,7.983102,5.224785,5.723938,6.637976,6.672443,8.399891,8.262613,6.365891,8.378346,6.560671,5.398195,6.982623,7.007344, + 3.246744,3.630998,3.891677,3.192905,1.849297,3.822994,2.277155,3.213966,2.986869,2.961625,2.981542,3.382217,2.049149,1.186418,1.73509,5.094141,1.834045,2.502175,5.281001,4.091139,2.051854,3.421803,1.355596,3.076927,3.267807,2.188786,2.512296,2.392467,3.03484,2.261797,2.399192,3.056343,0.9104486,3.995098,3.282723,3.503751,3.323124,2.578353,1.649816,2.984407,3.351175,2.717421,2.665,3.395801,2.759615,2.282056,3.663845,1.824292,2.887951,3.75673,3.656902,5.098365,5.517437,4.850859,3.515253,3.154431,3.062888,3.851178,4.147003,2.323895,4.797698,3.686932,3.391474,1.913784,3.214587,3.737204,4.560255,3.966475,4.71303,5.163349,2.51039,2.992368,5.533905,5.839668,3.366875,3.315225,3.092636,3.318542,4.149617,4.277668,4.26763,4.895184,3.755444,3.183541,1.935806,4.615698,4.843506,5.622258,2.245108,2.527891,2.145084,0,3.670401,3.675113,3.737469,5.495767,4.892301,3.689316,4.208576,3.023935,10.37561,10.42755,10.06496,7.965976,7.506737,9.779551,9.419397,9.091356,7.777566,9.237324,8.248668,11.45073,10.061,8.877139,9.330093,8.700316,9.396876,9.632894,9.849331,8.958151,8.599758,7.790524,10.5751,10.6073,9.200076,9.764156,9.80161,7.240231,9.511717,9.255971,11.13114,9.773669,9.692497,8.330617,8.397841,8.857883,8.529038,8.812872,12.07302,8.19401,8.472094,8.065978,10.98736,8.950565,8.59431,10.22947,10.12445,9.844247,10.19905,8.623562,5.979907,5.101704,6.995869,6.701462,6.681336,5.426873,5.212692,6.449878,6.619603,6.435995,5.563221,5.70566,6.932417,5.766231,5.50447,5.01001,6.288868,6.181815,6.229818,7.150613,8.276972,6.947217,6.991982,6.516537,5.372629,6.244107,5.649822,6.21312,5.750528,5.722693,7.054529,4.391357,5.84194,7.979279,4.749438,6.746674,6.858183,7.632066,5.784452,5.928571,6.256258,6.54823,7.691474,8.697488,6.141806,7.69405,5.992999,5.252733,6.984746,7.111249, + 6.126875,6.610178,6.670982,6.678683,4.533067,6.581078,5.768742,5.808766,6.354479,5.968706,6.095652,6.729673,5.142264,4.842071,4.455036,8.168792,5.102255,4.861938,6.689152,6.483238,4.885329,5.379917,4.829059,6.671609,5.674375,4.444188,4.927999,3.824513,5.75108,5.790398,5.537245,5.779743,4.423647,6.977508,5.160619,6.838497,4.722884,6.135724,4.930856,6.449714,5.90061,5.003898,5.183314,6.874151,5.150302,5.145255,6.544761,4.072963,6.50531,6.61586,1.721703,2.849494,1.84804,1.621942,0.3093373,0.5164563,0.7118641,1.274785,0.5153781,1.348003,1.699351,0.1894754,0.8105136,2.075927,0.5651645,1.287323,0.9206474,1.421284,1.072967,1.534586,2.173656,0.6794786,1.87719,2.232823,0.3378632,0.3579953,0.7232359,0.3535895,1.955776,1.652596,0.6454248,1.228077,0.5022897,1.114497,2.025404,1.061572,1.182124,2.053477,1.445758,1.707156,1.526353,3.670401,0,0.04640422,0.3733483,2.709112,1.314965,0.319186,1.478672,1.499493,7.059537,6.913113,6.864198,4.648717,4.103372,6.29483,6.128431,5.733759,4.982168,5.912174,5.146561,7.868534,6.961243,5.497821,5.823022,5.103264,6.108364,6.404476,6.408072,5.671192,5.271394,4.21572,6.972407,7.398885,5.768322,6.146338,6.545284,3.741656,5.876604,6.13387,7.671756,6.402002,6.952208,4.91181,4.781035,5.591935,4.990314,5.184574,8.671535,4.526388,5.239437,5.110989,7.633489,5.345242,5.397236,6.645791,7.021014,6.332784,6.645945,5.282549,7.299595,6.750896,8.241343,7.243042,6.725348,6.033506,6.305982,6.463675,6.990682,7.758872,5.698662,6.211285,7.11172,5.809761,6.831367,6.103039,7.192918,5.83614,6.330346,7.533371,8.777305,8.326678,8.234552,6.766008,6.838666,6.800561,6.06518,7.113655,6.814934,6.397494,7.307249,5.086312,6.455648,8.263483,4.901708,8.138892,7.092211,8.491403,5.268094,5.98586,7.227797,7.094442,9.118846,8.210814,6.87136,9.083147,7.26845,5.922533,7.302137,7.255029, + 6.110853,6.594817,6.652587,6.673236,4.519201,6.562532,5.764428,5.789565,6.346484,5.954875,6.083291,6.720798,5.131692,4.844667,4.442005,8.153228,5.094601,4.842713,6.65563,6.460168,4.871925,5.354445,4.825947,6.669832,5.653179,4.425592,4.909187,3.80034,5.73359,5.78707,5.526379,5.762281,4.422425,6.96168,5.134947,6.829229,4.693808,6.132937,4.923884,6.443932,5.880627,4.983289,5.164863,6.868328,5.130417,5.131377,6.52802,4.056459,6.504668,6.598689,1.67803,2.893756,1.842329,1.655598,0.3513975,0.5210808,0.6951079,1.228749,0.5318398,1.351484,1.736286,0.1431061,0.7714023,2.09781,0.5448621,1.333709,0.9307247,1.375005,1.057241,1.518283,2.207967,0.6827501,1.880223,2.242843,0.3254031,0.3598897,0.7026696,0.356683,2.001996,1.697376,0.6617291,1.220621,0.5478595,1.155465,2.046916,1.034916,1.172074,2.032088,1.456894,1.683286,1.530172,3.675113,0.04640422,0,0.3269772,2.747861,1.291908,0.3653392,1.52325,1.465422,7.079781,6.925452,6.887957,4.670882,4.12298,6.308947,6.150076,5.753472,5.016297,5.932872,5.174311,7.876532,6.987482,5.516926,5.83629,5.111179,6.130101,6.427784,6.424081,5.693328,5.292526,4.225957,6.979128,7.422115,5.785137,6.152002,6.567688,3.757216,5.880559,6.160183,7.686387,6.420739,6.985382,4.929866,4.78736,5.614791,5.002352,5.189533,8.68811,4.524628,5.263622,5.142027,7.652182,5.352342,5.42227,6.654058,7.047126,6.345546,6.656225,5.303233,7.339869,6.788344,8.282727,7.287232,6.770893,6.076558,6.346686,6.509194,7.035368,7.799483,5.743383,6.254952,7.157055,5.854862,6.871165,6.143505,7.235462,5.882192,6.375566,7.57826,8.822239,8.367317,8.275949,6.810987,6.877537,6.844436,6.109113,7.156161,6.856317,6.440547,7.352448,5.127692,6.499031,8.308898,4.94559,8.179333,7.137382,8.534874,5.314236,6.031024,7.270019,7.138535,9.159627,8.257217,6.914521,9.124143,7.308974,5.965165,7.34714,7.300508, + 6.019614,6.507699,6.543313,6.657112,4.446974,6.452267,5.75778,5.675615,6.312702,5.879784,6.018599,6.680204,5.081704,4.888516,4.376064,8.062983,5.065599,4.730437,6.433644,6.316793,4.802108,5.194768,4.829851,6.679658,5.524774,4.319021,4.7998,3.654164,5.632259,5.787354,5.473441,5.661109,4.440784,6.87072,4.974143,6.785679,4.508114,6.136451,4.900168,6.425754,5.76079,4.860481,5.057564,6.849273,5.012642,5.057511,6.430966,3.966443,6.522712,6.498408,1.381188,3.203577,1.821957,1.899984,0.6670024,0.6640765,0.6757061,0.9080849,0.7165095,1.43188,2.000681,0.1847894,0.5410805,2.28353,0.5229236,1.660663,1.046817,1.050865,0.9887011,1.42798,2.468726,0.7984545,1.920431,2.32604,0.422127,0.5202123,0.6528544,0.5235497,2.326661,2.011895,0.8329841,1.2048,0.8697906,1.458076,2.230775,0.8814856,1.139698,1.894297,1.584111,1.556959,1.608077,3.737469,0.3733483,0.3269772,0,3.02025,1.156738,0.6906829,1.836717,1.258924,7.217527,7.007856,7.050568,4.825507,4.261254,6.404613,6.298675,5.889102,5.253412,6.075136,5.36682,7.927405,7.167418,5.648679,5.926721,5.165511,6.279369,6.587702,6.532859,5.845964,5.438793,4.298893,7.021984,7.58053,5.900464,6.188577,6.721114,3.868711,5.905567,6.34144,7.784102,6.548632,7.21417,5.055401,4.831337,5.772569,5.085781,5.222961,8.798697,4.512514,5.431191,5.357465,7.778494,5.400442,5.595513,6.708195,7.226125,6.431661,6.724496,5.446354,7.631698,7.062499,8.581312,7.602968,7.094287,6.385686,6.641433,6.832457,7.353993,8.093322,6.0623,6.56771,7.479304,6.175896,7.160126,6.436842,7.541342,6.208116,6.697223,7.898008,9.142194,8.661232,8.574614,7.131285,7.160673,7.158352,6.42345,7.461817,7.155143,6.749621,7.673953,5.426973,6.81007,8.631559,5.259804,8.472039,7.458732,8.846235,5.640554,6.352395,7.57393,7.453703,9.45432,8.583821,7.224182,9.420186,7.602368,6.27179,7.667545,7.623539, + 8.470679,8.927546,9.067467,8.688393,6.860073,8.982611,7.770347,8.237663,8.458083,8.256465,8.339021,8.851661,7.360876,6.647261,6.763439,10.46906,7.236534,7.3081,9.369158,8.991461,7.189518,7.946353,6.832643,8.550985,8.150933,6.885464,7.363525,6.387376,8.139387,7.757561,7.752022,8.166822,6.388469,9.30169,7.732759,8.97045,7.353412,8.070695,7.051353,8.477653,8.346501,7.477849,7.605473,8.891219,7.605836,7.454499,8.900342,6.477549,8.348454,8.981643,4.39873,0.7876311,2.527067,1.151878,2.570413,3.004279,3.326401,3.891353,2.324522,3.583953,1.02123,2.87202,3.519251,3.583217,3.218019,1.816662,2.161666,4.007665,2.686134,2.815551,3.04806,3.118926,2.187674,1.92097,2.986047,2.929252,3.363031,2.919549,1.360509,1.251369,2.233558,2.492373,2.252385,2.401389,3.564417,2.951488,2.55768,3.234965,3.491795,4.319211,3.711949,5.495767,2.709112,2.747861,3.02025,0,2.949355,2.429806,1.369464,4.197981,4.926575,5.187546,4.577023,2.593148,2.291314,4.516465,3.9726,3.701914,2.347942,3.816823,2.755848,6.321014,4.565693,3.51778,4.130573,3.80128,3.949158,4.155549,4.521414,3.519542,3.203779,2.942224,5.547843,5.118142,3.887348,4.848955,4.332307,2.273433,4.704657,3.761035,5.787956,4.375337,4.321712,3.053558,3.623762,3.409512,3.466109,4.042255,6.656988,3.88961,3.015781,2.580465,5.552097,4.056472,3.120171,5.159585,4.629064,4.624567,5.049237,3.237838,6.556768,6.354656,7.304226,5.946166,5.165506,5.029262,5.594831,4.930711,5.615122,6.945384,4.431127,5.089254,5.581891,4.444076,6.179632,5.441062,6.164329,4.176399,4.886301,6.081126,7.25617,7.476962,7.296195,5.343878,6.288619,5.59174,4.911466,6.096342,5.973051,5.357363,5.798196,4.43998,5.358065,6.652801,3.908731,7.32306,5.603515,7.247089,3.62649,4.586933,6.242194,5.825536,8.213594,6.125294,5.774285,8.153424,6.498302,4.993887,5.838641,5.678832, + 7.027884,7.520139,7.516031,7.761918,5.495635,7.42365,6.873436,6.645433,7.399923,6.914596,7.067859,7.758352,6.155035,6.03699,5.433821,9.063388,6.162534,5.712146,7.100121,7.219077,5.851346,6.069306,5.956355,7.806611,6.466986,5.315526,5.786037,4.584884,6.625683,6.908663,6.541078,6.654604,5.577757,7.874865,5.848805,7.859898,5.32403,7.259562,6.003073,7.529108,6.718407,5.820777,6.045064,7.950739,5.981101,6.099194,7.426795,4.994026,7.655634,7.488091,1.953283,3.397376,0.8166753,1.836245,1.584411,1.788995,1.829479,1.418769,1.051945,2.587458,2.01701,1.235079,1.556563,3.389712,1.679135,2.279054,0.8786854,1.442045,0.3144464,0.3181503,3.454327,1.939079,1.070754,1.545863,1.553541,1.629526,1.800546,1.62929,2.787468,2.367321,1.019543,0.4575029,1.555037,2.343076,3.338763,0.2769006,0.39313,0.7424205,2.728003,2.594293,2.764278,4.892301,1.314965,1.291908,1.156738,2.949355,0,1.475259,2.208218,2.182275,6.425279,6.072095,6.338694,4.127367,3.526398,5.506035,5.551101,5.107514,4.877648,5.310991,4.792715,6.920406,6.514339,4.859402,5.0206,4.186553,5.534209,5.872839,5.666545,5.118684,4.698553,3.377524,6.004659,6.848963,5.059803,5.165042,5.983199,3.065106,4.863761,5.70497,6.878873,5.734948,6.759701,4.25906,3.835465,5.063638,4.174459,4.201911,7.9193,3.424477,4.762799,4.878612,6.948106,4.405854,4.943765,5.714292,6.568942,5.509587,5.759595,4.69592,8.469362,7.977807,9.378596,8.273895,7.664109,7.123859,7.468641,7.407208,7.994068,8.918868,6.709986,7.274493,8.066708,6.794174,8.013673,7.272445,8.296156,6.722387,7.300909,8.519905,9.754141,9.484403,9.371452,7.751234,8.040274,7.85022,7.1169,8.21863,7.957121,7.485578,8.272006,6.237529,7.529842,9.203929,5.966049,9.30218,8.060769,9.551939,6.146502,6.963843,8.342109,8.131387,10.2709,8.94473,7.952453,10.22938,8.432152,7.029288,8.28196,8.195963, + 6.277171,6.755705,6.835775,6.759356,4.672228,6.746913,5.843148,5.979567,6.452432,6.105162,6.222465,6.832957,5.25897,4.871695,4.589047,8.314304,5.199986,5.034247,6.945977,6.677456,5.020797,5.589936,4.897294,6.727695,5.857798,4.613366,5.097615,4.029179,5.911171,5.858177,5.655172,5.939616,4.480267,7.125663,5.372108,6.944245,4.955217,6.199333,5.024453,6.532903,6.076204,5.184586,5.350263,6.957097,5.326267,5.283277,6.699172,4.22992,6.553938,6.772941,2.033855,2.537187,1.883089,1.383188,0.1794275,0.6221805,0.9116022,1.593951,0.4792477,1.401762,1.436382,0.5083034,1.107542,1.982995,0.7908449,0.9722357,0.8789644,1.740271,1.19406,1.646327,1.979475,0.772007,1.851908,2.154192,0.556642,0.5107364,0.9409813,0.501685,1.636676,1.338309,0.5866061,1.289911,0.1863933,0.8722452,1.935973,1.250878,1.262637,2.191373,1.444221,1.920238,1.573079,3.689316,0.319186,0.3653392,0.6906829,2.429806,1.475259,0,1.165646,1.768332,6.89534,6.802008,6.676923,4.474892,3.948058,6.172469,5.95586,5.574567,4.72924,5.746163,4.934827,7.785848,6.757631,5.343045,5.707049,5.024968,5.935205,6.220592,6.272837,5.495922,5.103391,4.123852,6.899305,7.214676,5.628519,6.081524,6.367244,3.615031,5.823896,5.930464,7.544499,6.248507,6.703992,4.7651,4.71434,5.411976,4.884178,5.126296,8.53054,4.515846,5.051137,4.877816,7.479125,5.27201,5.203089,6.562573,6.818183,6.219516,6.549076,5.117531,7.044735,6.519891,7.976647,6.953147,6.421585,5.754663,6.047898,6.160243,6.69596,7.500974,5.403867,5.926643,6.810244,5.510989,6.580758,5.847109,6.918303,5.52624,6.030213,7.236517,8.479848,8.06836,7.969749,6.46834,6.59584,6.51379,5.778058,6.839411,6.550717,6.11851,7.007188,4.823065,6.173596,7.961,4.615528,7.882315,6.79249,8.208062,4.956949,5.686382,6.956044,6.805528,8.859106,7.893389,6.59123,8.821584,7.011476,5.647583,7.00414,6.951941, + 7.111463,7.572453,7.703642,7.389717,5.499037,7.618241,6.468265,6.870519,7.138016,6.903892,6.99323,7.529496,6.015465,5.381518,5.404041,9.119073,5.904556,5.939392,8.032438,7.621997,5.831905,6.579903,5.523252,7.283177,6.781719,5.516634,5.995283,5.022672,6.775147,6.463157,6.408769,6.802727,5.083065,7.946374,6.367102,7.646731,5.998994,6.785962,5.720774,7.173789,6.978493,6.108506,6.238137,7.59185,6.236983,6.097049,7.540502,5.109811,7.088659,7.620792,3.199196,1.371543,2.187547,0.7550049,1.2706,1.673992,2.0066,2.744479,1.25823,2.214509,0.627422,1.662833,2.270575,2.302947,1.917399,0.47156,1.332827,2.883461,1.895384,2.222049,1.900117,1.773088,1.965943,2.011265,1.698468,1.623964,2.050481,1.613982,0.5814636,0.1758841,1.227797,1.819721,0.9792767,1.046706,2.276021,2.09108,1.848034,2.762133,2.128068,2.975362,2.344089,4.208576,1.478672,1.52325,1.836717,1.369464,2.208218,1.165646,0,2.903124,6.167234,6.265951,5.86993,3.759572,3.324234,5.606492,5.211265,4.885732,3.717248,5.029038,4.066351,7.338312,5.892882,4.675532,5.174273,4.650662,5.188828,5.431392,5.658131,4.74978,4.39255,3.735046,6.49966,6.41263,5.009776,5.72817,5.596832,3.120956,5.521078,5.075949,6.939951,5.568014,5.690992,4.143215,4.394217,4.650338,4.410773,4.822842,7.867154,4.411047,4.266339,3.932951,6.779006,4.908695,4.393665,6.132057,5.955531,5.685835,6.069047,4.417432,6.36728,5.971535,7.237491,6.077133,5.455979,4.959812,5.367069,5.19899,5.791029,6.802458,4.511751,5.093904,5.858544,4.589723,5.93171,5.181419,6.133934,4.518317,5.093977,6.313654,7.546437,7.362332,7.230071,5.545527,5.986849,5.661204,4.931645,6.057986,5.82899,5.31779,6.064114,4.138611,5.353706,6.996106,3.795145,7.187069,5.853174,7.362811,3.942657,4.758145,6.187558,5.936888,8.139507,6.800763,5.778134,8.092692,6.323226,4.877679,6.075158,5.987881, + 4.845678,5.337873,5.340247,5.631685,3.323462,5.248189,4.767346,4.469679,5.249153,4.734788,4.892261,5.598233,3.996349,4.063524,3.267082,6.882342,4.029812,3.532349,5.190285,5.076863,3.678294,3.944741,3.886224,5.720435,4.301525,3.133465,3.605491,2.420469,4.444645,4.81477,4.376533,4.473572,3.550739,5.693081,3.723761,5.696524,3.249318,5.167321,3.880718,5.39774,4.546881,3.646976,3.864533,5.814945,3.804928,3.922452,5.245818,2.815319,5.587937,5.308156,0.6692794,4.259333,2.965213,3.120999,1.6365,1.241248,0.9051188,0.86268,1.964643,1.237177,3.196466,1.360326,0.7178444,2.234005,0.9863255,2.58736,2.304231,0.9540097,2.135889,2.497122,2.748578,1.182667,3.125152,3.557278,1.213131,1.279577,0.8554634,1.289535,3.279953,3.06687,2.086817,2.387347,1.948053,2.1434,2.183322,1.926546,2.310826,2.822891,1.49205,0.4968997,1.319563,3.023935,1.499493,1.465422,1.258924,4.197981,2.182275,1.768332,2.903124,0,8.467256,8.216043,8.308372,6.082396,5.513773,7.626694,7.553209,7.138807,6.481579,7.327522,6.623398,9.09589,8.426215,6.89677,7.145182,6.348639,7.534127,7.845101,7.765443,7.101901,6.69304,5.506815,8.182267,8.837393,7.138675,7.343479,7.976937,5.108945,7.045113,7.600094,9.005705,7.793793,8.450666,6.301044,6.003659,7.029756,6.300279,6.378788,10.03008,5.60403,6.689858,6.603999,9.021705,6.574676,6.854432,7.88462,8.484974,7.644844,7.918009,6.699504,7.892226,7.202152,8.88685,8.098053,7.716924,6.822185,6.941556,7.455452,7.891537,8.364073,6.622456,7.040817,8.074885,6.76694,7.405196,6.729328,7.927315,6.909023,7.291376,8.446525,9.682913,8.925962,8.880928,7.697084,7.361898,7.636402,6.917446,7.846648,7.481251,7.179507,8.253912,5.791435,7.260074,9.224323,5.775164,8.728944,8.038292,9.275613,6.36535,6.946421,7.94038,7.943362,9.717562,9.383928,7.653237,9.695214,7.875991,6.685008,8.228958,8.232906, + 13.17241,13.64989,13.72808,13.55473,11.56551,13.63863,12.63282,12.86777,13.29074,12.99559,13.10504,13.67937,12.13359,11.54513,11.48014,15.20794,12.04731,11.92106,13.52528,13.53329,11.91201,12.41116,11.68594,13.44844,12.73254,11.50238,11.98649,10.87047,12.80523,12.62964,12.52968,12.83376,11.24784,14.02044,12.19032,13.79469,11.70602,12.9532,11.866,13.33708,12.96015,12.06307,12.24097,13.75652,12.20983,12.17545,13.59446,11.12433,13.25148,13.66792,8.369415,5.509877,5.611501,5.566046,7.071976,7.515988,7.770642,7.823629,6.548678,8.264254,5.591687,7.14938,7.754393,8.46614,7.624248,6.638752,6.172795,7.863974,6.371331,6.118539,7.971947,7.667196,5.376035,4.920171,7.395458,7.387215,7.782257,7.379554,6.284932,6.101335,6.41947,6.108983,6.768661,7.201897,8.441262,6.624081,6.190283,6.074295,8.237713,8.759332,8.421061,10.37561,7.059537,7.079781,7.217527,4.926575,6.425279,6.89534,6.167234,8.467256,0,1.282076,0.6304352,2.424641,2.957637,1.220828,0.9567419,1.328513,3.032584,1.149314,2.22535,2.219132,1.053268,1.571431,1.615463,2.581558,0.979606,0.8251252,0.9344545,1.417461,1.792476,3.110323,2.143166,0.627738,1.391817,2.34788,0.6250188,3.367746,2.632006,1.358893,1.138884,0.7010459,2.411864,2.170425,2.923333,1.519891,2.357283,2.801855,1.745903,3.739398,1.911322,2.573654,0.6339045,2.508224,1.813996,1.90823,1.030869,1.367106,1.615691,1.777948,10.51813,10.62891,10.97008,9.39641,8.432561,8.985449,9.717248,8.297704,9.03092,10.78834,8.253811,8.915296,8.790141,8.153981,10.27141,9.626346,9.893215,7.590266,8.384227,9.29267,10.13998,11.21727,10.96168,8.758725,10.45152,9.219689,8.74201,9.848517,9.922169,9.215142,8.987491,8.796335,9.155963,9.500649,8.116309,11.11738,8.866458,10.54302,7.256886,8.219446,10.00509,9.334743,11.80851,8.131397,9.49476,11.72654,10.44148,9.02728,9.085232,8.794441, + 13.02678,13.51384,13.54848,13.5562,11.44372,13.45705,12.63708,12.67928,13.25443,12.8792,13.00868,13.63441,12.0539,11.61235,11.36739,15.07028,12.00192,11.73594,13.10278,13.28559,11.79701,12.13968,11.68872,13.49954,12.51746,11.32639,11.80622,10.63629,12.63995,12.64659,12.44936,12.66881,11.2628,13.878,11.91892,13.74511,11.39523,12.98254,11.82642,13.33134,12.76055,11.85991,12.06438,13.75506,12.0151,12.05575,13.43882,10.97248,13.31506,13.50608,8.019775,5.877013,5.262078,5.580197,6.98143,7.404964,7.619179,7.490806,6.398575,8.202269,5.650128,6.971397,7.52533,8.553205,7.465192,6.726943,5.995181,7.505444,6.080564,5.754639,8.148032,7.564459,5.093733,4.68591,7.250124,7.261181,7.620231,7.254751,6.495651,6.234899,6.268954,5.829263,6.703223,7.251651,8.521407,6.304482,5.90525,5.597389,8.215412,8.564443,8.370428,10.42755,6.913113,6.925452,7.007856,5.187546,6.072095,6.802008,6.265951,8.216043,1.282076,0,1.846116,2.605112,2.944045,0.6714442,1.60783,1.58831,3.761849,1.586998,2.823889,1.187167,2.29517,1.705664,1.097638,1.902895,1.628257,1.780916,0.7480381,1.888706,2.047369,2.71025,0.8613139,1.887091,1.31076,1.228025,1.618423,3.191465,1.56641,2.300246,0.8478545,1.099185,3.619777,2.138463,2.266779,2.015831,1.923368,1.985306,1.911508,2.942754,2.365014,3.271128,1.280828,1.720477,2.374271,0.6673035,2.284518,0.5834969,0.4102906,2.000716,11.2509,11.26652,11.78492,10.23602,9.289003,9.695898,10.39265,9.130259,9.87058,11.55646,8.982537,9.65808,9.666921,8.907212,10.96344,10.28117,10.67761,8.391925,9.191258,10.17952,11.10308,12.01682,11.7765,9.592606,11.12387,10.01621,9.480061,10.62648,10.65019,9.955672,9.87239,9.382573,9.910508,10.45904,8.73767,11.90207,9.734088,11.43408,7.99994,8.992283,10.78284,10.16031,12.64985,9.190478,10.27452,12.57209,11.1783,9.717382,9.960881,9.689292, + 12.93952,13.41111,13.50925,13.25451,11.32745,13.421,12.33416,12.65583,13.00794,12.74982,12.84979,13.3993,11.87409,11.2229,11.23829,14.96577,11.77268,11.71101,13.42542,13.34723,11.66945,12.24034,11.39128,13.127,12.53359,11.28977,11.77391,10.68829,12.58266,12.32543,12.26906,12.61093,10.94954,13.78353,12.0203,13.51634,11.55712,12.64259,11.58945,13.04064,12.75311,11.86095,12.02569,13.45702,12.00319,11.93405,13.36489,10.9021,12.92524,13.441,8.259597,5.104244,5.536582,5.316999,6.850199,7.299048,7.570226,7.710394,6.361488,8.017812,5.32168,6.968016,7.591157,8.151229,7.428845,6.340144,6.004195,7.763117,6.254675,6.041962,7.6221,7.444897,5.272648,4.803647,7.195897,7.178641,7.586727,7.170481,5.936373,5.789277,6.234265,5.990931,6.538751,6.91435,8.129565,6.518052,6.073552,6.055476,7.973356,8.571148,8.168173,10.06496,6.864198,6.887957,7.050568,4.577023,6.338694,6.676923,5.86993,8.308372,0.6304352,1.846116,0,2.227555,2.814863,1.606384,0.8112319,1.291289,2.523971,1.067357,1.822934,2.84558,0.4501339,1.535613,1.881162,2.789986,0.8234001,0.4660031,1.312181,1.220064,1.641106,3.147721,2.700491,0.5427092,1.519927,2.776993,0.3914561,3.28014,3.020034,0.8439592,1.765166,0.9328013,1.789893,2.113067,3.096788,1.280369,2.473219,3.059437,2.240597,3.943153,1.625831,2.09747,1.175109,2.772617,1.479499,2.421226,0.4470887,1.787164,2.127687,1.647443,9.953806,10.09297,10.38321,8.805519,7.839119,8.430878,9.171569,7.710484,8.440584,10.2138,7.695742,8.351324,8.191324,7.588927,9.719455,9.087323,9.315697,7.012978,7.803517,8.690923,9.522751,10.63395,10.37483,8.170294,9.905162,8.640109,8.179842,9.272802,9.360301,8.651133,8.386564,8.282397,8.588067,8.884637,7.593035,10.53801,8.269647,9.939056,6.697778,7.648565,9.429166,8.747436,11.21443,7.503078,8.919184,11.13155,9.876144,8.478807,8.48626,8.191569, + 10.7506,11.227,11.31031,11.13784,9.142418,11.22125,10.21578,10.4523,10.86872,10.57163,10.68044,11.25672,9.708967,9.140994,9.056475,12.78468,9.624032,9.50607,11.20121,11.13075,9.488313,10.0183,9.267949,11.04196,10.32278,9.086256,9.57053,8.469516,10.38605,10.21486,10.10508,10.4145,8.831497,11.59794,9.797981,11.37169,9.330501,10.54118,9.443088,10.91891,10.54671,9.651582,9.824074,11.33927,9.796355,9.751947,11.17351,8.704811,10.84816,11.24767,6.035612,3.271957,3.337186,3.141847,4.650722,5.096453,5.357878,5.48608,4.141957,5.839707,3.172345,4.746897,5.365644,6.062448,5.213878,4.230004,3.778742,5.542218,4.031307,3.838002,5.601567,5.246188,3.057403,2.584652,4.982805,4.970579,5.371943,4.962715,3.926235,3.704999,4.013836,3.767647,4.345433,4.785838,6.035514,4.297534,3.85049,3.903258,5.814007,6.353745,5.996434,7.965976,4.648717,4.670882,4.825507,2.593148,4.127367,4.474892,3.759572,6.082396,2.424641,2.605112,2.227555,0,0.6097664,1.934172,1.481028,1.126313,1.613816,1.276538,0.8611435,3.762573,2.387787,0.9260815,1.593677,1.648114,1.460516,1.763123,1.928373,1.022476,0.6345801,1.294929,3.060111,2.755051,1.297117,2.492766,1.896975,1.119613,2.466701,1.589641,3.199548,1.808482,2.864079,0.538228,1.701072,0.9475673,1.182859,1.981193,4.107602,2.435417,0.6417813,1.235924,3.024256,1.844417,0.8321064,2.661784,2.441841,2.058242,2.507601,0.6578707,8.762485,8.715203,9.368845,7.864413,6.953415,7.202005,7.868107,6.766763,7.504081,9.096128,6.51154,7.191755,7.352385,6.459847,8.446526,7.744374,8.24014,6.004963,6.796312,7.870755,8.900181,9.583105,9.360484,7.223159,8.593157,7.598329,7.011465,8.183179,8.162286,7.484307,7.565799,6.815086,7.452184,8.258493,6.191878,9.454668,7.405844,9.114379,5.557279,6.56326,8.337885,7.772973,10.25608,7.231801,7.836501,10.18376,8.69367,7.207905,7.639915,7.400292, + 10.22332,10.70319,10.77383,10.66018,8.620201,10.68409,9.738672,9.912137,10.37729,10.05315,10.1685,10.76255,9.201427,8.688358,8.537035,12.26196,9.128305,8.965309,10.61098,10.57592,8.968816,9.455874,8.789684,10.5831,9.775133,8.547349,9.03127,7.913165,9.852445,9.742555,9.597789,9.881036,8.357654,11.07262,9.23517,10.87602,8.757812,10.07375,8.949255,10.43849,10.00361,9.106027,9.28631,10.86064,9.253389,9.231332,10.64378,8.172379,10.39419,10.71621,5.445358,3.035345,2.731256,2.657207,4.126004,4.566327,4.814942,4.896416,3.591572,5.331092,2.713495,4.191743,4.799257,5.618815,4.667673,3.78802,3.21567,4.948254,3.44049,3.233784,5.20412,4.719836,2.45842,1.98879,4.439901,4.434353,4.825609,4.426886,3.559676,3.290858,3.462209,3.176781,3.829196,4.323908,5.588601,3.703191,3.259274,3.293629,5.321274,5.801728,5.492711,7.506737,4.103372,4.12298,4.261254,2.291314,3.526398,3.948058,3.324234,5.513773,2.957637,2.944045,2.814863,0.6097664,0,2.282335,2.041007,1.630499,1.968401,1.813939,1.408323,4.044795,2.993806,1.39537,1.859726,1.566317,2.022483,2.348876,2.343005,1.596551,1.181147,0.8957953,3.256638,3.33294,1.693895,2.572368,2.4684,0.5191254,2.462574,2.199374,3.624455,2.300656,3.439995,0.8242872,1.484172,1.537377,1.182961,1.855968,4.586337,2.068287,1.251542,1.692928,3.531773,1.809137,1.441318,2.869505,3.046934,2.366827,2.770626,1.185813,8.690341,8.576872,9.350531,7.885444,7.004968,7.13442,7.76541,6.802759,7.531287,9.04604,6.470383,7.148732,7.412595,6.438926,8.348761,7.6286,8.212702,6.033985,6.811025,7.929799,9.006751,9.55105,9.342249,7.250914,8.479957,7.589856,6.967967,8.151656,8.093882,7.434805,7.628663,6.663409,7.413803,8.370981,6.075691,9.41295,7.457514,9.158412,5.550647,6.55562,8.304113,7.784379,10.24869,7.455585,7.811345,10.18026,8.625238,7.125127,7.693831,7.474552, + 12.41775,12.90302,12.9479,12.9184,10.82789,12.85688,11.9982,12.08014,12.62307,12.26353,12.38887,13.0049,11.42989,10.96319,10.74953,14.4609,11.37126,11.13504,12.57419,12.70239,11.18007,11.56199,11.04936,12.85388,11.92489,10.72283,11.20421,10.04658,12.03516,12.00566,11.82582,12.06397,10.6211,13.2689,11.34098,13.11654,10.82818,12.33987,11.19453,12.69462,12.16425,11.26362,11.46175,13.11788,11.41686,11.44008,12.83244,10.36283,12.6675,12.9012,7.458881,5.206124,4.690886,4.929211,6.351828,6.780484,7.003845,6.923253,5.779517,7.569924,4.993707,6.360413,6.928446,7.898602,6.851188,6.069498,5.380843,6.946041,5.495707,5.190595,7.483982,6.938672,4.501675,4.078609,6.632518,6.639458,7.007281,6.632754,5.82759,5.57203,5.649548,5.240209,6.068193,6.599851,7.867614,5.728978,5.318022,5.072644,7.576101,7.961325,7.736308,9.779551,6.29483,6.308947,6.404613,4.516465,5.506035,6.172469,5.606492,7.626694,1.220828,0.6714442,1.606384,1.934172,2.282335,0,1.106345,0.9587091,3.152659,1.009274,2.202779,1.838894,2.041889,1.0447,0.4862711,1.42715,1.121381,1.382712,0.2970045,1.283628,1.389353,2.128526,1.27686,1.83925,0.6436164,1.170824,1.275445,2.557453,1.423673,1.82866,1.379574,0.6855302,3.266584,1.470169,1.788078,1.406981,1.331576,1.604004,2.41391,2.560494,1.72813,2.662982,1.527627,1.312251,1.760624,0.910181,2.049733,0.1963811,0.655679,1.340163,10.61076,10.61106,11.16231,9.62221,8.681892,9.05349,9.743438,8.516659,9.257444,10.92319,8.34474,9.021988,9.065195,8.274626,10.31632,9.628955,10.04908,7.771864,8.570748,9.579959,10.52935,11.3902,11.15391,8.978403,10.47347,9.39156,8.843288,9.996546,10.00982,9.318674,9.272812,8.722569,9.276478,9.884656,8.082622,11.27211,9.12939,10.83375,7.367143,8.363895,10.15265,9.542808,12.03321,8.667251,9.645498,11.95668,10.53902,9.071366,9.358198,9.093351, + 12.23105,12.7069,12.79133,12.59964,10.62226,12.70227,11.67782,11.93321,12.33791,12.05056,12.15764,12.72704,11.18503,10.58848,10.53582,14.26427,11.09568,10.98692,12.64622,12.60896,10.9676,11.49323,10.73129,12.49187,11.80278,10.56721,11.05147,9.946978,11.86703,11.67409,11.58095,11.89548,10.29273,13.07806,11.2727,12.84266,10.79851,11.99717,10.914,12.38239,12.02739,11.1319,11.30508,12.80153,11.27702,11.23142,12.65421,10.18578,12.29478,12.7285,7.482118,4.569779,4.744304,4.616919,6.131564,6.577469,6.838156,6.933884,5.620331,7.317596,4.638588,6.224051,6.837742,7.509574,6.693578,5.682814,5.252081,6.98185,5.478176,5.250814,7.01645,6.727045,4.489611,4.024899,6.463013,6.451465,6.851654,6.443622,5.329869,5.144654,5.4918,5.214684,5.825544,6.247187,7.484824,5.737636,5.296867,5.250463,7.287038,7.83231,7.472921,9.419397,6.128431,6.150076,6.298675,3.9726,5.551101,5.95586,5.211265,7.553209,0.9567419,1.60783,0.8112319,1.481028,2.041007,1.106345,0,0.4825407,2.198995,0.2570598,1.313315,2.769889,1.126851,0.7244819,1.2069,2.031995,0.02428155,0.3778487,0.879096,0.4624369,0.8602304,2.336761,2.366582,1.298189,0.7718459,2.217601,0.4335548,2.486689,2.400945,0.7223405,1.908946,0.5146908,2.190394,1.306092,2.317021,0.5635468,1.680239,2.32549,2.687244,3.168263,0.956962,1.715301,1.579568,2.050456,0.8771362,2.014438,1.16,1.302433,1.745554,0.8567217,9.714598,9.780066,10.21488,8.656004,7.702788,8.168191,8.88404,7.551183,8.290145,10.00466,7.444781,8.114997,8.075572,7.358198,9.446878,8.783612,9.118097,6.822404,7.62109,8.586126,9.497126,10.4527,10.20646,8.013703,9.617897,8.451122,7.938851,9.069522,9.115386,8.414071,8.279204,7.924082,8.362557,8.853354,7.256512,10.34373,8.145227,9.84059,6.453558,7.435086,9.226157,8.584859,11.07134,7.58874,8.716389,10.99216,9.640026,8.199988,8.370106,8.093618, + 11.85139,12.33026,12.40383,12.26069,10.24649,12.31418,11.33864,11.54249,11.9878,11.67824,11.79077,12.37491,10.82138,10.26701,10.16229,13.88879,10.74143,10.59568,12.20698,12.20513,10.59416,11.08265,10.39043,12.16764,11.40551,10.17754,10.66152,9.542298,11.48195,11.33867,11.21768,11.51051,9.954837,12.70019,10.86181,12.48936,10.37844,11.66582,10.56114,12.0411,11.6341,10.73651,10.91641,12.46192,10.88387,10.85713,12.27251,9.801511,11.97418,12.34534,7.046963,4.347525,4.296516,4.25943,5.751889,6.194149,6.445233,6.500179,5.222069,6.950564,4.295812,5.821829,6.425882,7.188654,6.298145,5.355993,4.844631,6.543378,5.046361,4.803648,6.724659,6.346572,4.052757,3.593995,6.07014,6.063599,6.456091,6.05605,5.045567,4.831019,5.09269,4.78359,5.451452,5.910086,7.161581,5.301405,4.865171,4.785923,6.931402,7.431931,7.109618,9.091356,5.733759,5.753472,5.889102,3.701914,5.107514,5.574567,4.885732,7.138807,1.328513,1.58831,1.291289,1.126313,1.630499,0.9587091,0.4825407,0,2.194112,0.2257329,1.244329,2.775141,1.602015,0.2497984,0.8643769,1.577774,0.4739828,0.8568648,0.853155,0.3397423,0.4983264,1.857143,2.223173,1.757762,0.3927784,1.915837,0.9057033,2.044167,2.04746,1.054603,2.087891,0.6823418,2.56288,0.8486225,1.846119,0.4546681,1.203431,1.886138,2.981709,2.697978,0.7767105,1.704817,1.905956,1.623906,0.8027483,1.838983,1.638116,1.134224,1.608981,0.4685722,9.66318,9.681537,10.20593,8.663986,7.723191,8.107744,8.804818,7.558362,8.299128,9.971132,7.395336,8.071487,8.106598,7.322029,9.37523,8.694363,9.094698,6.814602,7.613657,8.621485,9.576031,10.43514,10.19752,8.0202,9.53633,8.435696,7.893218,9.042774,9.062404,8.368781,8.31435,7.802691,8.32475,8.931275,7.152768,10.31843,8.170689,9.875181,6.414572,7.40933,9.199008,8.585144,11.0755,7.739316,8.691299,10.99876,9.590789,8.129102,8.399549,8.135263, + 10.81067,11.26334,11.41152,10.96523,9.202384,11.32716,10.05403,10.58455,10.75842,10.59023,10.66603,11.15334,9.688708,8.900406,9.104434,12.79866,9.551735,9.655938,11.67106,11.33905,9.528717,10.28858,9.127274,10.79472,10.49887,9.233348,9.711145,8.727892,10.48398,10.03335,10.07725,10.51129,8.681265,11.6375,10.07393,11.27355,9.680547,10.33497,9.365643,10.76076,10.69396,9.825746,9.952531,11.16815,9.953721,9.793387,11.24075,8.824931,10.58448,11.32298,6.598332,2.693417,4.202598,3.360785,4.882859,5.326716,5.638819,6.062761,4.53725,5.931738,3.293043,5.126885,5.779464,5.880141,5.51936,4.161662,4.272087,6.155982,4.689699,4.645898,5.279343,5.449992,3.862507,3.412384,5.283485,5.238051,5.670173,5.228667,3.63631,3.596665,4.425762,4.444331,4.561269,4.745756,5.866673,4.970621,4.524195,4.879339,5.837815,6.642686,6.059621,7.777566,4.982168,5.016297,5.253412,2.347942,4.877648,4.72924,3.717248,6.481579,3.032584,3.761849,2.523971,1.613816,1.968401,3.152659,2.198995,2.194112,0,2.175378,0.9538124,4.945262,2.38011,2.156077,2.979108,3.252426,2.175563,2.207901,3.013889,1.87497,1.829227,2.840933,4.411811,3.028028,2.548526,3.992315,2.409292,2.423947,4.023192,1.686755,4.097232,2.706567,1.977454,2.101782,3.313204,1.748861,2.781134,3.589282,4.755031,4.012245,1.44271,0.4908249,3.657235,3.43147,1.392361,4.021479,2.44369,3.326879,3.802128,1.886943,7.515786,7.598114,8.024385,6.474413,5.530152,5.971022,6.692541,5.368621,6.109093,7.806651,5.246129,5.916002,5.912538,5.159441,7.252094,6.597275,6.922055,4.631028,5.43033,6.427375,7.393219,8.258825,8.015972,5.830896,7.426809,6.2574,5.739893,6.87263,6.916773,6.215085,6.120243,5.765667,6.163809,6.748643,5.083732,8.147476,5.977047,7.68109,4.254569,5.237924,7.029212,6.398516,8.888006,5.637465,6.519796,8.810329,7.441101,6.005784,6.205593,5.941536, + 12.02317,12.50057,12.57954,12.41243,10.41619,12.49017,11.4904,11.71974,12.145,11.84636,11.95621,12.53313,10.98514,10.40995,10.33087,14.05863,10.90054,10.77311,12.40871,12.38897,10.76274,11.2698,10.5429,12.31217,11.58602,10.35415,10.83832,9.72637,11.65639,11.48859,11.38129,11.68489,10.10579,12.87114,11.04911,12.64817,10.57034,11.81378,10.71954,12.19397,11.81263,10.91603,11.09259,12.614,11.06228,11.02616,12.44533,9.975391,12.11691,12.51889,7.246296,4.439384,4.502073,4.418375,5.922726,6.36695,6.622939,6.698701,5.402158,7.115387,4.44736,6.004101,6.613188,7.330671,6.477086,5.500208,5.029298,6.744374,5.243669,5.008966,6.852193,6.51798,4.252461,3.790401,6.247731,6.238658,6.635133,6.230959,5.168533,4.968365,5.27317,4.980464,5.619372,6.059667,7.304736,5.501062,5.062377,5.000577,7.090539,7.613584,7.272619,9.237324,5.912174,5.932872,6.075136,3.816823,5.310991,5.746163,5.029038,7.327522,1.149314,1.586998,1.067357,1.276538,1.813939,1.009274,0.2570598,0.2257329,2.175378,0,1.246431,2.769996,1.377929,0.4685376,1.015861,1.79093,0.2482865,0.6314504,0.838992,0.3141827,0.6432351,2.080366,2.286098,1.543495,0.5548626,2.054413,0.6846696,2.245911,2.211961,0.8766975,1.998921,0.5673238,2.378926,1.057308,2.067323,0.4402835,1.427083,2.092409,2.843778,2.919105,0.8242881,1.684907,1.750053,1.823505,0.7953289,1.915142,1.413208,1.199002,1.664298,0.6296398,9.67652,9.717124,10.19949,8.649126,7.702125,8.124773,8.830986,7.543387,8.283653,9.976152,7.406842,8.080522,8.080759,7.327248,9.398016,8.725233,9.094687,6.806216,7.605544,8.593842,9.528507,10.4328,10.19108,8.005765,9.56385,8.431698,7.903173,9.044316,9.076285,8.37878,8.286682,7.848452,8.331211,8.883992,7.189826,10.31968,8.14747,9.848321,6.420562,7.409703,9.200792,8.573851,11.06315,7.658117,8.691934,10.98526,9.603081,8.151067,8.374572,8.104495, + 11.16295,11.62962,11.74304,11.44012,9.54944,11.6559,10.52074,10.89683,11.20073,10.96419,11.05779,11.59312,10.0805,9.403024,9.457588,13.18039,9.970461,9.955554,11.79258,11.61116,9.887539,10.52282,9.579945,11.30682,10.78667,9.532949,10.01606,8.963284,10.81477,10.51008,10.47434,10.84278,9.137056,12.00298,10.30428,11.71092,9.867103,10.82516,9.786391,11.22771,10.99829,10.11249,10.26495,11.64281,10.2502,10.15258,11.59031,9.137722,11.1042,11.66837,6.644217,3.29203,4.035978,3.556358,5.103167,5.55382,5.840863,6.096148,4.659547,6.241648,3.541229,5.266484,5.906717,6.33501,5.706208,4.53419,4.332803,6.167649,4.658767,4.52199,5.799318,5.693304,3.727531,3.252841,5.470365,5.443173,5.862742,5.434532,4.114154,3.978173,4.536586,4.398625,4.785798,5.112929,6.314474,4.934426,4.481535,4.649552,6.183769,6.849044,6.386389,8.248668,5.146561,5.174311,5.36682,2.755848,4.792715,4.934827,4.066351,6.623398,2.22535,2.823889,1.822934,0.8611435,1.408323,2.202779,1.313315,1.244329,0.9538124,1.246431,0,4.010449,1.829767,1.203949,2.028975,2.389353,1.28907,1.418557,2.078068,0.9365733,0.8854006,2.154916,3.458219,2.362877,1.594718,3.053416,1.607606,1.925839,3.105523,1.009632,3.220672,1.799507,2.034112,1.236645,2.507555,0.8090685,1.917817,2.729874,3.971205,3.280354,0.4913042,0.4726073,2.85924,2.542417,0.4511928,3.067666,1.891743,2.3746,2.849899,0.9436816,8.430701,8.474171,8.962844,7.419662,6.479385,6.878426,7.58516,6.314033,7.0548,8.732866,6.161267,6.835652,6.863898,6.083655,8.151707,7.480618,7.8538,5.57086,6.370029,7.379299,8.346121,9.193379,8.954434,6.77588,8.318243,7.193219,6.658024,7.80259,7.830345,7.133655,7.072224,6.612356,7.087232,7.701468,5.948264,9.078191,6.927276,8.632572,5.176547,6.168445,7.958954,7.341058,9.831359,6.560933,7.450659,9.754526,8.357468,6.904728,7.156556,6.89443, + 13.93602,14.42661,14.43527,14.54284,12.37423,14.34302,13.62835,13.56459,14.22294,13.80586,13.94598,14.59703,13.00445,12.63715,12.30333,15.97643,12.97079,12.62815,13.82518,14.13082,12.72947,12.97528,12.6831,14.51032,13.3872,12.22637,12.70095,11.50528,13.53939,13.64402,13.39779,13.56832,12.26494,14.7856,12.75586,14.70491,12.20907,13.98472,12.79905,14.31515,13.63868,12.7405,12.95994,14.73958,12.89998,12.98431,14.34043,11.88863,14.33221,14.40373,8.83845,7.029542,6.131795,6.62872,7.964409,8.372707,8.563236,8.327936,7.35939,9.186635,6.714858,7.909112,8.42674,9.602051,8.406927,7.790706,6.948187,8.325148,6.96792,6.602935,9.233326,8.534667,6.008247,5.637865,8.201816,8.222863,8.558538,8.217148,7.603683,7.320009,7.231558,6.728292,7.701732,8.295205,9.567617,7.169698,6.799556,6.371014,9.218745,9.474215,9.358904,11.45073,7.868534,7.876532,7.927405,6.321014,6.920406,7.785848,7.338312,9.09589,2.219132,1.187167,2.84558,3.762573,4.044795,1.838894,2.769889,2.775141,4.945262,2.769996,4.010449,0,3.271017,2.883245,2.190472,2.765354,2.791666,2.889744,1.932718,3.074553,3.227275,3.662713,0.9202599,2.707296,2.482261,1.759331,2.706065,4.223517,2.081667,3.431562,1.162265,2.25524,4.630888,3.269594,3.096475,3.201866,2.930085,2.718572,1.77861,3.575684,3.551829,4.454895,1.881796,2.526972,3.560342,1.223353,3.244952,1.70436,1.274177,3.178783,12.43805,12.44919,12.96949,11.41784,10.46834,10.88288,11.57827,10.31224,11.05222,12.74327,10.1697,10.84518,10.84367,10.09404,12.14967,11.46561,11.86371,9.576205,10.37553,11.35501,12.26276,13.20243,12.96107,10.77471,12.3091,11.2015,10.6672,11.81284,11.83732,11.14281,11.048,10.56146,11.09745,11.61956,9.920536,13.08838,10.91221,12.60957,9.186833,10.17848,11.96924,11.34347,13.83237,10.31353,11.46073,13.75415,12.36547,10.90382,11.13798,10.86311, + 12.99271,13.45915,13.57244,13.25383,11.37919,13.4852,12.33603,12.72537,13.02177,12.79333,12.88575,13.41481,11.90817,11.20696,11.28725,15.00942,11.7949,11.78342,13.57421,13.43509,11.71711,12.34088,11.39792,13.10886,12.61304,11.36098,11.84432,10.78325,12.64425,12.32275,12.30164,12.67228,10.954,13.83256,12.12176,13.53309,11.67449,12.63415,11.61044,13.04334,12.8262,11.93906,12.09365,13.45668,12.07768,11.98217,13.42008,10.96675,12.90331,13.49811,8.411812,5.03619,5.724612,5.382736,6.927507,7.377997,7.660454,7.862156,6.4671,8.071333,5.370781,7.074825,7.708427,8.148896,7.523354,6.359206,6.125348,7.92308,6.410634,6.225789,7.591645,7.519176,5.443868,4.969975,7.288306,7.264403,7.680512,7.255906,5.915119,5.800435,6.342042,6.147452,6.611422,6.939578,8.130002,6.679816,6.230485,6.275747,8.012934,8.666935,8.216132,10.061,6.961243,6.987482,7.167418,4.565693,6.514339,6.757631,5.892882,8.426215,1.053268,2.29517,0.4501339,2.387787,2.993806,2.041889,1.126851,1.602015,2.38011,1.377929,1.829767,3.271017,0,1.829606,2.282732,3.155741,1.131325,0.7492043,1.750933,1.447553,1.862352,3.427828,3.150469,0.702806,1.886625,3.212187,0.7781499,3.485011,3.444189,0.8274392,2.161914,1.35958,1.360803,2.367075,3.443807,1.472484,2.805001,3.441118,2.501278,4.295114,1.752147,2.008488,1.514165,3.159867,1.576272,2.870054,0.06401415,2.22665,2.576819,1.881288,9.69255,9.867959,10.089,8.506639,7.537388,8.184918,8.935827,7.419034,8.143066,9.938038,7.44657,8.092867,7.879967,7.330432,9.474873,8.860053,9.036654,6.738129,7.521963,8.373802,9.173823,10.34492,10.08065,7.876201,9.667472,8.358927,7.924161,8.996435,9.103137,8.392125,8.071252,8.08672,8.323786,8.538961,7.388072,10.25491,7.961644,9.616772,6.44965,7.381734,9.152303,8.45432,10.90812,7.121337,8.643489,10.82383,9.613596,8.240695,8.174266,7.872993, + 11.61869,12.09845,12.16866,12.04164,10.01527,12.07884,11.1197,11.30645,11.76486,11.44789,11.56219,12.15121,10.59404,10.05486,9.931805,13.65718,10.5173,10.3596,11.95919,11.96531,10.36362,10.84111,10.1711,11.95397,11.16758,9.941995,10.42582,9.302501,11.24761,11.12108,10.99038,11.27621,9.736703,12.46795,10.62022,12.26524,10.13462,11.44964,10.33752,11.82126,11.39729,10.4992,10.68106,12.24261,10.64719,10.62628,12.03913,9.567676,11.7619,12.11149,6.800153,4.183275,4.04786,4.037633,5.520807,5.961633,6.209553,6.253714,4.985261,6.723182,4.079647,5.583554,6.184677,6.978084,6.061744,5.144689,4.605234,6.295993,4.800536,4.555021,6.526047,6.114924,3.806105,3.348864,5.834619,5.829669,6.219594,5.822217,4.852166,4.625719,4.855686,4.537989,5.22246,5.694245,6.950132,5.054604,4.619415,4.536189,6.708031,7.193718,6.883456,8.877139,5.497821,5.516926,5.648679,3.51778,4.859402,5.343045,4.675532,6.89677,1.571431,1.705664,1.535613,0.9260815,1.39537,1.0447,0.7244819,0.2497984,2.156077,0.4685376,1.203949,2.883245,1.829606,0,0.8261009,1.396401,0.7133977,1.092081,1.004631,0.4438124,0.3452756,1.612305,2.264204,2.007342,0.4045826,1.864469,1.152789,1.797374,1.955223,1.2191,2.273637,0.9054771,2.718449,0.6004246,1.639316,0.5126748,0.9903084,1.718692,3.198635,2.489082,0.713387,1.675848,2.136404,1.473428,0.7994239,1.869911,1.868686,1.196595,1.66802,0.2955426,9.570683,9.566361,10.13389,8.601942,7.668666,8.012489,8.699678,7.497403,8.238035,9.887126,7.30645,7.984565,8.056923,7.239799,9.273184,8.584526,9.016511,6.74738,7.545272,8.573359,9.549293,10.35863,10.12549,7.958225,9.429368,8.362209,7.805489,8.962985,8.969713,8.280615,8.266498,7.678587,8.240315,8.904705,7.037931,10.23818,8.118099,9.825348,6.332593,7.332122,9.118861,8.519326,11.00932,7.752758,8.612714,10.93387,9.49942,8.028749,8.348685,8.09097, + 11.9426,12.4286,12.46986,12.45936,10.35546,12.37871,11.54001,11.60162,12.15932,11.79113,11.91843,12.53995,10.9616,10.51503,10.27804,13.98599,10.907,10.65699,12.08808,12.22003,10.70818,11.07859,10.59155,12.4019,11.44456,10.24561,10.72651,9.56542,11.55845,11.54922,11.3573,11.58727,10.16532,12.79382,10.85761,12.65101,10.34332,11.88499,10.73108,12.23472,11.68492,10.78423,10.98427,12.65835,10.93803,10.96762,12.35633,9.887776,12.21752,12.42457,6.973249,4.844047,4.205791,4.483723,5.886475,6.312046,6.530777,6.438147,5.307984,7.10657,4.55627,5.885358,6.44872,7.457687,6.377502,5.633437,4.906976,6.460267,5.012847,4.704949,7.061298,6.471017,4.020043,3.601378,6.160445,6.169472,6.533168,6.162914,5.41895,5.147219,5.17816,4.758142,5.606666,6.155179,7.425533,5.244637,4.835588,4.58728,7.118147,7.483663,7.274243,9.330093,5.823022,5.83629,5.926721,4.130573,5.0206,5.707049,5.174273,7.145182,1.615463,1.097638,1.881162,1.593677,1.859726,0.4862711,1.2069,0.8643769,2.979108,1.015861,2.028975,2.190472,2.282732,0.8261009,0,0.9695988,1.213006,1.556362,0.6991595,1.199918,1.151734,1.643348,1.470601,2.204533,0.4718294,1.05205,1.506643,2.094364,1.196981,1.892532,1.860863,0.9631841,3.390929,1.082,1.321662,1.303216,0.8464824,1.192413,2.900019,2.124203,1.537747,2.501311,1.994689,0.9001709,1.621669,1.071861,2.302661,0.5141799,0.9201731,1.094876,10.34441,10.30855,10.92884,9.405955,8.478404,8.784318,9.457783,8.302854,9.04295,10.67033,8.086538,8.766094,8.869443,8.027042,10.03495,9.33602,9.806287,7.548653,8.344948,9.386569,10.37161,11.14927,10.92045,8.762647,10.18412,9.156875,8.586309,9.751203,9.743705,9.060482,9.079977,8.408703,9.024294,9.727163,7.784273,11.02515,8.928838,10.63715,7.121178,8.124185,9.90661,9.320448,11.80902,8.577314,9.402379,11.73465,10.27456,8.794106,9.16038,8.906427, + 11.18036,11.66999,11.68837,11.77891,9.612335,11.59644,10.86541,10.81798,11.45761,11.04524,11.1832,11.83173,10.23972,9.886302,9.540389,13.22245,10.20551,9.878177,11.19989,11.40556,9.967293,10.25549,9.921128,11.75224,10.64789,9.473198,9.95,8.76528,10.78701,10.8824,10.63333,10.81593,9.50522,12.03077,10.0351,11.93971,9.503814,11.22419,10.03396,11.55088,10.89538,9.995613,10.2088,11.97533,10.15324,10.22302,11.58755,9.130046,11.57662,11.65236,6.12717,4.569299,3.384433,3.917145,5.203053,5.608187,5.798207,5.603358,4.594661,6.424369,4.023246,5.144383,5.670307,6.873412,5.642026,5.087213,4.18304,5.612553,4.214587,3.868434,6.550202,5.770363,3.245236,2.87371,5.436463,5.457842,5.794009,5.452182,4.979538,4.653161,4.467109,3.970393,4.946099,5.566822,6.836759,4.426836,4.043351,3.694781,6.462248,6.716087,6.597469,8.700316,5.103264,5.111179,5.165511,3.80128,4.186553,5.024968,4.650662,6.348639,2.581558,1.902895,2.789986,1.648114,1.566317,1.42715,2.031995,1.577774,3.252426,1.79093,2.389353,2.765354,3.155741,1.396401,0.9695988,0,2.030147,2.407581,1.667897,1.839851,1.569396,0.917509,1.875011,3.157477,1.271781,1.077561,2.40157,1.548906,0.9040371,2.614816,2.736413,1.909031,4.113951,1.156973,0.3656688,1.895249,0.4729306,0.3405322,3.797949,1.160785,1.945409,2.834543,2.95415,0.2588584,2.102275,1.54337,3.184712,1.374596,1.573309,1.51694,10.25618,10.13071,10.91447,9.440693,8.549381,8.700649,9.328196,8.352612,9.084516,10.61231,8.035862,8.714511,8.953876,8.002155,9.912025,9.189068,9.777434,7.585341,8.367247,9.47196,10.52599,11.11648,10.90617,8.803773,10.04038,9.151669,8.533737,9.716778,9.659986,9.000944,9.168999,8.215421,8.979325,9.886329,7.637443,10.97897,9.002264,10.70708,7.110724,8.116703,9.869466,9.342091,11.81122,8.879753,9.375707,11.7421,10.19128,8.690572,9.237886,9.009683, + 12.21016,12.68588,12.77076,12.57737,10.60123,12.68173,11.65556,11.9128,12.31597,12.02937,12.13626,12.70515,11.16354,10.56578,10.51471,14.24318,11.07388,10.96655,12.62876,12.58918,10.94648,11.47384,10.70909,12.46922,11.78268,10.54677,11.03104,9.927287,11.84637,11.65173,11.55945,11.87481,10.27045,13.05708,11.25332,12.8208,10.7797,11.97469,10.89216,12.36018,12.00709,11.11172,11.28458,12.77927,11.25673,11.21033,12.63339,10.16511,12.27204,12.70775,7.46444,4.545744,4.727853,4.595466,6.110832,6.556867,6.817972,6.916115,5.600469,7.296322,4.616668,6.204353,6.818539,7.486924,6.67352,5.660381,5.232723,6.964454,5.460342,5.234267,6.993208,6.706317,4.47224,4.007131,6.442844,6.431068,6.831595,6.423212,5.306559,5.121936,5.47199,5.196815,5.804605,6.225,7.46223,5.720121,5.279036,5.235899,7.26537,7.812451,7.451507,9.396876,6.108364,6.130101,6.279369,3.949158,5.534209,5.935205,5.188828,7.534127,0.979606,1.628257,0.8234001,1.460516,2.022483,1.121381,0.02428155,0.4739828,2.175563,0.2482865,1.28907,2.791666,1.131325,0.7133977,1.213006,2.030147,0,0.3834443,0.8975345,0.4407284,0.8414397,2.325606,2.383827,1.314791,0.7735605,2.227684,0.4493254,2.470141,2.408087,0.7079416,1.933058,0.5366728,2.181676,1.291689,2.312611,0.5403993,1.674316,2.325552,2.711031,3.164109,0.9334413,1.691617,1.603097,2.051678,0.8528891,2.030174,1.165601,1.317274,1.762445,0.8390292,9.691087,9.756072,10.192,8.633392,7.680381,8.144544,8.860207,7.528522,8.267541,9.981393,7.42125,8.091559,8.053391,7.334839,9.423129,8.759685,9.094968,6.799455,7.598177,8.564053,9.476099,10.42969,10.18359,7.991045,9.59405,8.428102,7.915381,9.046341,9.091846,8.390616,8.257116,7.899922,8.339201,8.83228,7.232451,10.32059,8.122935,9.818535,6.430132,7.411878,9.202973,8.562107,11.04871,7.56974,8.693225,10.96958,9.616542,8.176227,8.347902,8.071662, + 12.4877,12.96056,13.05485,12.81987,10.87638,12.96637,11.89886,12.20011,12.5681,12.30067,12.40281,12.95877,11.42794,10.79513,10.788,14.51617,11.33035,11.25482,12.95954,12.88771,11.2194,11.77886,10.95454,12.69937,12.07579,10.83393,11.31815,10.22791,12.1288,11.89187,11.82326,12.15712,10.51379,13.33266,11.55871,13.07535,11.0935,12.21117,11.14759,12.6048,12.29659,11.40352,11.57043,13.0222,11.54649,11.4838,12.91248,10.44786,12.49928,12.98809,7.793744,4.710547,5.07122,4.865529,6.394534,6.842772,7.11149,7.244579,5.900511,7.567512,4.875073,6.506608,7.128102,7.71984,6.969357,5.902396,5.541109,7.297129,5.788815,5.576422,7.203492,6.989608,4.806657,4.337664,6.736893,6.720963,7.127314,6.712877,5.516057,5.355338,5.772995,5.525072,6.084379,6.473741,7.697089,6.052067,5.607677,5.594072,7.527173,8.11107,7.719365,9.632894,6.404476,6.427784,6.587702,4.155549,5.872839,6.220592,5.431392,7.845101,0.8251252,1.780916,0.4660031,1.763123,2.348876,1.382712,0.3778487,0.8568648,2.207901,0.6314504,1.418557,2.889744,0.7492043,1.092081,1.556362,2.407581,0.3834443,0,1.115068,0.7544663,1.176045,2.701861,2.593919,0.9944662,1.141374,2.533759,0.2019906,2.8154,2.739312,0.5515263,1.915205,0.7091308,1.884256,1.655653,2.694839,0.8155606,2.05767,2.696937,2.562166,3.546001,1.171574,1.749246,1.454438,2.418696,1.03859,2.26822,0.7822774,1.577178,1.984968,1.184013,9.70269,9.805234,10.16893,8.599721,7.639146,8.166544,8.895591,7.498245,8.233903,9.978233,7.436421,8.100178,8.002731,7.339683,9.451368,8.803293,9.08533,6.783434,7.579345,8.508761,9.384507,10.41311,10.16052,7.960065,9.629914,8.413528,7.926141,9.039467,9.105806,8.399936,8.202689,7.97121,8.342673,8.742654,7.291498,10.31034,8.076531,9.761471,6.440349,7.40819,9.196112,8.53472,11.01399,7.425353,8.685762,10.93301,9.626535,8.206481,8.297798,8.012509, + 12.53486,13.01814,13.07278,13.00205,10.93896,12.98218,12.08075,12.20674,12.71534,12.37399,12.49482,13.09933,11.53161,11.03025,10.85851,14.57683,11.46503,11.26057,12.75127,12.84224,11.28976,11.70677,11.13172,12.92589,12.05735,10.84614,11.32868,10.18266,12.15656,12.08524,11.92787,12.1853,10.70032,13.38557,11.48568,13.21207,10.98133,12.41672,11.28686,12.77984,12.29335,11.39323,11.58548,13.20229,11.54464,11.55095,12.95194,10.48053,12.73647,13.02211,7.619534,5.18648,4.849935,5.000202,6.451802,6.885936,7.119097,7.079958,5.892913,7.664658,5.053654,6.481193,7.061652,7.957797,6.968062,6.125017,5.50021,7.10846,5.6419,5.35334,7.520498,7.04235,4.644726,4.209279,6.745918,6.748299,7.12501,6.741294,5.851321,5.614708,5.762841,5.383573,6.161639,6.666071,7.928457,5.881996,5.462709,5.260552,7.661363,8.087458,7.82853,9.849331,6.408072,6.424081,6.532859,4.521414,5.666545,6.272837,5.658131,7.765443,0.9344545,0.7480381,1.312181,1.928373,2.343005,0.2970045,0.879096,0.853155,3.013889,0.838992,2.078068,1.932718,1.750933,1.004631,0.6991595,1.667897,0.8975345,1.115068,0,1.141863,1.333562,2.296706,1.490641,1.546877,0.6492555,1.465189,0.9924021,2.667147,1.720492,1.593111,1.28217,0.4065478,2.997472,1.518805,2.020709,1.269225,1.507991,1.871096,2.265839,2.817568,1.626751,2.52321,1.302168,1.577586,1.62768,1.153404,1.756938,0.475717,0.8734512,1.292351,10.50773,10.53375,11.03736,9.487987,8.541095,8.953963,9.654662,8.382231,9.122544,10.81089,8.238714,8.913552,8.919419,8.161702,10.22394,9.545537,9.930991,7.644247,8.443584,9.432269,10.36107,11.26979,11.02895,8.844583,10.38664,9.268979,8.735792,9.880157,9.907185,9.211424,9.125122,8.655833,9.165299,9.716779,8.005103,11.15568,8.986339,10.6868,7.254614,8.245765,10.03657,9.41239,11.90187,8.466993,9.528024,11.82407,10.43478,8.977408,9.213303,8.942473, + 11.77021,12.24568,12.33165,12.13767,10.16103,12.2427,11.21581,11.47419,11.87551,11.58892,11.6956,12.26461,10.72283,10.12801,10.07435,13.80287,10.63325,10.52807,12.20744,12.15309,10.50611,11.03968,10.26917,12.03118,11.34522,10.10808,10.59236,9.491669,11.40699,11.21233,11.11873,11.43542,9.830758,12.61696,10.81928,12.38022,10.34889,11.53574,10.45157,11.92028,11.56889,10.67395,10.8457,12.33952,10.81855,10.77,12.19362,9.725723,11.83451,12.26812,7.041894,4.131845,4.316755,4.154773,5.671329,6.117727,6.380285,6.492967,5.164249,6.855764,4.176173,5.76888,6.385674,7.0489,6.236354,5.221303,4.799154,6.544242,5.03704,4.821975,6.560285,6.266812,4.053114,3.584997,6.005232,5.992597,6.394419,5.984698,4.874669,4.684399,5.036023,4.773332,5.364605,5.785056,7.023894,5.299269,4.85582,4.843397,6.824656,7.376116,7.010831,8.958151,5.671192,5.693328,5.845964,3.519542,5.118684,5.495922,4.74978,7.101901,1.417461,1.888706,1.220064,1.022476,1.596551,1.283628,0.4624369,0.3397423,1.87497,0.3141827,0.9365733,3.074553,1.447553,0.4438124,1.199918,1.839851,0.4407284,0.7544663,1.141863,0,0.4220926,1.983917,2.555617,1.737127,0.7301791,2.251966,0.8751578,2.061295,2.372129,0.7782529,2.311463,0.8798803,2.274638,0.9197145,2.074124,0.127521,1.424338,2.162397,3.137448,2.920503,0.5128844,1.384194,2.03479,1.914531,0.4858281,2.174588,1.493346,1.465154,1.938014,0.4347644,9.367186,9.40383,9.896305,8.349174,7.404829,7.814479,8.518952,7.243379,7.98393,9.669111,7.097818,7.772209,7.785777,7.019954,9.086607,8.412483,8.789177,6.50347,7.302787,8.299805,9.245823,10.12816,9.887893,7.705576,9.251626,8.127505,7.594597,8.738297,8.766785,8.070228,7.99263,7.534377,8.023641,8.601113,6.876304,10.01383,7.851227,9.553985,6.112941,7.103927,8.894707,8.272424,10.76231,7.400581,8.386184,10.68489,9.294005,7.839751,8.079196,7.812019, + 11.38024,11.85748,11.93741,11.77237,9.77306,11.84812,10.85031,11.0781,11.50314,11.20314,11.31302,11.89102,10.34207,9.774064,9.687668,13.41548,10.25819,10.13156,11.78982,11.75031,10.11954,10.63348,9.902509,11.67546,10.94566,9.712348,10.19656,9.088049,11.01396,10.84925,10.73823,11.04245,9.465976,12.2281,10.4129,12.00592,9.938302,11.17533,10.07735,11.55348,11.17144,10.27527,10.45063,11.97381,10.42107,10.38298,11.80256,9.332878,11.48119,11.87625,6.624792,3.854566,3.895491,3.775779,5.279821,5.724365,5.981771,6.076183,4.762259,6.472197,3.806882,5.365245,5.977695,6.695163,5.836444,4.863284,4.392319,6.125953,4.62027,4.400992,6.227083,5.875132,3.634158,3.167423,5.606568,5.596643,5.994512,5.588901,4.547395,4.335574,4.633506,4.356652,4.976186,5.420194,6.668571,4.881207,4.438986,4.421798,6.448083,6.974099,6.629571,8.599758,5.271394,5.292526,5.438793,3.203779,4.698553,5.103391,4.39255,6.69304,1.792476,2.047369,1.641106,0.6345801,1.181147,1.389353,0.8602304,0.4983264,1.829227,0.6432351,0.8854006,3.227275,1.862352,0.3452756,1.151734,1.569396,0.8414397,1.176045,1.333562,0.4220926,0,1.586342,2.604773,2.152763,0.7497511,2.168038,1.28755,1.639374,2.227153,1.138942,2.584982,1.177415,2.582158,0.5190911,1.753707,0.3949385,1.115943,1.906172,3.474984,2.583298,0.3982297,1.357367,2.389676,1.690867,0.5338017,2.208993,1.910052,1.541632,2.012262,0.0583208,9.225568,9.221976,9.791027,8.261268,7.330096,7.667287,8.354509,7.157143,7.897636,9.542629,6.961613,7.639862,7.719726,6.895623,8.927932,8.239616,8.67275,6.405788,7.203322,8.236556,9.220307,10.01505,9.78263,7.617649,9.084293,8.01922,7.460724,8.619011,8.624597,7.935798,7.929837,7.335447,7.895837,8.575937,6.693419,9.894098,7.780009,9.487835,5.988524,6.988622,8.774834,8.177805,10.66753,7.446082,8.26892,10.59236,9.154362,7.683474,8.011071,7.755519, + 10.31847,10.80623,10.83827,10.88251,8.73969,10.74682,9.966943,9.969033,10.56814,10.17458,10.30743,10.94481,9.357643,8.976836,8.665049,12.36187,9.31544,9.025794,10.45466,10.57936,9.093714,9.436412,9.02108,10.84767,9.807874,8.616652,9.096188,7.927268,9.930363,9.981778,9.752312,9.959235,8.602263,11.1696,9.215475,11.05401,8.699971,10.32213,9.142264,10.65544,10.05041,9.149752,9.354429,11.07978,9.304847,9.351389,10.72957,8.264804,10.67009,10.79645,5.330485,3.722951,2.562454,2.999783,4.302634,4.715198,4.917409,4.794822,3.703501,5.525212,3.107746,4.266696,4.815092,5.957176,4.762388,4.169949,3.295376,4.817874,3.372287,3.062274,5.633978,4.876448,2.383493,1.983114,4.551273,4.567573,4.916362,4.561554,4.075884,3.740843,3.574774,3.119581,4.039194,4.650279,5.920843,3.601627,3.196073,2.969094,5.556177,5.854966,5.696904,7.790524,4.21572,4.225957,4.298893,2.942224,3.377524,4.123852,3.735046,5.506815,3.110323,2.71025,3.147721,1.294929,0.8957953,2.128526,2.336761,1.857143,2.840933,2.080366,2.154916,3.662713,3.427828,1.612305,1.643348,0.917509,2.325606,2.701861,2.296706,1.983917,1.586342,0,2.786497,3.60591,1.719476,1.994533,2.762734,0.6692693,1.79272,2.72425,3.503252,2.409465,4.120763,1.068054,0.6823563,1.980311,0.7969706,1.106634,4.541906,1.174874,1.842399,2.516503,3.59138,1.174401,2.035057,2.439923,3.470743,2.138183,2.430274,1.557327,9.460465,9.294438,10.15523,8.715962,7.852481,7.913352,8.515737,7.643593,8.365851,9.830734,7.269735,7.944082,8.263016,7.250721,9.100705,8.369098,9.014489,6.87395,7.641203,8.778663,9.873215,10.34658,10.14702,8.086478,9.21912,8.404882,7.763718,8.951038,8.868608,8.224849,8.479798,7.378748,8.211165,9.240248,6.824306,10.20241,8.304021,9.998084,6.374538,7.374582,9.101626,8.610021,11.05837,8.349747,8.615721,10.9924,9.398243,7.893267,8.540854,8.330806, + 13.02466,13.5157,13.52047,13.65034,11.46753,13.42814,12.73796,12.64983,13.32489,12.89774,13.04006,13.69713,12.1021,11.76117,11.39785,15.06404,12.0735,11.71459,12.90785,13.21213,11.82302,12.05616,11.79445,13.62688,12.47069,11.31411,11.78772,10.58919,12.62659,12.75585,12.49472,12.65552,11.37954,13.87373,11.83685,13.8042,11.28914,13.09815,11.903,13.42181,12.72302,11.82537,12.04675,13.84627,11.98534,12.07691,13.42773,10.97929,13.45157,13.49042,7.919231,6.282352,5.219955,5.776829,7.077186,7.479532,7.66287,7.410122,6.465895,8.297862,5.873204,7.008032,7.51711,8.742348,7.506163,6.944531,6.05321,7.406146,6.057591,5.687529,8.399226,7.642031,5.10537,4.74661,7.304059,7.328026,7.656696,7.322541,6.794602,6.491257,6.338912,5.820492,6.821106,7.435112,8.706451,6.255743,5.890733,5.45091,8.337227,8.565188,8.47138,10.5751,6.972407,6.979128,7.021984,5.547843,6.004659,6.899305,6.49966,8.182267,2.143166,0.8613139,2.700491,3.060111,3.256638,1.27686,2.366582,2.223173,4.411811,2.286098,3.458219,0.9202599,3.150469,2.264204,1.470601,1.875011,2.383827,2.593919,1.490641,2.555617,2.604773,2.786497,0,2.742843,1.864679,0.840202,2.447676,3.37886,1.162576,3.083672,1.46241,1.888311,4.459952,2.535899,2.192155,2.676568,2.096529,1.803495,2.412437,2.657337,2.973017,3.924936,2.070446,1.627766,3.024864,0.3987694,3.141976,1.090545,0.6226158,2.55006,11.81498,11.77443,12.39464,10.86588,9.93266,10.25491,10.92738,9.761507,10.5021,12.1399,9.556462,10.23585,10.32006,9.495468,11.50498,10.80445,11.2741,9.010546,9.80796,10.83612,11.79911,12.61687,12.38625,10.22221,11.65306,10.62269,10.05616,11.2195,11.21425,10.5305,10.52915,9.871423,10.49361,11.15435,9.251963,12.49388,10.38185,12.08865,8.589096,9.591014,11.37506,10.78257,13.27221,9.943709,10.8702,13.19711,11.74506,10.26453,10.61213,10.35234, + 13.47989,13.95199,14.04835,13.79705,11.86812,13.95996,12.87676,13.19408,13.55064,13.29115,13.39168,13.94198,12.41615,11.76461,11.77924,15.50699,12.31525,12.24892,13.94251,13.88212,12.21049,12.7726,11.93395,13.66864,13.07021,11.82793,12.31213,11.22214,13.12205,12.8679,12.81119,13.15035,11.49217,14.3243,12.55239,14.059,12.08516,13.18481,12.13205,13.58327,13.29079,12.39789,12.56425,13.99958,12.54073,12.47502,13.90502,11.44126,13.46657,13.98089,8.777554,5.63696,6.042493,5.857334,7.388417,7.836853,8.105956,8.228907,6.894618,8.558696,5.863481,7.500509,8.120695,8.693543,7.963789,6.882854,6.533785,8.278451,6.772975,6.548988,8.162082,7.983373,5.786382,5.320185,7.731357,7.715344,8.121752,7.707247,6.476991,6.331881,6.766986,6.509332,7.077754,7.456986,8.671993,7.033844,6.591701,6.543357,8.515341,9.105399,8.709534,10.6073,7.398885,7.422115,7.58053,5.118142,6.848963,7.214676,6.41263,8.837393,0.627738,1.887091,0.5427092,2.755051,3.33294,1.83925,1.298189,1.757762,3.028028,1.543495,2.362877,2.707296,0.702806,2.007342,2.204533,3.157477,1.314791,0.9944662,1.546877,1.737127,2.152763,3.60591,2.742843,0,1.91724,2.975469,0.865813,3.784855,3.256839,1.370377,1.555961,1.248454,1.999324,2.600792,3.486615,1.808134,2.890058,3.396827,1.798482,4.318262,2.164141,2.619267,0.8571022,3.104052,2.021411,2.528217,0.649821,1.992211,2.237446,2.153256,10.39281,10.5596,10.79179,9.20934,8.240007,8.88198,9.630449,8.121823,8.845817,10.64012,8.144213,8.792473,8.581801,8.029921,10.17182,9.55221,9.738957,7.439869,8.224355,9.074818,9.865711,11.0477,10.78344,8.579006,10.36273,9.061344,8.623231,9.698519,9.802646,9.09187,8.77257,8.767142,9.024374,9.232359,8.072046,10.95751,8.663807,10.31673,7.146812,8.082571,9.85444,9.157126,11.61026,7.794126,9.345491,11.52584,10.31406,8.935821,8.875998,8.573848, + 11.89502,12.37743,12.43634,12.35352,10.29701,12.34596,11.43214,11.57131,12.0681,11.73162,11.85096,12.45249,10.88662,10.38103,10.21583,13.93627,10.81816,10.62478,12.15534,12.21427,10.64727,11.08239,10.48312,12.27665,11.42509,10.20936,10.69235,9.553057,11.51863,11.43635,11.28293,11.54734,10.05144,12.74543,10.86132,12.56545,10.3635,11.76765,10.63973,12.13151,11.6592,10.75954,10.94875,12.55385,10.90994,10.90884,12.31304,9.841281,12.08722,12.38382,7.010266,4.567663,4.24361,4.351097,5.807299,6.243006,6.479842,6.467669,5.253547,7.018456,4.404521,5.844852,6.43181,7.308887,6.329594,5.476295,4.863939,6.501403,5.022663,4.749442,6.875332,6.398779,4.024868,3.581464,6.106057,6.106632,6.486851,6.099519,5.209715,4.967789,5.123523,4.762543,5.515506,6.01682,7.279433,5.268034,4.842571,4.686633,7.013365,7.452979,7.181745,9.200076,5.768322,5.785137,5.900464,3.887348,5.059803,5.628519,5.009776,7.138675,1.391817,1.31076,1.519927,1.297117,1.693895,0.6436164,0.7718459,0.3927784,2.548526,0.5548626,1.594718,2.482261,1.886625,0.4045826,0.4718294,1.271781,0.7735605,1.141374,0.6492555,0.7301791,0.7497511,1.719476,1.864679,1.91724,0,1.52306,1.130307,2.031765,1.661045,1.428976,1.931304,0.690809,2.933588,0.869626,1.578748,0.8379124,0.9734366,1.555565,2.903372,2.423303,1.108338,2.063742,1.888683,1.27868,1.16978,1.472969,1.914017,0.7920328,1.264135,0.6986981,9.975263,9.968827,10.53715,9.003449,8.068398,8.417035,9.103605,7.898604,8.639323,10.29151,7.710987,8.389051,8.455404,7.64401,9.677368,8.987902,9.420443,7.149716,7.947867,8.971445,9.939911,10.76243,10.52875,8.359674,9.833071,8.765593,8.21,9.367059,9.374292,8.685145,8.664478,8.079265,8.644693,9.295196,7.440648,10.64232,8.517376,10.22401,6.736748,7.735891,9.522969,8.921544,11.41171,8.121754,9.016671,11.33604,9.904003,8.433082,8.74752,8.487859, + 12.1868,12.67806,12.68102,12.82501,10.63249,12.58866,11.91439,11.8104,12.49554,12.06172,12.20539,12.86644,11.2699,10.94939,10.56362,14.2256,11.24489,10.87569,12.07832,12.37198,10.98811,11.21614,10.97245,12.8085,11.6307,10.47585,10.94897,9.749334,11.78802,11.934,11.66198,11.81695,10.56024,13.03557,10.99679,12.97293,10.44982,12.27746,11.07534,12.5959,11.88328,10.98582,11.20801,13.02031,11.14597,11.24139,12.58918,10.14267,12.63546,12.65159,7.079246,5.605379,4.38257,4.994304,6.258645,6.65561,6.833063,6.569935,5.642414,7.477134,5.100749,6.177937,6.680684,7.94672,6.676107,6.164482,5.228794,6.56607,5.220995,4.848076,7.62776,6.818463,4.274946,3.927334,6.476474,6.502816,6.825758,6.497524,6.051674,5.72968,5.516278,4.985744,6.008713,6.640848,7.90954,5.416939,5.055221,4.612042,7.522639,7.728994,7.651597,9.764156,6.146338,6.152002,6.188577,4.848955,5.165042,6.081524,5.72817,7.343479,2.34788,1.228025,2.776993,2.492766,2.572368,1.170824,2.217601,1.915837,3.992315,2.054413,3.053416,1.759331,3.212187,1.864469,1.05205,1.077561,2.227684,2.533759,1.465189,2.251966,2.168038,1.994533,0.840202,2.975469,1.52306,0,2.441803,2.620252,0.3504607,2.926159,2.047736,1.853411,4.406571,1.954637,1.367203,2.354137,1.389544,0.9659988,3.088285,1.830263,2.564026,3.525321,2.493242,0.8201766,2.663893,0.6183636,3.220541,0.9928328,0.8177948,2.109782,11.23545,11.14622,11.85892,10.35714,9.443762,9.67587,10.32411,9.258984,9.996653,11.57804,8.994554,9.67477,9.840842,8.948052,10.90588,10.19179,10.72799,8.497682,9.288979,10.35904,11.37037,12.07044,11.85057,9.71575,11.04283,10.0893,9.494188,10.67004,10.63654,9.965427,10.05349,9.234114,9.936777,10.72687,8.637724,11.93938,9.895871,11.60477,8.047398,9.053885,10.82426,10.26564,12.74785,9.613329,10.32465,12.67588,11.16825,9.674593,10.12939,9.885236, + 12.63906,13.11336,13.2029,12.98647,11.02881,13.11413,12.06509,12.3464,12.7309,12.45505,12.55939,13.12098,11.58543,10.96631,10.94132,14.66986,11.49127,11.40053,13.07691,13.02769,11.37293,11.91481,11.11987,12.87042,12.21887,10.98022,11.4645,10.36649,12.27766,12.05929,11.98104,12.30605,10.67989,13.48504,11.69442,13.23719,11.22364,12.37996,11.30893,12.77058,12.4417,11.5473,11.71747,13.18865,11.69141,11.63709,13.06309,10.59644,12.67131,13.13807,7.912173,4.897939,5.177133,5.019295,6.542101,6.989277,7.253893,7.363653,6.038925,7.72146,5.033981,6.643806,7.260789,7.88938,7.110419,6.068201,5.674307,7.412751,5.907765,5.683506,7.380248,7.137503,4.920631,4.454778,6.878935,6.865307,7.268468,6.857345,5.692573,5.52408,5.910808,5.644165,6.233872,6.637121,7.865938,6.168224,5.726475,5.683686,7.685359,8.250662,7.874881,9.80161,6.545284,6.567688,6.721114,4.332307,5.983199,6.367244,5.596832,7.976937,0.6250188,1.618423,0.3914561,1.896975,2.4684,1.275445,0.4335548,0.9057033,2.409292,0.6846696,1.607606,2.706065,0.7781499,1.152789,1.506643,2.40157,0.4493254,0.2019906,0.9924021,0.8751578,1.28755,2.762734,2.447676,0.865813,1.130307,2.441803,0,2.919401,2.66702,0.7502824,1.715559,0.5899278,2.013538,1.739341,2.705847,0.9555237,2.081839,2.675791,2.36644,3.552939,1.330685,1.948642,1.256591,2.391018,1.212136,2.136923,0.7960529,1.465262,1.84855,1.287445,9.904515,10.0069,10.36918,8.799295,7.838173,8.368524,9.097529,7.698186,8.433512,10.17959,7.638348,8.301971,8.200805,7.541406,9.653358,9.005086,9.28643,6.984355,7.780041,8.706277,9.576927,10.61378,10.36078,8.159907,9.831854,8.614407,8.127985,9.2407,9.307686,8.601738,8.400337,8.17179,8.544322,8.935494,7.492698,10.51136,8.275023,9.958652,6.642223,7.609633,9.397338,8.734779,11.21331,7.607469,8.886983,11.13218,9.828325,8.408459,8.495893,8.209654, + 9.868066,10.35181,10.40595,10.365,8.273934,10.31542,9.445678,9.540336,10.06626,9.709346,9.832742,10.44768,8.872691,8.425975,8.194501,11.91035,8.814229,8.59397,10.1633,10.18331,8.625416,9.053489,8.497268,10.30968,9.393335,8.179176,8.661861,7.521668,9.489417,9.455169,9.26869,9.518156,8.071512,10.71889,8.83246,10.55919,8.340676,9.791411,8.637834,10.14041,9.627739,8.727951,8.918538,10.56401,8.878648,8.88606,10.28485,7.813567,10.12665,10.35496,5.002858,3.053683,2.257748,2.40522,3.794401,4.223674,4.452298,4.456342,3.226348,5.01315,2.494945,3.814238,4.400604,5.379405,4.301005,3.568618,2.833223,4.499333,3.003601,2.764134,5.020366,4.381497,2.008736,1.553865,4.079519,4.083827,4.457894,4.076989,3.431589,3.113861,3.096275,2.741394,3.512466,4.073268,5.345544,3.257296,2.822587,2.791297,5.023949,5.421525,5.180283,7.240231,3.741656,3.757216,3.868711,2.273433,3.065106,3.615031,3.120956,5.108945,3.367746,3.191465,3.28014,1.119613,0.5191254,2.557453,2.486689,2.044167,2.423947,2.245911,1.925839,4.223517,3.485011,1.797374,2.094364,1.548906,2.470141,2.8154,2.667147,2.061295,1.639374,0.6692693,3.37886,3.784855,2.031765,2.620252,2.919401,0,2.444716,2.70366,3.931307,2.686372,3.958625,1.19738,1.350329,2.016185,1.293473,1.770474,4.932219,1.738172,1.758254,2.189579,3.912819,1.807522,1.950797,3.012049,3.536195,2.608077,2.961382,1.633417,8.794894,8.625169,9.497237,8.068916,7.216242,7.24978,7.847968,7.003131,7.721159,9.1677,6.611476,7.284297,7.628525,6.5966,8.432986,7.700596,8.356033,6.233747,6.994759,8.142628,9.25188,9.685938,9.489046,7.442544,8.550442,7.751205,7.104136,8.291909,8.203937,7.563572,7.845665,6.709486,7.551797,8.622515,6.156777,9.540325,7.666693,9.35532,5.726298,6.723182,8.441914,7.960688,10.40169,7.789197,7.958235,10.33659,8.733142,7.227822,7.903697,7.70089, + 11.89049,12.38234,12.37847,12.55282,10.34384,12.28596,11.64499,11.50806,12.2172,11.77046,11.91719,12.58575,10.98685,10.69536,10.27674,13.9271,10.96809,10.5759,11.74542,12.05995,10.69965,10.90272,10.70554,12.54576,11.32467,10.17854,10.64978,9.444703,11.48937,11.66696,11.37781,11.51829,10.29712,12.73819,10.68378,12.6912,10.13242,12.01187,10.80011,12.32291,11.5791,10.68294,10.90881,12.74714,10.84405,10.95148,12.2905,9.850303,12.37559,12.35183,6.766078,5.473336,4.091433,4.778796,5.999755,6.388637,6.55643,6.261954,5.377324,7.213974,4.894615,5.901375,6.390213,7.712442,6.399163,5.948329,4.962912,6.253964,4.931218,4.548031,7.416955,6.551852,4.000519,3.672271,6.203942,6.234042,6.547089,6.229053,5.868451,5.53152,5.252643,4.700988,5.758143,6.409706,7.673977,5.119578,4.768509,4.293966,7.267485,7.438567,7.389582,9.511717,5.876604,5.880559,5.905567,4.704657,4.863761,5.823896,5.521078,7.045113,2.632006,1.56641,3.020034,2.466701,2.462574,1.423673,2.400945,2.04746,4.023192,2.211961,3.105523,2.081667,3.444189,1.955223,1.196981,0.9040371,2.408087,2.739312,1.720492,2.372129,2.227153,1.79272,1.162576,3.256839,1.661045,0.3504607,2.66702,2.444716,0,3.088532,2.394303,2.087746,4.587791,1.937038,1.127824,2.462603,1.302816,0.7018775,3.437932,1.494818,2.625087,3.572129,2.817854,0.6536029,2.745858,0.9688009,3.457477,1.264918,1.157885,2.1692,11.15184,11.03377,11.79912,10.31402,9.412791,9.59483,10.22782,9.221181,9.955899,11.50406,8.924618,9.604024,9.814162,8.88639,10.81128,10.09006,10.66395,8.456023,9.242275,10.33256,11.36676,12.0045,11.7908,9.674961,10.94141,10.03328,9.423256,10.60422,10.55477,9.891918,10.02827,9.118702,9.867982,10.72486,8.537701,11.8691,9.865567,11.57291,7.991031,8.997726,10.75747,10.21828,12.6932,9.65949,10.26154,12.623,11.08629,9.587199,10.10037,9.864732, + 12.16982,12.63739,12.74781,12.44797,10.55642,12.66041,11.52895,11.89977,12.21008,11.97255,12.06693,12.60256,11.08975,10.40782,10.46504,14.18883,10.98009,10.95741,12.75264,12.60791,10.89524,11.51346,10.58872,12.31114,11.78638,10.53508,11.01855,9.955814,11.8198,11.51762,11.48369,11.84788,10.1456,13.01062,11.29435,12.72041,10.84796,11.83166,10.79601,12.23602,12.00018,11.11249,11.26821,12.65071,11.25147,11.16023,12.59683,10.14168,12.1075,12.67451,7.592486,4.266655,4.922536,4.556474,6.100563,6.550998,6.833034,7.042979,5.640198,7.247644,4.546963,6.24791,6.882374,7.342574,6.695922,5.543813,5.300314,7.106404,5.593823,5.420638,6.799088,6.692548,4.63425,4.159218,6.460867,6.437068,6.853074,6.428581,5.116654,4.987472,5.515335,5.331104,5.78479,6.122492,7.322486,5.864741,5.414186,5.492332,7.192249,7.839499,7.39358,9.255971,6.13387,6.160183,6.34144,3.761035,5.70497,5.930464,5.075949,7.600094,1.358893,2.300246,0.8439592,1.589641,2.199374,1.82866,0.7223405,1.054603,1.686755,0.8766975,1.009632,3.431562,0.8274392,1.2191,1.892532,2.614816,0.7079416,0.5515263,1.593111,0.7782529,1.138942,2.72425,3.083672,1.370377,1.428976,2.926159,0.7502824,2.70366,3.088532,0,2.465825,1.20347,1.50828,1.658014,2.852047,0.7494183,2.202365,2.932921,3.06836,3.697101,0.9478814,1.253515,1.974504,2.676634,0.7615995,2.736058,0.887721,2.024772,2.464462,1.172513,9.159436,9.2743,9.619127,8.049013,7.087996,7.626714,8.359846,6.94797,7.683231,9.431585,6.894919,7.556644,7.451232,6.795504,8.912991,8.270632,8.537639,6.235204,7.030475,7.95724,8.836084,9.864133,9.610726,7.409659,9.094039,7.865139,7.383223,8.492284,8.563333,7.856477,7.651163,7.451418,7.797816,8.193851,6.766403,9.76235,7.525131,9.209984,5.898012,6.862058,8.648901,7.98461,10.46305,6.891429,8.138542,10.38196,9.082893,7.669285,7.746303,7.461032, + 13.79615,14.28101,14.32734,14.28136,12.20469,14.23635,13.36032,13.45967,13.99163,13.64024,13.76403,14.37472,12.80325,12.3123,12.12567,15.83913,12.7406,12.5145,13.93104,14.08087,12.55647,12.93934,12.41128,14.20755,13.30435,12.1021,12.58359,11.42577,13.41425,13.36555,13.19935,13.44305,11.98064,14.64724,12.71837,14.48697,12.20256,13.69762,12.56303,14.05868,13.54383,12.6432,12.84108,14.48139,12.79642,12.81686,14.21128,11.74125,14.01842,14.28025,8.830494,6.432889,6.065056,6.281394,7.723715,8.154854,8.381425,8.297101,7.156381,8.939375,6.335808,7.739066,8.307982,9.239936,8.229132,7.407074,6.759076,8.316925,6.873709,6.562548,8.798837,8.312347,5.880566,5.45807,8.00955,8.015061,8.385433,8.00825,7.12577,6.895236,7.026352,6.618856,7.43661,7.948024,9.210625,7.104879,6.696401,6.424905,8.939727,9.340747,9.104363,11.13114,7.671756,7.686387,7.784102,5.787956,6.878873,7.544499,6.939951,9.005705,1.138884,0.8478545,1.765166,3.199548,3.624455,1.379574,1.908946,2.087891,4.097232,1.998921,3.220672,1.162265,2.161914,2.273637,1.860863,2.736413,1.933058,1.915205,1.28217,2.311463,2.584982,3.503252,1.46241,1.555961,1.931304,2.047736,1.715559,3.931307,2.394303,2.465825,0,1.43171,3.519575,2.80054,3.101826,2.434533,2.706971,2.832386,1.064609,3.790606,2.823201,3.619558,0.7195354,2.564263,2.777252,1.442976,2.128652,1.371816,1.241326,2.550118,11.60935,11.68803,12.08402,10.51481,9.553686,10.06779,10.78878,9.41345,10.14901,11.89011,9.340903,10.00772,9.915562,9.248446,11.34931,10.69045,10.99861,8.697457,9.493887,10.42024,11.27728,12.32766,12.07561,9.87526,11.52291,10.3276,9.832749,10.95214,11.0113,10.30727,10.11452,9.832751,10.2522,10.63745,9.165273,12.22389,9.990208,11.67198,8.346663,9.319709,11.10881,10.44991,12.92887,9.268211,10.59851,12.84772,11.53386,10.1029,10.21067,9.923022, + 12.52393,13.00384,13.07298,12.94234,10.92073,12.98307,12.02031,12.21028,12.6681,12.35337,12.4675,13.05485,11.49908,10.94934,10.83728,14.56259,11.42114,11.26343,12.83378,12.86537,11.2691,11.73853,11.07199,12.84998,12.06989,10.84616,11.32988,10.20279,12.15234,12.02062,11.89541,12.18096,10.63667,13.37327,11.51755,13.16909,11.02694,12.34799,11.2411,12.72254,12.30058,11.4021,11.58532,13.14351,11.55059,11.53175,12.94418,10.47262,12.65651,13.0164,7.682276,5.005413,4.919908,4.939963,6.426283,6.866982,7.113818,7.137782,5.888966,7.628178,4.97784,6.486,7.083326,7.870918,6.965597,6.038319,5.506733,7.17523,5.688178,5.426593,7.404057,7.020371,4.691292,4.240233,6.738996,6.734693,7.123371,6.727271,5.723089,5.512659,5.759276,5.426658,6.127772,6.59222,7.843896,5.937851,5.507454,5.3747,7.611406,8.096022,7.788073,9.773669,6.402002,6.420739,6.548632,4.375337,5.734948,6.248507,5.568014,7.793793,0.7010459,1.099185,0.9328013,1.808482,2.300656,0.6855302,0.5146908,0.6823418,2.706567,0.5673238,1.799507,2.25524,1.35958,0.9054771,0.9631841,1.909031,0.5366728,0.7091308,0.4065478,0.8798803,1.177415,2.409465,1.888311,1.248454,0.690809,1.853411,0.5899278,2.686372,2.087746,1.20347,1.43171,0,2.590925,1.49324,2.240169,1.003688,1.659114,2.154147,2.299373,3.069812,1.39153,2.219737,1.231492,1.86286,1.351343,1.559139,1.370429,0.875835,1.276265,1.150614,10.2199,10.27366,10.72677,9.169288,8.216782,8.67123,9.382792,8.06426,8.803463,10.51322,7.949895,8.621448,8.590042,7.865741,9.94767,9.279632,9.628037,7.333859,8.132767,9.100725,10.01046,10.96361,10.71835,8.526791,10.11623,8.962007,8.444857,9.57897,9.620248,8.920268,8.793789,8.40964,8.870089,9.366835,7.747657,10.85358,8.6595,10.35521,6.960285,7.944324,9.735573,9.097482,11.58454,8.091541,9.226015,11.50554,10.14574,8.700625,8.884541,8.608293, + 12.76788,13.21553,13.37382,12.86668,11.16329,13.29025,11.963,12.55204,12.679,12.54077,12.60987,13.07435,11.63438,10.79117,11.06384,14.74331,11.48665,11.62659,13.64095,13.31269,11.4858,12.26565,11.04693,12.6716,12.47079,11.20436,11.68083,10.70517,12.44741,11.93642,12.02009,12.47452,10.60079,13.58948,12.05116,13.19554,11.6571,12.22856,11.30013,12.66758,12.66293,11.79826,11.92057,13.0692,11.92465,11.74995,13.19826,10.79406,12.45644,13.28161,8.54358,4.595032,6.032094,5.330326,6.859014,7.303618,7.614406,8.002376,6.497725,7.905146,5.268531,7.092916,7.744565,7.813212,7.493361,6.130113,6.214008,8.087813,6.597773,6.504633,7.183105,7.427402,5.709699,5.240526,7.25715,7.213462,7.644952,7.204129,5.579163,5.566283,6.383009,6.344097,6.537335,6.712811,7.802928,6.877638,6.42588,6.667202,7.80565,8.619287,8.030388,9.692497,6.952208,6.985382,7.21417,4.321712,6.759701,6.703992,5.690992,8.450666,2.411864,3.619777,1.789893,2.864079,3.439995,3.266584,2.190394,2.56288,1.977454,2.378926,2.034112,4.630888,1.360803,2.718449,3.390929,4.113951,2.181676,1.884256,2.997472,2.274638,2.582158,4.120763,4.459952,1.999324,2.933588,4.406571,2.013538,3.958625,4.587791,1.50828,3.519575,2.590925,0,3.085958,4.331897,2.222029,3.686004,4.436762,3.741893,5.165446,2.278737,1.881314,2.850757,4.184012,2.087829,4.148499,1.391096,3.461366,3.861598,2.626211,8.618529,8.883768,8.934984,7.349656,6.380161,7.160616,7.931165,6.287496,6.991529,8.827673,6.421687,7.037483,6.697934,6.282662,8.443656,7.877945,7.923426,5.655227,6.413834,7.176001,7.906944,9.201676,8.926735,6.734648,8.652343,7.244988,6.877417,7.889895,8.042991,7.33276,6.879107,7.196827,7.251756,7.280257,6.482296,9.125811,6.786819,8.402577,5.441228,6.312,8.043617,7.311169,9.724142,5.801474,7.540892,9.637045,8.536881,7.236154,6.989046,6.674627, + 11.03659,11.51778,11.58245,11.48427,9.435961,11.49238,10.56281,10.71895,11.20019,10.86985,10.98723,11.58503,10.0215,9.511837,9.353808,13.07667,9.950718,9.772147,11.35878,11.37213,9.785444,10.24573,9.613808,11.40712,10.57719,9.355443,9.838952,8.709564,10.66286,10.56682,10.41785,10.69151,9.181919,11.88651,10.02478,11.69825,9.536605,10.89803,9.771968,11.26243,10.80859,9.909802,10.09473,11.68467,10.05876,10.0475,11.45583,8.983998,11.21789,11.52743,6.1999,3.76209,3.447897,3.481475,4.94355,5.381436,5.623667,5.653631,4.398026,6.152087,3.535812,4.993609,5.590167,6.440721,5.474699,4.608734,4.013895,5.695585,4.200915,3.955026,6.01514,5.536218,3.205985,2.750028,5.249166,5.247002,5.632331,5.239727,4.357538,4.104598,4.268191,3.938566,4.649462,5.147496,6.410953,4.454377,4.019859,3.944377,6.144731,6.603429,6.314595,8.330617,4.91181,4.929866,5.055401,3.053558,4.25906,4.7651,4.143215,6.301044,2.170425,2.138463,2.113067,0.538228,0.8242872,1.470169,1.306092,0.8486225,2.101782,1.057308,1.236645,3.269594,2.367075,0.6004246,1.082,1.156973,1.291689,1.655653,1.518805,0.9197145,0.5190911,1.068054,2.535899,2.600792,0.869626,1.954637,1.739341,1.19738,1.937038,1.658014,2.80054,1.49324,3.085958,0,1.27943,0.9123068,0.6840628,1.496851,3.765724,2.08637,0.8238269,1.67757,2.723557,1.329945,1.003937,2.138949,2.412147,1.571061,2.002082,0.4894441,9.2967,9.239402,9.906757,8.402506,7.490476,7.736268,8.398173,7.304562,8.042062,9.632374,7.047887,7.728148,7.888799,6.997345,8.977506,8.272313,8.777613,6.543045,7.334529,8.407128,9.431143,10.1205,9.898398,7.761151,9.121842,8.136378,7.54778,8.720448,8.696743,8.020289,8.101966,7.335534,7.988942,8.788848,6.718911,9.991527,7.9428,9.651491,6.095144,7.101239,8.875058,8.311189,10.79425,7.737102,8.374026,10.72197,9.22825,7.740442,8.176684,7.935562, + 10.84051,11.33081,11.34391,11.45956,9.277915,11.25183,10.54819,10.47332,11.13277,10.70938,10.84991,11.505,9.910333,9.582809,9.207396,12.88163,9.881482,9.534999,10.83647,11.05413,9.633225,9.902631,9.605769,11.44133,10.30041,9.131713,9.607322,8.417789,10.44516,10.5673,10.30318,10.47408,9.193119,11.69042,9.68242,11.61214,9.148008,10.91053,9.711218,11.23073,10.54937,9.65015,9.866243,11.65518,9.808576,9.887881,11.24602,8.792295,11.26828,11.31002,5.77147,4.403184,3.038447,3.651046,4.891441,5.289349,5.470719,5.250369,4.275926,6.110115,3.76818,4.815909,5.330669,6.588011,5.314027,4.820508,3.86261,5.256874,3.872499,3.517339,6.289324,5.452086,2.913428,2.560148,5.112173,5.137088,5.464691,5.131705,4.750461,4.407032,4.149533,3.631849,4.642474,5.284038,6.550032,4.079265,3.703347,3.3325,6.155725,6.377881,6.284471,8.397841,4.781035,4.78736,4.831337,3.623762,3.835465,4.71434,4.394217,6.003659,2.923333,2.266779,3.096788,1.701072,1.484172,1.788078,2.317021,1.846119,3.313204,2.067323,2.507555,3.096475,3.443807,1.639316,1.321662,0.3656688,2.312611,2.694839,2.020709,2.074124,1.753707,0.6823563,2.192155,3.486615,1.578748,1.367203,2.705847,1.350329,1.127824,2.852047,3.101826,2.240169,4.331897,1.27943,0,2.112268,0.6498262,0.429097,4.163581,0.8518694,2.10075,2.928015,3.3132,0.5710169,2.273849,1.880996,3.476551,1.739968,1.929786,1.707098,10.13148,9.974331,10.8152,9.362861,8.487664,8.581559,9.190816,8.283657,9.010205,10.49777,7.930981,8.607048,8.895908,7.906854,9.77563,9.045836,9.675365,7.514438,8.288056,9.412875,10.49027,11.01011,10.80695,8.730141,9.89627,9.059903,8.426477,9.612824,9.538278,8.889738,9.112114,8.058464,8.87349,9.853919,7.499115,10.868,8.940041,10.6393,7.024447,8.027391,9.76415,9.259685,11.71638,8.905115,9.275458,11.64929,10.06851,8.564322,9.176503,8.958594, + 11.68357,12.158,12.24753,12.03956,10.07343,12.15879,11.11786,11.39132,11.78025,11.5,11.60503,12.16984,10.63147,10.02609,9.986073,13.71463,10.53927,10.44557,12.14587,12.07496,10.41772,10.9645,10.17176,11.92966,11.26474,10.02512,10.5094,9.414472,11.3222,11.11347,11.02719,11.35058,9.732689,12.52962,10.74427,12.28575,10.27802,11.43589,10.35724,11.82277,11.48691,10.59291,10.76224,12.24155,10.73666,10.68183,12.10757,9.640994,11.73221,12.18255,6.980027,4.014227,4.26579,4.064435,5.586705,6.034055,6.299885,6.430697,5.08682,6.766437,4.081606,5.692494,6.312862,6.947425,6.156983,5.121894,4.725891,6.484618,4.975199,4.769698,6.452918,6.182082,3.995748,3.525318,5.925055,5.910603,6.314998,5.902604,4.766413,4.582233,4.959057,4.711458,5.278348,5.6879,6.922952,5.239565,4.794157,4.804929,6.732004,7.298014,6.92032,8.857883,5.591935,5.614791,5.772569,3.409512,5.063638,5.411976,4.650338,7.029756,1.519891,2.015831,1.280369,0.9475673,1.537377,1.406981,0.5635468,0.4546681,1.748861,0.4402835,0.8090685,3.201866,1.472484,0.5126748,1.303216,1.895249,0.5403993,0.8155606,1.269225,0.127521,0.3949385,1.980311,2.676568,1.808134,0.8379124,2.354137,0.9555237,2.016185,2.462603,0.7494183,2.434533,1.003688,2.222029,0.9123068,2.112268,0,1.46457,2.223409,3.248598,2.952841,0.3952942,1.25821,2.142624,1.984224,0.358479,2.293495,1.521871,1.586584,2.060368,0.4239845,9.239665,9.276962,9.769335,8.222756,7.278946,7.686976,8.391648,7.116967,7.85756,9.541693,6.970301,7.644714,7.660379,6.892524,8.959199,8.285373,8.66191,6.376598,7.175903,8.174605,9.123405,10.00099,9.760924,7.579124,9.124365,8.000404,7.467092,8.610975,8.639264,7.942724,7.867434,7.40832,7.896188,8.478667,6.749579,9.886523,7.725555,9.428692,5.98549,6.976638,8.767377,8.145746,10.63571,7.285681,8.258891,10.55838,9.166487,7.712329,7.953705,7.687189, + 11.10395,11.59076,11.62797,11.64227,9.520365,11.53668,10.72446,10.75926,11.33558,10.95584,11.08564,11.71445,10.13187,9.715195,9.444166,13.14745,10.08286,9.815187,11.24742,11.37436,9.873704,10.23237,9.776934,11.59529,10.60047,9.404741,9.885088,8.720688,10.71804,10.73626,10.52716,10.74688,9.353944,11.95518,10.0114,11.82467,9.496875,11.07424,9.908145,11.41647,10.84175,9.941041,10.14307,11.8405,10.09539,10.13239,11.51654,9.049468,11.41402,11.58419,6.127333,4.217378,3.35941,3.698692,5.063509,5.483961,5.695897,5.591782,4.476073,6.285586,3.786063,5.048067,5.60559,6.672657,5.541843,4.861129,4.071946,5.614581,4.167054,3.859065,6.308437,5.643989,3.175427,2.762625,5.327146,5.339192,5.696864,5.332854,4.698112,4.397626,4.346582,3.912987,4.790211,5.366223,6.638596,4.398172,3.990123,3.752682,6.305597,6.642649,6.455108,8.529038,4.990314,5.002352,5.085781,3.466109,4.174459,4.884178,4.410773,6.300279,2.357283,1.923368,2.473219,1.182859,1.182961,1.331576,1.680239,1.203431,2.781134,1.427083,1.917817,2.930085,2.805001,0.9903084,0.8464824,0.4729306,1.674316,2.05767,1.507991,1.424338,1.115943,0.7969706,2.096529,2.890058,0.9734366,1.389544,2.081839,1.293473,1.302816,2.202365,2.706971,1.659114,3.686004,0.6840628,0.6498262,1.46457,0,0.8128668,3.745169,1.498787,1.48109,2.36163,2.808305,0.6636953,1.644556,1.72191,2.839913,1.345924,1.670017,1.066521,9.857016,9.757536,10.49722,9.011375,8.111984,8.298683,8.939678,7.919157,8.653459,10.20552,7.624565,8.304286,8.514335,7.584562,9.522182,8.80549,9.362715,7.153611,7.939493,9.032675,10.07572,10.70377,10.48889,8.372537,9.656717,8.730822,8.123547,9.303351,9.259065,8.593045,8.7288,7.84493,8.567751,9.434965,7.251743,10.56947,8.564828,10.27161,6.688479,7.695222,9.456838,8.915468,11.39072,8.411699,8.960092,11.32037,9.790729,8.29397,8.799883,8.566798, + 11.22136,11.71251,11.71731,11.86276,9.66651,11.62501,10.95327,10.84664,11.53121,11.09575,11.23943,11.90153,10.30448,9.997049,9.597729,13.26056,10.28096,9.911122,11.15162,11.41375,10.02214,10.25923,10.01245,11.85078,10.66863,9.510668,9.984228,8.786753,10.8231,10.97399,10.6964,10.85203,9.6022,12.07032,10.03955,12.0078,9.496961,11.31819,10.1119,11.63333,10.92028,10.02234,10.24326,12.05768,10.18211,10.27539,11.62424,9.17677,11.67941,11.68694,6.123238,4.818727,3.416828,4.078839,5.302648,5.695191,5.868896,5.609991,4.682752,6.518804,4.196985,5.213713,5.714732,7.010634,5.711833,5.247902,4.268633,5.609351,4.255054,3.884547,6.71728,5.858243,3.310991,2.973229,5.513634,5.541532,5.86104,5.536376,5.179038,4.836112,4.557359,4.019854,5.058422,5.707831,6.972229,4.45228,4.089234,3.663829,6.569262,6.763021,6.693931,8.812872,5.184574,5.189533,5.222961,4.042255,4.201911,5.126296,4.822842,6.378788,2.801855,1.985306,3.059437,1.981193,1.855968,1.604004,2.32549,1.886138,3.589282,2.092409,2.729874,2.718572,3.441118,1.718692,1.192413,0.3405322,2.325552,2.696937,1.871096,2.162397,1.906172,1.106634,1.803495,3.396827,1.555565,0.9659988,2.675791,1.770474,0.7018775,2.932921,2.832386,2.154147,4.436762,1.496851,0.429097,2.223409,0.8128668,0,3.896695,0.9645178,2.284797,3.174336,3.12267,0.2936432,2.439659,1.522821,3.466796,1.514144,1.615417,1.852951,10.53302,10.38814,11.2049,9.740937,8.856234,8.98036,9.597498,8.656454,9.386231,10.89481,8.322955,9.000427,9.262299,8.294008,10.18201,9.454775,10.0663,7.88817,8.666674,9.780039,10.84278,11.40334,11.19663,9.105726,10.30566,9.44547,8.81972,10.00468,9.93842,9.284959,9.477885,8.472179,9.266132,10.20414,7.905842,11.26342,9.309006,11.01183,7.406604,8.411445,10.15669,9.640274,12.10393,9.212558,9.665414,12.03578,10.4692,8.966277,9.54501,9.320755, + 14.79833,15.2808,15.33817,15.24021,13.20019,15.24763,14.31824,14.47238,14.96262,14.63462,14.75287,15.34844,13.78715,13.24859,13.11871,16.83964,13.71429,13.52611,14.98524,15.10693,13.55023,13.96981,13.36969,15.14935,14.32314,13.11138,13.59408,12.44801,14.42131,14.31923,14.18351,14.45004,12.93503,15.64878,13.74874,15.46212,13.24,14.64707,13.53492,15.01989,14.55917,13.65906,13.85075,15.44121,13.81039,13.81196,15.21612,12.74445,14.95576,15.28668,9.872379,7.253885,7.103674,7.236224,8.709106,9.145937,9.382942,9.33584,8.156638,9.917293,7.276778,8.746457,9.327214,10.16997,9.232403,8.337591,7.765441,9.359741,7.903581,7.604177,9.69582,9.301316,6.907368,6.474777,9.009304,9.009957,9.389529,9.002826,8.011383,7.810235,8.026592,7.646339,8.414964,8.891295,10.14312,8.140134,7.72498,7.480448,9.905893,10.3532,10.07903,12.07302,8.671535,8.68811,8.798697,6.656988,7.9193,8.53054,7.867154,10.03008,1.745903,1.911508,2.240597,4.107602,4.586337,2.41391,2.687244,2.981709,4.755031,2.843778,3.971205,1.77861,2.501278,3.198635,2.900019,3.797949,2.711031,2.562166,2.265839,3.137448,3.474984,4.541906,2.412437,1.798482,2.903372,3.088285,2.36644,4.932219,3.437932,3.06836,1.064609,2.299373,3.741893,3.765724,4.163581,3.248598,3.745169,3.896695,0,4.853646,3.643503,4.308842,1.112157,3.628769,3.556886,2.472801,2.447781,2.427251,2.296961,3.449774,12.18529,12.33355,12.59028,11.00774,10.03831,10.668,11.41111,9.920183,10.64428,12.43667,9.931684,10.5838,10.37884,9.821175,11.95719,11.32777,11.53605,9.235848,10.0217,10.8704,11.64382,12.84604,12.58193,10.37747,12.14445,10.85872,10.41348,11.49511,11.59357,10.88343,10.56871,10.51943,10.81773,11.01367,9.832342,12.75529,10.4614,12.11024,8.933752,9.87659,11.65114,10.95558,13.40774,9.53809,11.1419,13.3231,12.10697,10.71783,10.67285,10.36919, + 10.44663,10.93942,10.92096,11.16874,8.919988,10.82822,10.27023,10.0516,10.81708,10.33838,10.49234,11.17896,9.576252,9.368382,8.857444,12.47708,9.574157,9.12562,10.25061,10.58512,9.275737,9.426068,9.34001,11.18829,9.860967,8.734198,9.200736,7.985292,10.04071,10.29886,9.963732,10.0696,8.943805,11.29133,9.207913,11.28162,8.650025,10.64723,9.410782,10.93699,10.11887,9.226006,9.459493,11.36009,9.388962,9.52362,10.84116,8.418056,11.02682,10.90013,5.293047,4.676192,2.691751,3.656518,4.685153,5.04281,5.178514,4.800404,4.048921,5.874275,3.807257,4.528591,4.972379,6.466454,5.021337,4.792856,3.638018,4.783797,3.525438,3.114639,6.258979,5.205854,2.663966,2.427269,4.841569,4.88364,5.162981,4.879692,4.845827,4.457268,3.931204,3.314064,4.476238,5.189586,6.423827,3.689569,3.374286,2.816728,5.953669,6.016707,6.052406,8.19401,4.526388,4.524628,4.512514,3.88961,3.424477,4.515846,4.411047,5.60403,3.739398,2.942754,3.943153,2.435417,2.068287,2.560494,3.168263,2.697978,4.012245,2.919105,3.280354,3.575684,4.295114,2.489082,2.124203,1.160785,3.164109,3.546001,2.817568,2.920503,2.583298,1.174874,2.657337,4.318262,2.423303,1.830263,3.552939,1.738172,1.494818,3.697101,3.790606,3.069812,5.165446,2.08637,0.8518694,2.952841,1.498787,0.9645178,4.853646,0,2.908861,3.670142,4.084239,1.250221,3.090212,2.434194,4.327329,2.47789,2.561568,2.539969,10.44623,10.21475,11.18365,9.782063,8.943218,8.91668,9.480712,8.726063,9.438177,10.83394,8.301289,8.967666,9.356751,8.297706,10.06494,9.322703,10.04232,7.957646,8.709902,9.869252,10.98724,11.36245,11.17555,9.160852,10.16679,9.451693,8.788572,9.975987,9.862491,9.240622,9.57407,8.308324,9.236189,10.35913,7.797604,11.21071,9.392382,11.07384,7.440294,8.429999,10.12368,9.66999,12.09138,9.512439,9.648184,12.02885,10.38791,8.883399,9.629408,9.43239, + 11.31625,11.789,11.88422,11.65605,9.704836,11.79585,10.7346,11.03024,11.40035,11.12915,11.23168,11.79055,10.25708,9.638418,9.616422,13.34461,10.16118,10.08529,11.82542,11.72203,10.04783,10.61721,9.789244,11.54231,10.9078,9.664136,10.14831,9.063867,10.95792,10.72913,10.65251,10.98621,9.349392,12.1611,10.39736,11.90685,9.939174,11.05037,9.978709,11.44,11.12734,10.23512,10.40026,11.85819,10.37739,10.31223,11.74115,9.277126,11.34407,11.81688,6.661446,3.619545,3.976504,3.693965,5.224559,5.673279,5.944772,6.111759,4.738265,6.395941,3.704561,5.345345,5.972164,6.560517,5.803848,4.737766,4.386012,6.1714,4.659148,4.475953,6.06063,5.81939,3.692158,3.217978,5.5706,5.552866,5.961665,5.544695,4.37364,4.195063,4.611542,4.395829,4.913619,5.30645,6.536635,4.927817,4.478834,4.544864,6.356485,6.946556,6.547941,8.472094,5.239437,5.263622,5.431191,3.015781,4.762799,5.051137,4.266339,6.689858,1.911322,2.365014,1.625831,0.6417813,1.251542,1.72813,0.956962,0.7767105,1.44271,0.8242881,0.4913042,3.551829,1.752147,0.713387,1.537747,1.945409,0.9334413,1.171574,1.626751,0.5128844,0.3982297,1.842399,2.973017,2.164141,1.108338,2.564026,1.330685,1.758254,2.625087,0.9478814,2.823201,1.39153,2.278737,0.8238269,2.10075,0.3952942,1.48109,2.284797,3.643503,2.908861,0,0.9638517,2.536526,2.08024,0.1956309,2.580668,1.807695,1.894296,2.36908,0.4564295,8.886723,8.907189,9.434443,7.89696,6.960418,7.331079,8.02853,6.791792,7.532573,9.195991,6.619194,7.295681,7.347082,6.547111,8.598645,7.918822,8.321012,6.044803,6.84345,7.863107,8.835913,9.662068,9.426038,7.253142,8.760246,7.663524,7.117273,8.268622,8.285915,7.592794,7.556142,7.031978,7.549425,8.191322,6.378665,9.544226,7.40921,9.115697,5.639616,6.635792,8.424768,7.816218,10.30659,7.049364,7.917465,10.23047,8.81444,7.35245,7.639244,7.379683, + 11.04436,11.50423,11.6355,11.25852,9.431975,11.54972,10.3427,10.7984,11.03587,10.83435,10.91889,11.42985,9.940722,9.205309,9.336912,13.04808,9.81674,9.862636,11.79079,11.53369,9.764439,10.4635,9.408328,11.10568,10.70056,9.439567,9.920518,8.901569,10.70685,10.32683,10.33221,10.73453,8.963359,11.87827,10.2467,11.54898,9.831008,10.63514,9.631449,11.05009,10.90399,10.02626,10.16585,11.46146,10.15918,10.02956,11.47345,9.037177,10.89893,11.5537,6.672376,3.02822,4.157705,3.495258,5.039584,5.488642,5.789184,6.128919,4.642521,6.137158,3.453904,5.243732,5.892455,6.157252,5.661644,4.391795,4.344383,6.211339,4.717435,4.625632,5.586842,5.620524,3.83147,3.364701,5.424925,5.388544,5.815859,5.3795,3.916557,3.828008,4.52457,4.463128,4.718638,4.975855,6.140279,4.997046,4.545015,4.805621,6.060948,6.79805,6.273793,8.065978,5.110989,5.142027,5.357465,2.580465,4.878612,4.877816,3.932951,6.603999,2.573654,3.271128,2.09747,1.235924,1.692928,2.662982,1.715301,1.704817,0.4908249,1.684907,0.4726073,4.454895,2.008488,1.675848,2.501311,2.834543,1.691617,1.749246,2.52321,1.384194,1.357367,2.516503,3.924936,2.619267,2.063742,3.525321,1.948642,2.189579,3.572129,1.253515,3.619558,2.219737,1.881314,1.67757,2.928015,1.25821,2.36163,3.174336,4.308842,3.670142,0.9638517,0,3.203542,2.998411,0.9023623,3.536048,2.072477,2.838428,3.313527,1.415585,8.000334,8.069405,8.514603,6.965233,6.020738,6.452961,7.169617,5.859439,6.599918,8.294342,5.73036,6.401716,6.402508,5.646312,7.731712,7.070981,7.410982,5.121311,5.920638,6.917041,7.87617,8.74839,8.506191,6.321706,7.903638,6.74711,6.225132,7.361153,7.400837,6.700533,6.609886,6.224726,6.650615,7.231455,5.549554,8.636248,6.467404,8.170952,4.740604,5.726423,7.517696,6.889185,9.378762,6.090381,7.008499,9.301126,7.926069,6.484887,6.695712,6.430464, + 13.75508,14.23471,14.30447,14.16192,12.15133,14.21456,13.23986,13.4417,13.89227,13.58357,13.69664,14.2798,12.72734,12.15962,12.06754,15.79339,12.64659,12.49485,14.04146,14.09491,12.49939,12.9663,12.29215,14.06205,13.30074,12.07764,12.56134,11.43258,13.3838,13.23842,13.12363,13.41241,11.85541,14.6043,12.74528,14.39446,12.25086,13.56381,12.46605,13.94313,13.53183,12.63322,12.8168,14.3634,12.7819,12.76219,14.17551,11.70401,13.86649,14.2478,8.898923,6.142337,6.131722,6.164135,7.656727,8.097977,8.345308,8.356314,7.120395,8.856519,6.196492,7.717044,8.312375,9.080308,8.197043,7.250221,6.737451,8.389868,6.91033,6.637161,8.594901,8.251067,5.912653,5.465917,7.970487,7.966033,8.354802,7.958592,6.908826,6.717138,6.990685,6.649709,7.357154,7.809402,9.054565,7.156618,6.730014,6.559077,8.836431,9.326952,9.015495,10.98736,7.633489,7.652182,7.778494,5.552097,6.948106,7.479125,6.779006,9.021705,0.6339045,1.280828,1.175109,3.024256,3.531773,1.527627,1.579568,1.905956,3.657235,1.750053,2.85924,1.881796,1.514165,2.136404,1.994689,2.95415,1.603097,1.454438,1.302168,2.03479,2.389676,3.59138,2.070446,0.8571022,1.888683,2.493242,1.256591,3.912819,2.817854,1.974504,0.7195354,1.231492,2.850757,2.723557,3.3132,2.142624,2.808305,3.12267,1.112157,4.084239,2.536526,3.203542,0,2.834057,2.445546,1.947185,1.472129,1.610675,1.684323,2.369195,11.12398,11.24876,11.5583,9.980568,9.013993,9.596722,10.33295,8.885561,9.615663,11.38715,8.863079,9.521195,9.365191,8.759101,10.8842,10.24486,10.48965,8.186715,8.977955,9.863807,10.68324,11.80882,11.54992,9.345401,11.06701,9.814411,9.348985,10.44637,10.52947,9.821054,9.559774,9.422754,9.75937,10.04693,8.740037,11.71236,9.443977,11.11087,7.865383,8.82071,10.60279,9.922527,12.3891,8.63457,10.0927,12.30609,11.04668,9.641595,9.660058,9.364075, + 11.41114,11.90134,11.91492,12.02275,9.84731,11.82285,11.1102,11.04434,11.69863,11.27919,11.419,12.07169,10.47806,10.13629,9.776358,13.45241,10.44693,10.10597,11.3927,11.62409,10.20253,10.47207,10.1667,11.9997,10.87127,9.702546,10.17827,8.988661,11.01604,11.12812,10.8712,11.04496,9.75212,12.26113,10.25194,12.17919,9.715818,11.47054,10.27605,11.79432,11.12035,10.22116,10.43718,12.21878,10.37959,10.45749,11.81687,9.362514,11.82503,11.88095,6.339604,4.82246,3.609463,4.17414,5.449749,5.851875,6.037434,5.819991,4.83823,6.670169,4.281297,5.38296,5.901152,7.127842,5.88094,5.344337,4.425723,5.825085,4.443281,4.087762,6.80804,6.014331,3.481412,3.118905,5.677422,5.700601,6.032151,5.695074,5.238359,4.91178,4.711176,4.201991,5.195569,5.821611,7.090915,4.650208,4.273794,3.893478,6.710982,6.94813,6.843802,8.950565,5.345242,5.352342,5.400442,4.056472,4.405854,5.27201,4.908695,6.574676,2.508224,1.720477,2.772617,1.844417,1.809137,1.312251,2.050456,1.623906,3.43147,1.823505,2.542417,2.526972,3.159867,1.473428,0.9001709,0.2588584,2.051678,2.418696,1.577586,1.914531,1.690867,1.174401,1.627766,3.104052,1.27868,0.8201766,2.391018,1.807522,0.6536029,2.676634,2.564263,1.86286,4.184012,1.329945,0.5710169,1.984224,0.6636953,0.2936432,3.628769,1.250221,2.08024,2.998411,2.834057,0,2.223606,1.310007,3.184086,1.228841,1.367154,1.635308,10.49895,10.38074,11.15002,9.669844,8.773334,8.942305,9.574243,8.579173,9.31261,10.85231,8.27383,8.952992,9.17632,8.237332,10.15774,9.436471,10.01407,7.812923,8.597229,9.694611,10.73941,11.35409,11.14171,9.031742,10.28783,9.385375,8.772215,9.953983,9.902099,9.240391,9.390967,8.465857,9.217267,10.09866,7.884099,11.21792,9.226211,10.93244,7.343538,8.350007,10.10703,9.572773,12.04525,9.066945,9.611914,11.97551,10.43356,8.934069,9.461446,9.229585, + 11.46083,11.93195,12.03221,11.78152,9.848508,11.94416,10.86059,11.18016,11.53111,11.27039,11.37033,11.92207,10.39474,9.756779,9.759103,13.4864,10.29451,10.23598,11.99798,11.87778,10.1902,10.77669,9.916549,11.66101,11.06085,9.814351,10.29835,9.221558,11.10522,10.85338,10.78978,11.13345,9.475588,12.30447,10.55711,12.03887,10.10353,11.17258,10.1115,11.56664,11.27841,10.38767,10.54955,11.98387,10.5288,10.45483,11.88649,9.425075,11.46117,11.96287,6.835667,3.697006,4.161028,3.838744,5.375368,5.824913,6.100431,6.286029,4.898889,6.538729,3.842188,5.506436,6.136593,6.681256,5.96092,4.864477,4.551807,6.347764,4.835188,4.659046,6.168135,5.969426,3.873016,3.39815,5.726899,5.706857,6.11853,5.698564,4.480466,4.316783,4.772887,4.572191,5.062502,5.436872,6.658505,5.105228,4.655251,4.734904,6.493947,7.104262,6.688754,8.59431,5.397236,5.42227,5.595513,3.120171,4.943765,5.203089,4.393665,6.854432,1.813996,2.374271,1.479499,0.8321064,1.441318,1.760624,0.8771362,0.8027483,1.392361,0.7953289,0.4511928,3.560342,1.576272,0.7994239,1.621669,2.102275,0.8528891,1.03859,1.62768,0.4858281,0.5338017,2.035057,3.024864,2.021411,1.16978,2.663893,1.212136,1.950797,2.745858,0.7615995,2.777252,1.351343,2.087829,1.003937,2.273849,0.358479,1.644556,2.439659,3.556886,3.090212,0.1956309,0.9023623,2.445546,2.223606,0,2.638183,1.633387,1.936851,2.41172,0.5884364,8.881828,8.92339,9.41106,7.865252,6.922404,7.329616,8.035828,6.759486,7.500138,9.183288,6.612332,7.286532,7.304777,6.53414,8.602693,7.930636,8.303432,6.018446,6.817732,7.81939,8.774354,9.642548,9.402649,7.221571,8.768788,7.642011,7.108981,8.2525,8.281495,7.584608,7.512237,7.058387,7.537851,8.129594,6.39677,9.528045,7.369407,9.073262,5.627149,6.618159,8.408903,7.787845,10.27791,6.955737,7.900412,10.2007,8.808549,7.35574,7.597908,7.332765, + 12.72082,13.21087,13.22486,13.31952,11.15515,13.13277,12.405,12.35426,13.00027,12.58766,12.72629,13.37479,11.78308,11.41587,11.08351,14.76227,11.748,11.41598,12.67057,12.93113,11.5102,11.77795,11.4598,13.28757,12.18055,11.01246,11.48827,10.29801,12.326,12.42075,12.1767,12.35492,11.04188,13.57091,11.55802,13.4829,11.01821,12.76157,11.57607,13.09186,12.43005,11.53097,11.74718,13.51629,11.68952,11.76565,13.12681,10.67164,13.10994,13.19094,7.643295,5.88998,4.919419,5.415422,6.741104,7.14952,7.341524,7.126716,6.136289,7.963295,5.506719,6.687752,7.210707,8.386047,7.185375,6.580598,5.72533,7.129066,5.753177,5.396306,8.030224,7.311429,4.788195,4.414672,6.979391,6.999879,7.337377,6.994132,6.416058,6.119495,6.008376,5.511221,6.479116,7.078804,8.351008,5.959844,5.583362,5.186629,7.996099,8.257354,8.135612,10.22947,6.645791,6.654058,6.708195,5.159585,5.714292,6.562573,6.132057,7.88462,1.90823,0.6673035,2.421226,2.661784,2.869505,0.910181,2.014438,1.838983,4.021479,1.915142,3.067666,1.223353,2.870054,1.869911,1.071861,1.54337,2.030174,2.26822,1.153404,2.174588,2.208993,2.439923,0.3987694,2.528217,1.472969,0.6183636,2.136923,3.012049,0.9688009,2.736058,1.442976,1.559139,4.148499,2.138949,1.880996,2.293495,1.72191,1.522821,2.472801,2.434194,2.580668,3.536048,1.947185,1.310007,2.638183,0,2.867643,0.716636,0.2943361,2.153891,11.41627,11.37652,11.9974,10.47021,9.538442,9.856179,10.52873,9.366137,10.10662,11.74156,9.157998,9.837439,9.926809,9.097457,11.10626,10.40602,10.87628,8.614298,9.411441,10.44318,11.41193,12.21912,11.98901,9.826616,11.25453,10.22543,9.657721,10.82154,10.81555,10.13201,10.13628,9.47416,10.09534,10.76718,8.85366,12.0958,9.98798,11.69526,8.19122,9.193456,10.97705,10.38631,12.87571,9.571641,10.47237,12.80081,11.34638,9.865766,10.2186,9.9603, + 13.05467,13.5213,13.63404,13.31727,11.44117,13.54676,12.39941,12.78669,13.0849,12.85562,12.94828,13.4779,11.97074,11.27064,11.34932,15.07175,11.8578,11.84461,13.63128,13.49563,11.77924,12.40077,11.46119,13.17258,12.67394,11.4222,11.90559,10.84336,12.70589,12.38622,12.36426,12.73394,11.01731,13.89469,12.1816,13.59616,11.73344,12.69772,11.67337,13.10672,12.88738,12.00001,12.15503,13.52012,12.13879,12.04429,13.48197,11.02823,12.96708,13.55994,8.468376,5.1002,5.778063,5.443794,6.98823,7.438684,7.720629,7.918702,6.526362,8.133118,5.432505,7.134088,7.76716,8.212277,7.583306,6.422,6.183675,7.979047,6.466708,6.279684,7.655453,7.580083,5.498625,5.024997,7.348343,7.324763,7.740513,7.316281,5.978753,5.863399,6.40117,6.203446,6.672323,7.002234,8.193327,6.735506,6.286461,6.326373,8.075205,8.726904,8.278127,10.12445,7.021014,7.047126,7.226125,4.629064,6.568942,6.818183,5.955531,8.484974,1.030869,2.284518,0.4470887,2.441841,3.046934,2.049733,1.16,1.638116,2.44369,1.413208,1.891743,3.244952,0.06401415,1.868686,2.302661,3.184712,1.165601,0.7822774,1.756938,1.493346,1.910052,3.470743,3.141976,0.649821,1.914017,3.220541,0.7960529,3.536195,3.457477,0.887721,2.128652,1.370429,1.391096,2.412147,3.476551,1.521871,2.839913,3.466796,2.447781,4.327329,1.807695,2.072477,1.472129,3.184086,1.633387,2.867643,0,2.232429,2.57389,1.927721,9.749327,9.927315,10.14272,8.559986,7.590526,8.242976,8.994544,7.47326,8.196591,9.993552,7.504459,8.149986,7.931982,7.387619,9.532942,8.919326,9.09193,6.794012,7.57714,8.42508,9.220642,10.39914,10.13438,7.93011,9.726013,8.414058,7.981513,9.051958,9.160281,8.449174,8.122779,8.147783,8.380412,8.586337,7.448722,10.30973,8.014038,9.667304,6.507726,7.438236,9.20777,8.508274,10.96048,7.162441,8.699101,10.87604,9.670272,8.299301,8.226177,7.924144, + 12.44944,12.936,12.97386,12.97295,10.86439,12.88256,12.05374,12.1051,12.67193,12.29999,12.42843,13.05221,11.47268,11.02914,10.78754,14.49293,11.4195,11.1611,12.5599,12.71738,11.21742,11.5736,11.10534,12.91607,11.9456,10.75065,11.23101,10.06531,12.0639,12.06315,11.86826,12.09275,10.67932,13.30068,11.35272,13.16307,10.83361,12.39905,11.24381,12.74819,12.18736,11.28666,11.48899,13.17186,11.44118,11.4765,12.86231,10.39483,12.73169,12.93005,7.460251,5.326249,4.696973,4.997487,6.398943,6.823381,7.039659,6.928197,5.817994,7.61948,5.068838,6.392925,6.951316,7.971068,6.885992,6.145878,5.415643,6.946434,5.510462,5.192838,7.570607,6.982646,4.520601,4.107826,6.669999,6.680136,7.041329,6.673648,5.923241,5.656855,5.688275,5.257516,6.120068,6.668958,7.939067,5.738129,5.334198,5.0541,7.631999,7.988551,7.787435,9.844247,6.332784,6.345546,6.431661,4.624567,5.509587,6.219516,5.685835,7.644844,1.367106,0.5834969,1.787164,2.058242,2.366827,0.1963811,1.302433,1.134224,3.326879,1.199002,2.3746,1.70436,2.22665,1.196595,0.5141799,1.374596,1.317274,1.577178,0.475717,1.465154,1.541632,2.138183,1.090545,1.992211,0.7920328,0.9928328,1.465262,2.608077,1.264918,2.024772,1.371816,0.875835,3.461366,1.571061,1.739968,1.586584,1.345924,1.514144,2.427251,2.47789,1.894296,2.838428,1.610675,1.228841,1.936851,0.716636,2.232429,0,0.4753011,1.489897,10.7672,10.75621,11.32754,9.791229,8.853509,9.208833,9.893948,8.685999,9.426789,11.08342,8.503018,9.181055,9.238497,8.435737,10.46826,9.777122,10.2118,7.938867,8.73735,9.753836,10.70989,11.5536,11.31914,9.147408,10.62293,9.556196,9.00202,10.1586,10.16623,9.477174,9.446744,8.863409,9.436599,10.06515,8.228672,11.43394,9.301717,11.00717,7.528416,8.527052,10.31455,9.710418,12.20076,8.856702,9.808064,12.12473,10.69599,9.224324,9.531135,9.268414, + 12.7433,13.23198,13.25636,13.30836,11.16849,13.16458,12.39139,12.38625,12.99739,12.60292,12.73707,13.37464,11.78791,11.38521,11.09451,14.78624,11.74463,11.44513,12.75966,12.97839,11.52279,11.82871,11.44437,13.26473,12.21856,11.03842,11.51642,10.33612,12.35238,12.40419,12.18256,12.38128,11.0225,13.59416,11.60829,13.48403,11.07683,12.74281,11.57091,13.08197,12.46485,11.56472,11.77503,13.50617,11.7216,11.77996,13.15242,10.6909,13.08386,13.21814,7.700169,5.764171,4.955652,5.365286,6.728225,7.14435,7.347408,7.176643,6.133408,7.950835,5.447027,6.696018,7.235017,8.340313,7.192197,6.523753,5.725648,7.185546,5.782599,5.441508,7.962077,7.305228,4.804964,4.413384,6.981546,6.997428,7.345832,6.991342,6.329592,6.048248,6.004501,5.53552,6.458186,7.034558,8.306728,5.99848,5.609734,5.260157,7.974298,8.278585,8.121286,10.19905,6.645945,6.656225,6.724496,5.049237,5.759595,6.549076,6.069047,7.918009,1.615691,0.4102906,2.127687,2.507601,2.770626,0.655679,1.745554,1.608981,3.802128,1.664298,2.849899,1.274177,2.576819,1.66802,0.9201731,1.573309,1.762445,1.984968,0.8734512,1.938014,2.012262,2.430274,0.6226158,2.237446,1.264135,0.8177948,1.84855,2.961382,1.157885,2.464462,1.241326,1.276265,3.861598,2.002082,1.929786,2.060368,1.670017,1.615417,2.296961,2.561568,2.36908,3.313527,1.684323,1.367154,2.41172,0.2943361,2.57389,0.4753011,0,1.959483,11.23654,11.21721,11.80121,10.26602,9.328715,9.677613,10.35933,9.160872,9.901653,11.55489,8.9736,9.652017,9.713797,8.907785,10.93463,10.24073,10.6845,8.413197,9.211539,10.22913,11.1837,12.02654,11.7928,9.622207,11.08745,10.0297,9.472813,10.63101,10.63559,9.947807,9.922042,9.320924,9.908099,10.53898,8.690817,11.9062,9.776978,11.48247,8.000604,9.000009,10.78688,10.18487,12.67516,9.321304,10.28071,12.59926,11.16566,9.691529,10.00643,9.743656, + 11.39468,11.87251,11.95024,11.79421,9.788286,11.86083,10.87215,11.09025,11.52309,11.21902,11.32994,11.91061,10.35961,9.798825,9.703337,13.43074,10.27746,10.14359,11.78975,11.75957,10.13522,10.64111,9.924112,11.69968,10.95638,9.724714,10.20886,9.097041,11.02729,10.87171,10.75584,11.05581,9.488101,12.24289,10.42046,12.0253,9.943529,11.19844,10.09687,11.57494,11.18304,10.2864,10.46321,11.99554,10.43269,10.39849,11.81658,9.346381,11.50599,11.88998,6.62544,3.894241,3.890911,3.794958,5.294306,5.738066,5.993357,6.07717,4.772534,6.489223,3.828884,5.374619,5.984737,6.720317,5.847452,4.887817,4.40027,6.125464,4.621455,4.396941,6.256742,5.88944,3.633275,3.168183,5.618152,5.609351,6.005497,5.601674,4.578655,4.362448,4.643564,4.357966,4.991857,5.44285,6.693356,4.881094,4.440145,4.41043,6.467285,6.984014,6.647313,8.623562,5.282549,5.303233,5.446354,3.237838,4.69592,5.117531,4.417432,6.699504,1.777948,2.000716,1.647443,0.6578707,1.185813,1.340163,0.8567217,0.4685722,1.886943,0.6296398,0.9436816,3.178783,1.881288,0.2955426,1.094876,1.51694,0.8390292,1.184013,1.292351,0.4347644,0.0583208,1.557327,2.55006,2.153256,0.6986981,2.109782,1.287445,1.633417,2.1692,1.172513,2.550118,1.150614,2.626211,0.4894441,1.707098,0.4239845,1.066521,1.852951,3.449774,2.539969,0.4564295,1.415585,2.369195,1.635308,0.5884364,2.153891,1.927721,1.489897,1.959483,0,9.277531,9.270912,9.84514,8.316332,7.385801,7.718995,8.404907,7.21236,7.952797,9.595542,7.014122,7.692547,7.775756,6.948871,8.978716,8.28937,8.72631,6.460531,7.257902,8.292667,9.277588,10.06872,9.836744,7.672754,9.134411,8.073277,7.513331,8.67241,8.676564,7.988327,7.985981,7.383072,7.948782,8.633246,6.742532,9.947396,7.835831,9.543777,6.041876,7.04238,8.828188,8.232553,10.72215,7.504396,8.32246,10.64709,9.206461,7.73454,8.067004,7.811903, + 8.723632,8.923729,9.329242,7.738995,7.735488,9.291451,7.203474,8.905331,7.894182,8.385297,8.281788,8.194197,7.646088,6.199072,7.628384,9.952294,7.327326,8.399342,11.21558,9.772626,7.830667,9.337638,6.780137,7.269697,9.049149,8.141243,8.390889,8.347497,8.681804,7.097516,7.843996,8.694404,6.516771,9.203952,9.223788,8.302207,9.303028,7.166547,7.199824,7.670129,9.046921,8.611394,8.483224,7.885175,8.614748,7.990654,9.051565,7.800086,7.05237,9.146623,8.521525,5.770073,8.55469,7.026051,6.990739,7.031368,7.247918,8.353375,7.41947,6.657848,6.835079,7.461282,7.718801,5.661075,7.303773,6.195977,7.645223,8.514845,8.159884,8.550598,5.202942,6.963746,8.317379,8.266494,7.245817,7.135676,7.311348,7.129645,5.807704,6.248313,7.452136,8.14632,6.929844,6.18544,5.710682,8.280433,8.158282,9.104726,6.404255,7.547217,6.57576,5.979907,7.299595,7.339869,7.631698,6.556768,8.469362,7.044735,6.36728,7.892226,10.51813,11.2509,9.953806,8.762485,8.690341,10.61076,9.714598,9.66318,7.515786,9.67652,8.430701,12.43805,9.69255,9.570683,10.34441,10.25618,9.691087,9.70269,10.50773,9.367186,9.225568,9.460465,11.81498,10.39281,9.975263,11.23545,9.904515,8.794894,11.15184,9.159436,11.60935,10.2199,8.618529,9.2967,10.13148,9.239665,9.857016,10.53302,12.18529,10.44623,8.886723,8.000334,11.12398,10.49895,8.881828,11.41627,9.749327,10.7672,11.23654,9.277531,0,0.9605936,1.020556,1.52754,2.358899,1.56048,1.001715,2.374805,1.790801,0.4728093,2.270007,1.602879,2.200955,2.364917,0.4900654,1.197778,0.7992293,2.964476,2.215859,1.968462,2.60163,1.034896,1.016051,1.979596,0.6178844,1.417621,1.776656,0.7946509,0.6009706,1.303014,2.12767,2.233904,1.369605,2.613321,2.649376,0.8412671,2.086452,1.75041,3.262734,2.312283,0.6740175,1.475472,1.828743,4.154532,1.10617,1.803195,0.08559222,1.567219,1.996058,2.324925, + 7.773961,7.967622,8.375997,6.778467,6.82302,8.339397,6.247333,7.966323,6.934852,7.435121,7.328153,7.233744,6.708843,5.259227,6.717725,8.992281,6.387672,7.484918,10.3015,8.82968,6.90506,8.423209,5.844381,6.310154,8.11698,7.24052,7.473504,7.485992,7.740878,6.140506,6.897785,7.752865,5.595513,8.245553,8.315966,7.341656,8.419576,6.206517,6.264434,6.709716,8.107612,7.695458,7.557556,6.925038,7.692933,7.058032,8.097588,6.911448,6.092366,8.192421,7.848739,5.571503,8.145749,6.674309,6.446066,6.434912,6.622301,7.726849,6.926928,5.981825,6.492569,6.900696,7.094699,4.971551,6.693374,5.739746,7.190986,7.886447,7.675661,8.089623,4.597277,6.351135,7.937471,7.93887,6.660476,6.552413,6.684335,6.547308,5.44184,5.872398,6.97387,7.69001,6.423493,5.648567,5.023451,7.769437,7.693164,8.647649,5.732698,6.826834,5.88314,5.101704,6.750896,6.788344,7.062499,6.354656,7.977807,6.519891,5.971535,7.202152,10.62891,11.26652,10.09297,8.715203,8.576872,10.61106,9.780066,9.681537,7.598114,9.717124,8.474171,12.44919,9.867959,9.566361,10.30855,10.13071,9.756072,9.805234,10.53375,9.40383,9.221976,9.294438,11.77443,10.5596,9.968827,11.14622,10.0069,8.625169,11.03377,9.2743,11.68803,10.27366,8.883768,9.239402,9.974331,9.276962,9.757536,10.38814,12.33355,10.21475,8.907189,8.069405,11.24876,10.38074,8.92339,11.37652,9.927315,10.75621,11.21721,9.270912,0.9605936,0,1.922989,2.300015,2.94356,1.745258,0.9637324,2.880793,2.471041,1.365174,2.471603,1.931343,2.897304,2.633745,0.6289849,1.008481,1.604134,3.295969,2.672868,2.782939,3.548303,1.847237,1.920255,2.582513,0.3780668,2.032281,2.05976,1.561762,1.10464,1.676838,2.877653,1.915963,1.799297,3.504157,2.528859,1.647641,2.78347,2.711003,3.442595,2.64657,1.504792,2.203169,2.594322,4.920531,1.746442,2.593445,1.006565,1.650433,2.753479,3.049814, + 9.690631,9.873618,10.28776,8.649808,8.740113,10.253,8.154433,9.888797,8.829029,9.351374,9.239728,9.115825,8.631676,7.181804,8.633919,10.85023,8.310151,9.403028,12.21981,10.75082,8.82695,10.34146,7.767353,8.166728,10.03993,9.151306,9.392846,9.366729,9.662886,8.045324,8.817535,9.674677,7.515923,10.14357,10.23101,9.220662,10.31868,8.096037,8.187411,8.59333,10.03001,9.614249,9.479527,8.787763,9.61387,8.980982,10.00819,8.814083,7.954843,10.10255,9.509551,6.526005,9.418002,7.86533,7.932008,7.994568,8.221785,9.324793,8.333873,7.650528,7.670427,8.407715,8.690807,6.660171,8.271621,7.099646,8.538589,9.486643,9.066594,9.443252,6.177678,7.933537,9.164775,9.081868,8.203701,8.093093,8.28556,8.086696,6.66669,7.108493,8.359125,9.038273,7.853559,7.127346,6.70902,9.200304,9.054921,9.99297,7.396185,8.550957,7.573534,6.995869,8.241343,8.282727,8.581312,7.304226,9.378596,7.976647,7.237491,8.88685,10.97008,11.78492,10.38321,9.368845,9.350531,11.16231,10.21488,10.20593,8.024385,10.19949,8.962844,12.96949,10.089,10.13389,10.92884,10.91447,10.192,10.16893,11.03736,9.896305,9.791027,10.15523,12.39464,10.79179,10.53715,11.85892,10.36918,9.497237,11.79912,9.619127,12.08402,10.72677,8.934984,9.906757,10.8152,9.769335,10.49722,11.2049,12.59028,11.18365,9.434443,8.514603,11.5583,11.15002,9.41106,11.9974,10.14272,11.32754,11.80121,9.84514,1.020556,1.922989,0,1.585613,2.555982,2.291162,1.94903,2.672794,1.94669,0.5609335,2.885763,2.216027,2.249848,2.912732,1.507734,2.159544,1.141538,3.393376,2.594147,1.823179,1.923271,0.2976633,0.008413377,2.213253,1.623548,1.771984,2.395124,1.207961,1.426411,1.948979,2.090995,3.155037,1.947464,2.167028,3.452591,0.3686392,2.153859,0.9717473,3.811636,2.805725,1.063157,1.635775,0.9102196,3.903118,1.53974,0.8562594,1.020397,2.3604,1.969033,2.303887, + 9.694963,9.949371,10.32389,8.876742,8.534005,10.27629,8.245838,9.808456,8.972834,9.363599,9.288893,9.3025,8.554821,7.144826,8.421728,11.09806,8.253188,9.19565,11.98083,10.69035,8.681706,10.12226,7.694732,8.441415,9.915451,8.889607,9.19927,8.964746,9.597931,8.15065,8.801103,9.613891,7.372317,10.25664,9.983673,9.416855,9.975045,8.267794,8.105734,8.78042,9.950271,9.410945,9.325726,9.038831,9.438761,8.87171,10.05498,8.512429,8.215804,10.15136,8.675304,5.191434,8.21264,6.634981,6.937614,7.074519,7.340587,8.416326,7.256327,6.872781,6.436161,7.421638,7.79394,5.946423,7.364695,6.01776,7.406914,8.577625,7.959455,8.298688,5.350414,7.040609,7.93247,7.796897,7.260218,7.149877,7.40472,7.142288,5.49581,5.930405,7.262432,7.896852,6.808969,6.151587,5.988911,8.125048,7.923978,8.832956,6.619807,7.827904,6.82816,6.701462,7.243042,7.287232,7.602968,5.946166,8.273895,6.953147,6.077133,8.098053,9.39641,10.23602,8.805519,7.864413,7.885444,9.62221,8.656004,8.663986,6.474413,8.649126,7.419662,11.41784,8.506639,8.601942,9.405955,9.440693,8.633392,8.599721,9.487987,8.349174,8.261268,8.715962,10.86588,9.20934,9.003449,10.35714,8.799295,8.068916,10.31402,8.049013,10.51481,9.169288,7.349656,8.402506,9.362861,8.222756,9.011375,9.740937,11.00774,9.782063,7.89696,6.965233,9.980568,9.669844,7.865252,10.47021,8.559986,9.791229,10.26602,8.316332,1.52754,2.300015,1.585613,0,0.9705114,1.301626,1.596676,1.105796,0.3659291,1.550788,1.565456,1.058625,0.6956782,1.508741,1.67144,1.761001,0.7301105,1.859467,1.074871,0.4934257,1.602396,1.854177,1.577338,0.6438242,1.927413,0.4679944,1.18388,0.7506533,1.201339,0.9794069,0.6001313,2.366403,0.8668452,1.297947,2.344898,1.794463,0.5874205,1.302312,2.342728,1.359353,0.8535929,0.1566859,2.415407,2.636841,0.5967397,2.33635,1.444457,1.463755,0.4686397,0.8004816, + 9.803899,10.09816,10.44439,9.129421,8.530598,10.38957,8.428981,9.864285,9.175298,9.481767,9.430379,9.525564,8.63113,7.273542,8.416424,11.33665,8.346886,9.181097,11.91545,10.74802,8.713776,10.08808,7.789608,8.728458,9.942743,8.845474,9.193296,8.829782,9.665941,8.34374,8.910243,9.684241,7.430481,10.42413,9.933507,9.643977,9.863967,8.497944,8.18702,9.011255,10.00468,9.395887,9.342708,9.303211,9.440915,8.922981,10.18508,8.449032,8.498658,10.28152,8.254265,4.441836,7.528801,5.949323,6.428044,6.61723,6.906616,7.946495,6.679425,6.52212,5.750168,6.910087,7.341202,5.665563,6.91174,5.45974,6.78719,8.105346,7.351347,7.659262,5.006591,6.603707,7.230885,7.056367,6.782499,6.674283,6.969875,6.665956,4.878357,5.297878,6.671049,7.263958,6.264069,5.672244,5.702211,7.538536,7.298593,8.177296,6.275923,7.496893,6.501442,6.681336,6.725348,6.770893,7.094287,5.165506,7.664109,6.421585,5.455979,7.716924,8.432561,9.289003,7.839119,6.953415,7.004968,8.681892,7.702788,7.723191,5.530152,7.702125,6.479385,10.46834,7.537388,7.668666,8.478404,8.549381,7.680381,7.639146,8.541095,7.404829,7.330096,7.852481,9.93266,8.240007,8.068398,9.443762,7.838173,7.216242,9.412791,7.087996,9.553686,8.216782,6.380161,7.490476,8.487664,7.278946,8.111984,8.856234,10.03831,8.943218,6.960418,6.020738,9.013993,8.773334,6.922404,9.538442,7.590526,8.853509,9.328715,7.385801,2.358899,2.94356,2.555982,0.9705114,0,1.394969,2.049391,0.2624066,0.6119519,2.478195,1.134086,1.113771,0.4164316,0.9578813,2.352604,2.133575,1.588071,0.9903019,0.4524455,0.9263955,2.102582,2.821715,2.547695,0.3793031,2.605722,0.9449986,1.08882,1.572431,1.875612,1.28883,0.6332798,2.306265,1.155383,1.541652,1.99124,2.752129,0.4528925,2.161028,1.54582,0.7800719,1.714842,0.9360706,3.375959,2.108615,1.256719,3.294157,2.273343,1.569763,0.6888631,0.5320745, + 8.478751,8.755341,9.114485,7.750873,7.268076,9.063009,7.070569,8.567119,7.811229,8.151815,8.089867,8.155435,7.320973,5.935001,7.154996,9.963632,7.027189,7.926917,10.69994,9.450784,7.429011,8.848469,6.4683,7.342229,8.662485,7.611657,7.933369,7.668405,8.361739,6.981704,7.583792,8.378783,6.128128,9.074073,8.705234,8.27278,8.683048,7.124581,6.873475,7.638318,8.708486,8.142306,8.068122,7.922086,8.175942,7.627179,8.850494,7.229038,7.112991,8.947017,7.411533,4.246418,7.133947,5.576058,5.72529,5.83273,6.086773,7.174349,6.087713,5.591559,5.380622,6.207174,6.546451,4.65247,6.119296,4.847687,6.272419,7.336222,6.810286,7.174637,4.074022,5.78953,6.876324,6.790836,6.027703,5.916896,6.150992,5.909741,4.385025,4.826354,6.105201,6.769943,5.620787,4.927989,4.695859,6.957275,6.79005,7.720514,5.337576,6.539498,5.541028,5.426873,6.033506,6.076558,6.385686,5.029262,7.123859,5.754663,4.959812,6.822185,8.985449,9.695898,8.430878,7.202005,7.13442,9.05349,8.168191,8.107744,5.971022,8.124773,6.878426,10.88288,8.184918,8.012489,8.784318,8.700649,8.144544,8.166544,8.953963,7.814479,7.667287,7.913352,10.25491,8.88198,8.417035,9.67587,8.368524,7.24978,9.59483,7.626714,10.06779,8.67123,7.160616,7.736268,8.581559,7.686976,8.298683,8.98036,10.668,8.91668,7.331079,6.452961,9.596722,8.942305,7.329616,9.856179,8.242976,9.208833,9.677613,7.718995,1.56048,1.745258,2.291162,1.301626,1.394969,0,0.7815263,1.245659,1.194173,1.918357,0.7400563,0.2899831,1.53965,0.8887773,1.289967,0.7881158,1.174197,1.551323,1.011541,1.726026,2.903868,2.448818,2.283417,1.128854,1.491735,0.8338187,0.3327981,1.098233,0.9606841,0.363989,1.636098,1.064852,0.439745,2.553759,1.165364,2.294037,1.451721,2.46464,1.735269,0.909666,1.231123,1.144993,3.200475,3.501853,0.838922,3.14699,1.492387,0.1799629,1.559294,1.719773, + 8.125111,8.367485,8.749182,7.280447,7.019498,8.70388,6.658732,8.258665,7.381356,7.79146,7.709983,7.708166,7.000519,5.575932,6.908989,9.501947,6.69295,7.683961,10.48825,9.137409,7.147294,8.617735,6.136286,6.844963,8.378439,7.397725,7.682661,7.538192,8.043605,6.561735,7.233377,8.058555,5.832041,8.670118,8.48958,7.822069,8.522713,6.673393,6.551132,7.185627,8.400674,7.89848,7.796138,7.442192,7.916542,7.327212,8.47792,7.035971,6.619208,8.574126,7.561485,4.8072,7.554606,6.030823,5.996854,6.048467,6.273129,7.376657,6.419209,5.704655,5.840937,6.469569,6.742493,4.719558,6.324172,5.194493,6.643517,7.538448,7.158874,7.548902,4.228736,5.985568,7.319729,7.276174,6.259701,6.149265,6.336865,6.143027,4.809509,5.249589,6.451058,7.14461,5.931032,5.191496,4.767658,7.281199,7.156663,8.103013,5.450051,6.613717,5.630992,5.212692,6.305982,6.346686,6.641433,5.594831,7.468641,6.047898,5.367069,6.941556,9.717248,10.39265,9.171569,7.868107,7.76541,9.743438,8.88404,8.804818,6.692541,8.830986,7.58516,11.57827,8.935827,8.699678,9.457783,9.328196,8.860207,8.895591,9.654662,8.518952,8.354509,8.515737,10.92738,9.630449,9.103605,10.32411,9.097529,7.847968,10.22782,8.359846,10.78878,9.382792,7.931165,8.398173,9.190816,8.391648,8.939678,9.597498,11.41111,9.480712,8.02853,7.169617,10.33295,9.574243,8.035828,10.52873,8.994544,9.893948,10.35933,8.404907,1.001715,0.9637324,1.94903,1.596676,2.049391,0.7815263,0,1.954218,1.663418,1.453135,1.51163,0.9814494,2.076762,1.670111,0.58507,0.2134069,1.076533,2.332443,1.735019,2.087484,3.088203,2.020774,1.942797,1.713392,0.7343316,1.216148,1.098929,1.001822,0.5496041,0.7606477,2.104993,1.232211,0.8959326,2.888445,1.691736,1.834688,1.969308,2.426669,2.493471,1.685252,1.047016,1.463794,2.813033,4.105714,1.000038,2.779145,0.963914,0.6962006,1.995593,2.245676, + 9.587145,9.88749,10.2289,8.938202,8.299074,10.17301,8.225936,9.639627,8.97474,9.266744,9.219138,9.328339,8.410574,7.06302,8.184765,11.14063,8.129275,8.947596,11.67447,10.52299,8.48681,9.851551,7.572897,8.544507,9.714094,8.608631,8.960868,8.583214,9.443186,8.142565,8.694383,9.461809,7.208745,10.21629,9.695203,9.447369,9.619151,8.303299,7.967718,8.816061,9.779715,9.162157,9.113144,9.114036,9.209334,8.698494,9.971313,8.210264,8.314199,10.06769,7.992005,4.199947,7.279158,5.699081,6.166136,6.354825,6.644314,7.684162,6.420082,6.261957,5.499834,6.648296,7.078796,5.409596,6.649336,5.199066,6.530743,7.84304,7.09422,7.404847,4.747567,6.3414,6.983448,6.814942,6.520171,6.411934,6.707561,6.403611,4.620715,5.041704,6.412551,7.008804,6.003141,5.409865,5.445836,7.280012,7.042805,7.924666,6.01614,7.237205,6.242333,6.449878,6.463675,6.509194,6.832457,4.930711,7.407208,6.160243,5.19899,7.455452,8.297704,9.130259,7.710484,6.766763,6.802759,8.516659,7.551183,7.558362,5.368621,7.543387,6.314033,10.31224,7.419034,7.497403,8.302854,8.352612,7.528522,7.498245,8.382231,7.243379,7.157143,7.643593,9.761507,8.121823,7.898604,9.258984,7.698186,7.003131,9.221181,6.94797,9.41345,8.06426,6.287496,7.304562,8.283657,7.116967,7.919157,8.656454,9.920183,8.726063,6.791792,5.859439,8.885561,8.579173,6.759486,9.366137,7.47326,8.685999,9.160872,7.21236,2.374805,2.880793,2.672794,1.105796,0.2624066,1.245659,1.954218,0,0.7407994,2.542035,0.8897015,0.9827952,0.6613767,0.7028737,2.313968,2.014798,1.638879,0.7696452,0.2381056,1.150463,2.35274,2.925888,2.66441,0.4625315,2.560307,0.964561,0.9209413,1.610712,1.850746,1.204719,0.8729404,2.091332,1.082274,1.801598,1.74021,2.840304,0.6728719,2.355688,1.304942,0.5281213,1.761535,1.037094,3.520338,2.295371,1.271094,3.441914,2.290073,1.411953,0.9081171,0.7918867, + 9.666684,9.936645,10.30071,8.90323,8.461881,10.2503,8.244184,9.760177,8.979739,9.338449,9.27259,9.317871,8.512641,7.120135,8.348727,11.12132,8.217144,9.120319,11.88954,10.64369,8.623044,10.04077,7.658179,8.480948,9.856576,8.802937,9.127126,8.845114,9.554003,8.152718,8.771764,9.570866,7.321223,10.25145,9.896139,9.433953,9.865267,8.284552,8.064734,8.798177,9.901616,9.3357,9.262295,9.07015,9.369943,8.820532,10.03519,8.418138,8.253343,10.1317,8.456234,4.867555,7.910564,6.33082,6.68735,6.84127,7.115391,8.180916,6.985455,6.674408,6.131652,7.171493,7.563295,5.769496,7.133335,5.750652,7.123146,8.341605,7.679828,8.009881,5.150302,6.813941,7.625012,7.478282,7.020668,6.910834,7.179342,6.902994,5.209665,5.640672,6.987114,7.609637,6.547371,5.909434,5.810107,7.852235,7.639058,8.539706,6.423177,7.637904,6.637784,6.619603,6.990682,7.035368,7.353993,5.615122,7.994068,6.69596,5.791029,7.891537,9.03092,9.87058,8.440584,7.504081,7.531287,9.257444,8.290145,8.299128,6.109093,8.283653,7.0548,11.05222,8.143066,8.238035,9.04295,9.084516,8.267541,8.233903,9.122544,7.98393,7.897636,8.365851,10.5021,8.845817,8.639323,9.996653,8.433512,7.721159,9.955899,7.683231,10.14901,8.803463,6.991529,8.042062,9.010205,7.85756,8.653459,9.386231,10.64428,9.438177,7.532573,6.599918,9.615663,9.31261,7.500138,10.10662,8.196591,9.426789,9.901653,7.952797,1.790801,2.471041,1.94669,0.3659291,0.6119519,1.194173,1.663418,0.7407994,0,1.874155,1.292125,0.914371,0.4263138,1.202285,1.853697,1.795194,0.9998618,1.499882,0.7295488,0.5561767,1.793998,2.210149,1.938368,0.2809661,2.11172,0.4487275,0.9929039,0.9961785,1.370086,0.944011,0.4502419,2.239218,0.8085306,1.3694,2.117261,2.140698,0.3125903,1.635922,1.998352,1.039732,1.127769,0.3279085,2.781318,2.455366,0.7263932,2.702101,1.705511,1.37112,0.3652088,0.5845699, + 9.137436,9.325526,9.73709,8.114565,8.179296,9.701431,7.605657,9.33143,8.285565,8.798391,8.689073,8.576929,8.073741,6.62432,8.07305,10.32036,7.752788,8.842285,11.65906,10.19477,8.267057,9.780723,7.208999,7.636263,9.481037,8.590411,8.832256,8.808692,9.106052,7.49749,8.262474,9.118035,6.95558,9.598825,9.670093,8.682905,9.758595,7.554137,7.629021,8.05373,9.47274,9.053579,8.919658,8.255532,9.053608,8.422117,9.458047,8.253629,7.422303,9.552637,8.992379,6.161009,8.988609,7.450447,7.449788,7.49655,7.715758,8.820783,7.870306,7.129344,7.257879,7.921962,8.186271,6.133365,7.77018,6.642703,8.089173,8.98236,8.608471,8.994648,5.670599,7.430574,8.745502,8.682814,7.709638,7.599348,7.779276,7.593216,6.238366,6.679784,7.900562,8.589989,7.383482,6.644416,6.182888,8.73329,8.603533,9.547468,6.875614,8.019943,7.047946,6.435995,7.758872,7.799483,8.093322,6.945384,8.918868,7.500974,6.802458,8.364073,10.78834,11.55646,10.2138,9.096128,9.04604,10.92319,10.00466,9.971132,7.806651,9.976152,8.732866,12.74327,9.938038,9.887126,10.67033,10.61231,9.981393,9.978233,10.81089,9.669111,9.542629,9.830734,12.1399,10.64012,10.29151,11.57804,10.17959,9.1677,11.50406,9.431585,11.89011,10.51322,8.827673,9.632374,10.49777,9.541693,10.20552,10.89481,12.43667,10.83394,9.195991,8.294342,11.38715,10.85231,9.183288,11.74156,9.993552,11.08342,11.55489,9.595542,0.4728093,1.365174,0.5609335,1.550788,2.478195,1.918357,1.453135,2.542035,1.874155,0,2.584609,1.904499,2.246464,2.649246,0.9626607,1.656499,0.9042774,3.201171,2.417954,1.915249,2.320844,0.5679104,0.5575419,2.106822,1.063366,1.583046,2.084674,0.941604,0.9785254,1.612648,2.130752,2.681476,1.646818,2.438996,3.050912,0.3846128,2.137457,1.40673,3.556595,2.570445,0.7858865,1.546249,1.36159,4.08892,1.294817,1.332562,0.4913309,1.954888,1.999428,2.340782, + 8.71384,9.022046,9.356971,8.105228,7.412114,9.299758,7.373035,8.75779,8.125324,8.395715,8.35319,8.484288,7.533212,6.199484,7.297735,10.29743,7.255462,8.059509,10.78484,9.640676,7.603138,8.9623,6.700475,7.725919,8.828918,7.719328,8.073329,7.695863,8.563222,7.292825,7.822511,8.582168,6.330525,9.354741,8.805602,8.604291,8.730681,7.464756,7.091946,7.97601,8.897572,8.273951,8.227377,8.284683,8.322255,7.816998,9.10166,7.320624,7.494932,9.197912,7.176789,3.66136,6.650525,5.074799,5.395557,5.554628,5.832961,6.892753,5.6964,5.415291,4.876354,5.879668,6.277533,4.540227,5.847447,4.460068,5.841929,7.053155,6.395581,6.733235,3.893976,5.53086,6.374103,6.251483,5.731349,5.621734,5.89675,5.613808,3.930395,4.365014,5.700167,6.331458,5.255686,4.619679,4.577991,6.564141,6.358835,7.267779,5.166557,6.385943,5.387723,5.563221,5.698662,5.743383,6.0623,4.431127,6.709986,5.403867,4.511751,6.622456,8.253811,8.982537,7.695742,6.51154,6.470383,8.34474,7.444781,7.395336,5.246129,7.406842,6.161267,10.1697,7.44657,7.30645,8.086538,8.035862,7.42125,7.436421,8.238714,7.097818,6.961613,7.269735,9.556462,8.144213,7.710987,8.994554,7.638348,6.611476,8.924618,6.894919,9.340903,7.949895,6.421687,7.047887,7.930981,6.970301,7.624565,8.322955,9.931684,8.301289,6.619194,5.73036,8.863079,8.27383,6.612332,9.157998,7.504459,8.503018,8.9736,7.014122,2.270007,2.471603,2.885763,1.565456,1.134086,0.7400563,1.51163,0.8897015,1.292125,2.584609,0,0.68028,1.456353,0.218986,2.029167,1.480411,1.744754,0.8604848,0.6847714,1.837056,3.081314,3.080667,2.87757,1.075992,2.231019,1.166637,0.4999364,1.681875,1.670646,0.9742129,1.631459,1.239332,0.9434692,2.601992,0.8607589,2.945082,1.415857,2.857755,0.9979879,0.3654385,1.833778,1.42712,3.791102,3.153444,1.34726,3.727659,2.196239,0.8223568,1.610984,1.621226, + 8.766631,9.044532,9.402801,8.040461,7.548787,9.351055,7.360418,8.852283,8.101202,8.440062,8.378879,8.445385,7.607307,6.223688,7.435526,10.25349,7.314414,8.206736,10.97522,9.736076,7.712546,9.126603,6.755589,7.630879,8.945746,7.8886,8.213942,7.934547,8.64762,7.27164,7.871696,8.664796,6.413369,9.36366,8.981775,8.562706,8.952702,7.414461,7.160075,7.928203,8.993566,8.422108,8.350578,8.21144,8.457224,7.912032,9.139143,7.503847,7.401754,9.235667,7.621363,4.313127,7.255537,5.687879,5.904304,6.028163,6.289714,7.370387,6.245741,5.814542,5.490777,6.387618,6.745588,4.88877,6.317013,5.004986,6.415605,7.531973,6.96029,7.314325,4.292685,5.990632,6.989058,6.885233,6.21785,6.107252,6.353898,6.099847,4.51518,4.954654,6.258106,6.910443,5.78759,5.112457,4.930998,7.115633,6.933512,7.855929,5.561437,6.769292,5.769535,5.70566,6.211285,6.254952,6.56771,5.089254,7.274493,5.926643,5.093904,7.040817,8.915296,9.65808,8.351324,7.191755,7.148732,9.021988,8.114997,8.071487,5.916002,8.080522,6.835652,10.84518,8.092867,7.984565,8.766094,8.714511,8.091559,8.100178,8.913552,7.772209,7.639862,7.944082,10.23585,8.792473,8.389051,9.67477,8.301971,7.284297,9.604024,7.556644,10.00772,8.621448,7.037483,7.728148,8.607048,7.644714,8.304286,9.000427,10.5838,8.967666,7.295681,6.401716,9.521195,8.952992,7.286532,9.837439,8.149986,9.181055,9.652017,7.692547,1.602879,1.931343,2.216027,1.058625,1.113771,0.2899831,0.9814494,0.9827952,0.914371,1.904499,0.68028,0,1.250066,0.7626277,1.414445,1.032007,1.07514,1.389147,0.7564621,1.45645,2.656862,2.403094,2.207934,0.8388741,1.641301,0.5958859,0.1807787,1.008384,1.010311,0.2998682,1.351193,1.326949,0.2688129,2.280888,1.311738,2.265184,1.163444,2.281775,1.661486,0.7296986,1.15762,0.9030587,3.124592,3.217049,0.6901616,3.064232,1.526357,0.4698773,1.279281,1.430279, + 10.01471,10.29448,10.65163,9.284045,8.779441,10.59942,8.61005,10.09429,9.34993,9.688804,9.628677,9.692532,8.852271,7.47315,8.665743,11.49926,8.561316,9.434585,12.18828,10.97828,8.95068,10.34914,8.002671,8.868497,10.18283,9.108382,9.443903,9.121578,9.8914,8.520827,9.119863,9.908885,7.656067,10.6137,10.19967,9.809477,10.14953,8.660709,8.405686,9.174482,10.23534,9.649806,9.585661,9.453312,9.689063,9.153444,10.38849,8.717699,8.64009,10.48501,8.622036,4.857033,7.940238,6.360271,6.812506,6.991162,7.275806,8.324519,7.076291,6.870905,6.161038,7.295473,7.715022,5.994132,7.28511,5.852022,7.190664,8.484013,7.753523,8.065837,5.350197,6.973144,7.643802,7.471787,7.160962,7.052172,7.339341,7.043988,5.279685,5.701904,7.070229,7.669501,6.655002,6.049465,6.032474,7.93758,7.703158,8.586018,6.622547,7.842181,6.84407,6.932417,7.11172,7.157055,7.479304,5.581891,8.066708,6.810244,5.858544,8.074885,8.790141,9.666921,8.191324,7.352385,7.412595,9.065195,8.075572,8.106598,5.912538,8.080759,6.863898,10.84367,7.879967,8.056923,8.869443,8.953876,8.053391,8.002731,8.919419,7.785777,7.719726,8.263016,10.32006,8.581801,8.455404,9.840842,8.200805,7.628525,9.814162,7.451232,9.915562,8.590042,6.697934,7.888799,8.895908,7.660379,8.514335,9.262299,10.37884,9.356751,7.347082,6.402508,9.365191,9.17632,7.304777,9.926809,7.931982,9.238497,9.713797,7.775756,2.200955,2.897304,2.249848,0.6956782,0.4164316,1.53965,2.076762,0.6613767,0.4263138,2.246464,1.456353,1.250066,0,1.31002,2.279741,2.197551,1.403224,1.406614,0.7850794,0.5184043,1.691365,2.529155,2.241789,0.4163551,2.537821,0.8703152,1.283553,1.407999,1.796232,1.337498,0.2173992,2.541077,1.198993,1.153604,2.315195,2.481937,0.115235,1.76868,1.960796,1.131108,1.530398,0.7255068,3.029573,2.032429,1.152467,2.94435,2.116242,1.719601,0.2951107,0.1803605, + 8.924564,9.235127,9.568125,8.323086,7.614484,9.510456,7.588756,8.964456,8.34149,8.607248,8.566197,8.701099,7.742403,6.413327,7.50003,10.51424,7.466148,8.260183,10.97817,9.846964,7.808642,9.16022,6.911732,7.944568,9.03305,7.917165,8.274856,7.882535,8.771009,7.509016,8.033822,8.790128,6.539476,9.568712,9.001875,8.821204,8.919657,7.682196,7.301883,8.193274,9.104029,8.474398,8.430995,8.502779,8.524384,8.02397,9.313566,7.516676,7.713564,9.409774,7.312038,3.684447,6.709653,5.130484,5.508901,5.681821,5.965798,7.016383,5.790154,5.567396,4.931428,5.992476,6.405585,4.707788,5.97561,4.558814,5.922179,7.176139,6.480074,6.807837,4.050004,5.663151,6.426289,6.288185,5.853229,5.744196,6.029342,5.736079,4.008503,4.438691,5.789417,6.407847,5.358867,4.741439,4.744355,6.655463,6.437726,7.337426,5.320404,6.541101,5.544841,5.766231,5.809761,5.854862,6.175896,4.444076,6.794174,5.510989,4.589723,6.76694,8.153981,8.907212,7.588927,6.459847,6.438926,8.274626,7.358198,7.322029,5.159441,7.327248,6.083655,10.09404,7.330432,7.239799,8.027042,8.002155,7.334839,7.339683,8.161702,7.019954,6.895623,7.250721,9.495468,8.029921,7.64401,8.948052,7.541406,6.5966,8.88639,6.795504,9.248446,7.865741,6.282662,6.997345,7.906854,6.892524,7.584562,8.294008,9.821175,8.297706,6.547111,5.646312,8.759101,8.237332,6.53414,9.097457,7.387619,8.435737,8.907785,6.948871,2.364917,2.633745,2.912732,1.508741,0.9578813,0.8887773,1.670111,0.7028737,1.202285,2.649246,0.218986,0.7626277,1.31002,0,2.161139,1.657746,1.780296,0.6676223,0.5250133,1.728012,2.969391,3.123339,2.904419,0.9586761,2.374847,1.154671,0.5954235,1.724179,1.772731,1.062291,1.498738,1.457414,1.004368,2.46315,1.038191,2.998555,1.283147,2.810735,0.907496,0.179497,1.879596,1.3825,3.809949,2.941973,1.376688,3.74244,2.287657,0.9971994,1.493456,1.465975, + 8.291021,8.50368,8.902492,7.348392,7.271982,8.862483,6.784765,8.459681,7.486289,7.953691,7.856448,7.795251,7.199588,5.756501,7.164037,9.567128,6.883406,7.936453,10.75136,9.330656,7.374839,8.874283,6.333046,6.889654,8.597401,7.672086,7.929626,7.866416,8.238221,6.681345,7.4071,8.251459,6.059231,8.791016,8.757208,7.905317,8.827222,6.763756,6.752017,7.27093,8.60149,8.149204,8.027023,7.499995,8.155978,7.539905,8.626456,7.326613,6.669055,8.721938,8.036234,5.392006,8.118813,6.603522,6.522942,6.554917,6.767497,7.873441,6.962538,6.171543,6.414808,6.991067,7.238863,5.173227,6.825476,5.745364,7.197161,8.034735,7.705526,8.101898,4.723276,6.484893,7.888924,7.852718,6.771265,6.661367,6.830783,6.655479,5.378791,5.817706,6.998358,7.69832,6.46944,5.718118,5.223019,7.820444,7.708242,8.657425,5.918221,7.058142,6.088097,5.50447,6.831367,6.871165,7.160126,6.179632,8.013673,6.580758,5.93171,7.405196,10.27141,10.96344,9.719455,8.446526,8.348761,10.31632,9.446878,9.37523,7.252094,9.398016,8.151707,12.14967,9.474873,9.273184,10.03495,9.912025,9.423129,9.451368,10.22394,9.086607,8.927932,9.100705,11.50498,10.17182,9.677368,10.90588,9.653358,8.432986,10.81128,8.912991,11.34931,9.94767,8.443656,8.977506,9.77563,8.959199,9.522182,10.18201,11.95719,10.06494,8.598645,7.731712,10.8842,10.15774,8.602693,11.10626,9.532942,10.46826,10.93463,8.978716,0.4900654,0.6289849,1.507734,1.67144,2.352604,1.289967,0.58507,2.313968,1.853697,0.9626607,2.029167,1.414445,2.279741,2.161139,0,0.7513536,0.9788192,2.803291,2.120853,2.153989,2.958534,1.520802,1.50292,1.983141,0.2581989,1.422894,1.567348,0.9336596,0.4837501,1.131165,2.252221,1.793413,1.237501,2.882673,2.276519,1.324031,2.165194,2.168765,3.025225,2.144076,0.8857572,1.577395,2.312857,4.296547,1.127308,2.290269,0.4899909,1.24705,2.126957,2.428204, + 7.942029,8.190405,8.568317,7.119887,6.821536,8.521961,6.485167,8.068815,7.211903,7.609315,7.531142,7.542605,6.811724,5.391972,6.710683,9.340426,6.505999,7.485701,10.28762,8.948605,6.953336,8.418527,5.948587,6.69071,8.185363,7.196346,7.485262,7.330182,7.855034,6.389707,7.049296,7.870295,5.639041,8.496176,8.288791,7.657328,8.317097,6.50803,6.362316,7.02095,8.210795,7.700408,7.601295,7.28399,7.720246,7.135739,8.298181,6.832509,6.463905,8.394484,7.350175,4.653772,7.368759,5.85218,5.794053,5.841223,6.063952,7.167971,6.222207,5.492532,5.663553,6.265636,6.533671,4.506596,6.116071,5.000635,6.451227,7.329704,6.963333,7.356356,4.019167,5.777094,7.137784,7.101952,6.053484,5.943141,6.127633,5.936974,4.627577,5.066664,6.255724,6.952398,5.732097,4.988689,4.554772,7.082739,6.963382,7.911234,5.237988,6.400569,5.418275,5.01001,6.103039,6.143505,6.436842,5.441062,7.272445,5.847109,5.181419,6.729328,9.626346,10.28117,9.087323,7.744374,7.6286,9.628955,8.783612,8.694363,6.597275,8.725233,7.480618,11.46561,8.860053,8.584526,9.33602,9.189068,8.759685,8.803293,9.545537,8.412483,8.239616,8.369098,10.80445,9.55221,8.987902,10.19179,9.005086,7.700596,10.09006,8.270632,10.69045,9.279632,7.877945,8.272313,9.045836,8.285373,8.80549,9.454775,11.32777,9.322703,7.918822,7.070981,10.24486,9.436471,7.930636,10.40602,8.919326,9.777122,10.24073,8.28937,1.197778,1.008481,2.159544,1.761001,2.133575,0.7881158,0.2134069,2.014798,1.795194,1.656499,1.480411,1.032007,2.197551,1.657746,0.7513536,0,1.279691,2.325264,1.786702,2.2468,3.279983,2.224403,2.153407,1.816785,0.8513641,1.354674,1.119938,1.203295,0.762332,0.8611317,2.242661,1.042809,0.9998607,3.058008,1.554187,2.035858,2.09396,2.635428,2.437027,1.695478,1.256029,1.621396,3.017802,4.215673,1.168397,2.985685,1.165566,0.6606804,2.139212,2.370906, + 9.184045,9.415557,9.804071,8.293536,8.095397,9.760628,7.701273,9.327387,8.414608,8.848984,8.76175,8.732399,8.068224,6.637617,7.98503,10.51469,7.758319,8.75996,11.56477,10.20462,8.220548,9.694033,7.202887,7.843312,9.450726,8.47423,8.758269,8.60817,9.110739,7.6013,8.294297,9.125272,6.904664,9.711753,9.566113,8.844282,9.596732,7.69856,7.619004,8.208503,9.469403,8.974395,8.870057,8.449285,8.991502,8.398002,9.53091,8.111818,7.620668,9.626892,8.531497,5.387557,8.306716,6.745832,6.884065,6.975543,7.219531,8.314548,7.258014,6.691265,6.549742,7.364328,7.683562,5.725324,7.258882,6.018791,7.446203,8.476586,7.982796,8.348679,5.188276,6.925353,8.046676,7.952857,7.176064,7.065194,7.283679,7.058307,5.558766,5.99994,7.277132,7.943946,6.787472,6.083354,5.771473,8.127145,7.963749,8.894709,6.436351,7.620901,6.628839,6.288868,7.192918,7.235462,7.541342,6.164329,8.296156,6.918303,6.133934,7.927315,9.893215,10.67761,9.315697,8.24014,8.212702,10.04908,9.118097,9.094698,6.922055,9.094687,7.8538,11.86371,9.036654,9.016511,9.806287,9.777434,9.094968,9.08533,9.930991,8.789177,8.67275,9.014489,11.2741,9.738957,9.420443,10.72799,9.28643,8.356033,10.66395,8.537639,10.99861,9.628037,7.923426,8.777613,9.675365,8.66191,9.362715,10.0663,11.53605,10.04232,8.321012,7.410982,10.48965,10.01407,8.303432,10.87628,9.09193,10.2118,10.6845,8.72631,0.7992293,1.604134,1.141538,0.7301105,1.588071,1.174197,1.076533,1.638879,0.9998618,0.9042774,1.744754,1.07514,1.403224,1.780296,0.9788192,1.279691,0,2.30311,1.51495,1.189419,2.025314,1.343132,1.133394,1.211683,1.226475,0.6789111,1.253765,0.0806738,0.5597681,0.8183131,1.329779,2.137283,0.8063694,1.904617,2.339025,1.225653,1.289176,1.364486,2.68511,1.685393,0.1279081,0.678605,2.049466,3.364533,0.403909,1.989423,0.7153516,1.270723,1.198663,1.525745, + 9.384079,9.713773,10.0301,8.857458,8.019791,9.968893,8.095706,9.394412,8.852361,9.073715,9.045154,9.219509,8.19253,6.904059,7.905191,11.03086,7.928095,8.653661,11.32492,10.27291,8.233218,9.535697,7.379437,8.496445,9.446176,8.295092,8.673403,8.201737,9.209056,8.021421,8.499507,9.229359,6.990952,10.05509,9.368396,9.340809,9.247542,8.210701,7.758521,8.71851,9.53232,8.866033,8.842065,9.041284,8.926021,8.45785,9.782028,7.885829,8.265214,9.877731,7.415918,3.459101,6.558518,4.98185,5.545798,5.766614,6.069037,7.078946,5.757464,5.747491,4.783173,6.023341,6.488037,4.958553,6.061561,4.556404,5.843847,7.235477,6.411358,6.704886,4.262032,5.766796,6.255635,6.071851,5.917388,5.81135,6.131192,5.802617,3.94679,4.355622,5.741733,6.313302,5.362069,4.816311,4.989747,6.608134,6.35105,7.215614,5.509478,6.726711,5.745143,6.181815,5.83614,5.882192,6.208116,4.176399,6.722387,5.52624,4.518317,6.909023,7.590266,8.391925,7.012978,6.004963,6.033985,7.771864,6.822404,6.814602,4.631028,6.806216,5.57086,9.576205,6.738129,6.74738,7.548653,7.585341,6.799455,6.783434,7.644247,6.50347,6.405788,6.87395,9.010546,7.439869,7.149716,8.497682,6.984355,6.233747,8.456023,6.235204,8.697457,7.333859,5.655227,6.543045,7.514438,6.376598,7.153611,7.88817,9.235848,7.957646,6.044803,5.121311,8.186715,7.812923,6.018446,8.614298,6.794012,7.938867,8.413197,6.460531,2.964476,3.295969,3.393376,1.859467,0.9903019,1.551323,2.332443,0.7696452,1.499882,3.201171,0.8604848,1.389147,1.406614,0.6676223,2.803291,2.325264,2.30311,0,0.7993372,1.913161,3.083107,3.63092,3.384962,1.218938,3.025879,1.630144,1.240428,2.259887,2.388506,1.680176,1.623581,2.029508,1.596537,2.495691,1.455285,3.527195,1.435421,3.124905,0.5758858,0.6595688,2.416203,1.772022,4.261997,2.544524,1.906373,4.186568,2.883524,1.6648,1.672318,1.504298, + 9.358433,9.65627,9.999641,8.701869,8.079111,9.944223,7.992184,9.415065,8.740352,9.037252,8.988111,9.093172,8.183685,6.831632,7.964902,10.90524,7.900913,8.729196,11.46307,10.29867,8.263656,9.635756,7.344092,8.307184,9.492087,8.393117,8.741613,8.378688,9.217518,7.908305,8.465239,9.235961,6.982437,9.984076,9.481073,9.212072,9.412265,8.067563,7.740171,8.580451,9.555341,8.943946,8.891762,8.877387,8.989431,8.473805,9.741308,7.996587,8.076925,9.837716,7.837041,4.14141,7.197084,5.616591,6.030293,6.206267,6.490736,7.540156,6.303074,6.090107,5.417291,6.513589,6.930094,5.22316,6.500157,5.07492,6.426797,7.699773,6.987163,7.307862,4.571207,6.188068,6.907605,6.753967,6.376768,6.267865,6.554266,6.259712,4.513588,4.940164,6.299805,6.909436,5.876542,5.265116,5.260503,7.166638,6.941075,7.833306,5.842549,7.062893,6.06581,6.229818,6.330346,6.375566,6.697223,4.886301,7.300909,6.030213,5.093977,7.291376,8.384227,9.191258,7.803517,6.796312,6.811025,8.570748,7.62109,7.613657,5.43033,7.605544,6.370029,10.37553,7.521963,7.545272,8.344948,8.367247,7.598177,7.579345,8.443584,7.302787,7.203322,7.641203,9.80796,8.224355,7.947867,9.288979,7.780041,6.994759,9.242275,7.030475,9.493887,8.132767,6.413834,7.334529,8.288056,7.175903,7.939493,8.666674,10.0217,8.709902,6.84345,5.920638,8.977955,8.597229,6.817732,9.411441,7.57714,8.73735,9.211539,7.257902,2.215859,2.672868,2.594147,1.074871,0.4524455,1.011541,1.735019,0.2381056,0.7295488,2.417954,0.6847714,0.7564621,0.7850794,0.5250133,2.120853,1.786702,1.51495,0.7993372,0,1.220559,2.454553,2.833781,2.585734,0.4590348,2.362278,0.8370207,0.6843402,1.477322,1.669281,0.9971482,0.9769818,1.860829,0.8833688,1.938463,1.544819,2.734527,0.7624988,2.365119,1.269613,0.3460426,1.632206,0.9766622,3.464265,2.531151,1.127084,3.389732,2.132348,1.175675,0.9811959,0.9420895, + 10.16933,10.42901,10.80016,9.365746,8.988873,10.75157,8.728412,10.27489,9.457745,9.839032,9.767297,9.789391,9.02359,7.619916,8.876115,11.58671,8.72435,9.648976,12.42564,11.15762,9.143245,10.57242,8.165555,8.932378,10.37712,9.33664,9.654265,9.390915,10.06618,8.6342,9.274925,10.08252,7.836973,10.73855,10.4304,9.904124,10.40805,8.754829,8.574883,9.267741,10.41657,9.864357,9.785117,9.528663,9.895502,9.336703,10.53236,8.954929,8.706471,10.6288,9.009161,5.347889,8.41594,6.83537,7.231101,7.39106,7.667227,8.729684,7.518129,7.230231,6.636052,7.715081,8.113628,6.325346,7.683579,6.286516,7.646468,8.89014,8.205998,8.528356,5.70615,7.365498,8.124358,7.962663,7.568404,7.45878,7.731119,7.450859,5.73296,6.160409,7.516831,8.129758,7.085747,6.456726,6.366059,8.383145,8.161088,9.053765,6.979116,8.19404,7.19393,7.150613,7.533371,7.57826,7.898008,6.081126,8.519905,7.236517,6.313654,8.446525,9.29267,10.17952,8.690923,7.870755,7.929799,9.579959,8.586126,8.621485,6.427375,8.593842,7.379299,11.35501,8.373802,8.573359,9.386569,9.47196,8.564053,8.508761,9.432269,8.299805,8.236556,8.778663,10.83612,9.074818,8.971445,10.35904,8.706277,8.142628,10.33256,7.95724,10.42024,9.100725,7.176001,8.407128,9.412875,8.174605,9.032675,9.780039,10.8704,9.869252,7.863107,6.917041,9.863807,9.694611,7.81939,10.44318,8.42508,9.753836,10.22913,8.292667,1.968462,2.782939,1.823179,0.4934257,0.9263955,1.726026,2.087484,1.150463,0.5561767,1.915249,1.837056,1.45645,0.5184043,1.728012,2.153989,2.2468,1.189419,1.913161,1.220559,0,1.244353,2.11411,1.815557,0.7693579,2.407794,0.9114392,1.546735,1.222962,1.690364,1.436016,0.3071761,2.783264,1.310797,0.8287579,2.671557,2.09528,0.4781081,1.254594,2.454948,1.556251,1.304235,0.6254089,2.549868,2.188685,1.088726,2.461745,1.888715,1.898207,0.2426529,0.5015995, + 11.20876,11.44054,11.82934,10.3061,10.09864,11.78573,9.725503,11.34687,10.43605,10.87395,10.78705,10.7501,10.08864,8.661369,9.987295,12.52544,9.780413,10.76219,13.55792,12.22549,10.23331,11.69301,9.224135,9.848103,11.4653,10.46565,10.76299,10.55979,11.13165,9.624876,10.31844,11.1465,8.918935,11.73546,11.55933,10.86099,11.56503,9.717248,9.639265,10.22589,11.48888,10.97715,10.88106,10.45843,10.99912,10.41506,11.55622,10.09422,9.627588,11.6522,10.25004,6.541727,9.631137,8.051377,8.47526,8.634621,8.909385,9.97366,8.757517,8.462622,7.852169,8.959198,9.356918,7.545233,8.926912,7.527984,8.879041,10.13419,9.440605,9.756319,6.938744,8.607908,9.333412,9.154957,8.812611,8.702946,8.973333,8.695041,6.966677,7.391006,8.754279,9.359392,8.328246,7.700986,7.587164,9.621173,9.392347,10.27729,8.210566,9.42231,8.422159,8.276972,8.777305,8.822239,9.142194,7.25617,9.754141,8.479848,7.546437,9.682913,10.13998,11.10308,9.522751,8.900181,9.006751,10.52935,9.497126,9.576031,7.393219,9.528507,8.346121,12.26276,9.173823,9.549293,10.37161,10.52599,9.476099,9.384507,10.36107,9.245823,9.220307,9.873215,11.79911,9.865711,9.939911,11.37037,9.576927,9.25188,11.36676,8.836084,11.27728,10.01046,7.906944,9.431143,10.49027,9.123405,10.07572,10.84278,11.64382,10.98724,8.835913,7.87617,10.68324,10.73941,8.774354,11.41193,9.220642,10.70989,11.1837,9.277588,2.60163,3.548303,1.923271,1.602396,2.102582,2.903868,3.088203,2.35274,1.793998,2.320844,3.081314,2.656862,1.691365,2.969391,2.958534,3.279983,2.025314,3.083107,2.454553,1.244353,0,2.195642,1.919555,2.011508,3.17848,2.07039,2.768171,2.093701,2.584647,2.572949,1.482624,3.968428,2.467318,0.6447609,3.91066,2.289246,1.69341,0.9525154,3.647387,2.79542,2.08837,1.759081,2.21731,2.284422,2.135745,2.121927,2.545403,3.063869,1.475937,1.578824, + 9.577088,9.747174,10.16714,8.501089,8.667261,10.13469,8.030661,9.789663,8.693871,9.237416,9.11965,8.9725,8.535833,7.085054,8.562565,10.69257,8.211946,9.328206,12.1441,10.64602,8.74272,10.26617,7.674196,8.011578,9.948275,9.087256,9.315538,9.328199,9.561642,7.919551,8.710302,9.57266,7.436764,10.01005,10.16116,9.075429,10.26645,7.958601,8.09411,8.45154,9.930393,9.538047,9.394737,8.634566,9.53254,8.889745,9.886405,8.758586,7.802757,9.980186,9.556186,6.694982,9.547373,8.004483,8.017576,8.06407,8.282299,9.387554,8.436335,7.692067,7.811088,8.489857,8.753006,6.693993,8.337351,7.207492,8.652711,9.54908,9.173713,9.558127,6.237206,7.997583,9.30123,9.231649,8.277404,8.167132,8.34577,8.161013,6.796207,7.23787,8.465807,9.153355,7.950313,7.212208,6.743813,9.299854,9.167536,10.11034,7.43861,8.57786,7.608887,6.947217,8.326678,8.367317,8.661232,7.476962,9.484403,8.06836,7.362332,8.925962,11.21727,12.01682,10.63395,9.583105,9.55105,11.3902,10.4527,10.43514,8.258825,10.4328,9.193379,13.20243,10.34492,10.35863,11.14927,11.11648,10.42969,10.41311,11.26979,10.12816,10.01505,10.34658,12.61687,11.0477,10.76243,12.07044,10.61378,9.685938,12.0045,9.864133,12.32766,10.96361,9.201676,10.1205,11.01011,10.00099,10.70377,11.40334,12.84604,11.36245,9.662068,8.74839,11.80882,11.35409,9.642548,12.21912,10.39914,11.5536,12.02654,10.06872,1.034896,1.847237,0.2976633,1.854177,2.821715,2.448818,2.020774,2.925888,2.210149,0.5679104,3.080667,2.403094,2.529155,3.123339,1.520802,2.224403,1.343132,3.63092,2.833781,2.11411,2.195642,0,0.3043233,2.470323,1.590703,2.001607,2.583727,1.400513,1.533418,2.122759,2.376461,3.247657,2.137273,2.461674,3.597191,0.20132,2.430358,1.243695,4.028118,3.026549,1.247059,1.892233,0.7942078,4.200685,1.746987,0.7696657,1.059041,2.499823,2.252523,2.58978, + 9.688468,9.871838,10.2858,8.648739,8.736824,10.25097,8.152597,9.886216,8.82753,9.349229,9.237765,9.114578,8.629019,7.1792,8.630591,10.84943,8.307566,9.399782,12.21656,10.74839,8.823967,10.33822,7.764636,8.165875,10.03713,9.147778,9.389667,9.362548,9.660368,8.043551,8.8152,9.672181,7.512825,10.142,10.22762,9.219475,10.31483,8.094621,8.184689,8.592042,10.02744,9.611037,9.47655,8.786837,9.610797,8.978191,10.00626,8.810338,7.953894,10.10065,9.503472,6.518019,9.410499,7.857701,7.925217,7.988066,8.215449,9.318403,8.326792,7.644573,7.662779,8.400979,8.684434,6.654392,8.265186,7.09249,8.53132,9.480258,9.059431,9.435964,6.171394,7.927138,9.157174,9.074092,8.19712,8.086506,8.27923,8.080105,6.659208,7.101008,8.351975,9.030985,7.846577,7.120578,6.70322,9.193263,9.047671,9.985641,7.390217,8.545291,7.567706,6.991982,8.234552,8.275949,8.574614,7.296195,9.371452,7.969749,7.230071,8.880928,10.96168,11.7765,10.37483,9.360484,9.342249,11.15391,10.20646,10.19752,8.015972,10.19108,8.954434,12.96107,10.08065,10.12549,10.92045,10.90617,10.18359,10.16052,11.02895,9.887893,9.78263,10.14702,12.38625,10.78344,10.52875,11.85057,10.36078,9.489046,11.7908,9.610726,12.07561,10.71835,8.926735,9.898398,10.80695,9.760924,10.48889,11.19663,12.58193,11.17555,9.426038,8.506191,11.54992,11.14171,9.402649,11.98901,10.13438,11.31914,11.7928,9.836744,1.016051,1.920255,0.008413377,1.577338,2.547695,2.283417,1.942797,2.66441,1.938368,0.5575419,2.87757,2.207934,2.241789,2.904419,1.50292,2.153407,1.133394,3.384962,2.585734,1.815557,1.919555,0.3043233,0,2.204886,1.619803,1.763595,2.387007,1.199906,1.419636,1.941055,2.08312,3.148258,1.939358,2.161285,3.444963,0.3714362,2.145734,0.9682883,3.80328,2.797357,1.055242,1.627395,0.9181329,3.896646,1.531498,0.8638857,1.015312,2.352911,1.961086,2.296034, + 9.599617,9.881052,10.23692,8.878543,8.363347,10.18444,8.198823,9.678049,8.94,9.274054,9.214932,9.284225,8.436361,7.059019,8.249675,11.09214,8.145832,9.018712,11.77418,10.56204,8.534325,9.933801,7.587255,8.466795,9.766479,8.69329,9.02787,8.711347,9.475312,8.110311,8.704823,9.492834,7.239903,10.20128,9.784857,9.401506,9.737774,8.253174,7.9899,8.766926,9.819085,9.233951,9.16936,9.048985,9.272914,8.737172,9.974179,8.3033,8.237948,10.0707,8.25278,4.6003,7.654398,6.074026,6.464304,6.629488,6.908822,7.966653,6.748771,6.486839,5.874748,6.948144,7.352659,5.5985,6.922567,5.517365,6.878275,8.126837,7.437256,7.761544,4.963938,6.606655,7.365845,7.212996,6.804483,6.695084,6.972591,6.687083,4.964628,5.393015,6.747605,7.362424,6.316982,5.692602,5.637691,7.613847,7.393237,8.288528,6.237154,7.455143,6.45588,6.516537,6.766008,6.810987,7.131285,5.343878,7.751234,6.46834,5.545527,7.697084,8.758725,9.592606,8.170294,7.223159,7.250914,8.978403,8.013703,8.0202,5.830896,8.005765,6.77588,10.77471,7.876201,7.958225,8.762647,8.803773,7.991045,7.960065,8.844583,7.705576,7.617649,8.086478,10.22221,8.579006,8.359674,9.71575,8.159907,7.442544,9.674961,7.409659,9.87526,8.526791,6.734648,7.761151,8.730141,7.579124,8.372537,9.105726,10.37747,9.160852,7.253142,6.321706,9.345401,9.031742,7.221571,9.826616,7.93011,9.147408,9.622207,7.672754,1.979596,2.582513,2.213253,0.6438242,0.3793031,1.128854,1.713392,0.4625315,0.2809661,2.106822,1.075992,0.8388741,0.4163551,0.9586761,1.983141,1.816785,1.211683,1.218938,0.4590348,0.7693579,2.011508,2.470323,2.204886,0,2.238063,0.5672286,0.8672381,1.193974,1.503219,0.9573302,0.5596861,2.125191,0.8193378,1.529971,1.925236,2.391384,0.3478992,1.913089,1.722543,0.7874152,1.337872,0.5782417,3.057813,2.398931,0.8782483,2.979497,1.89404,1.308697,0.5363443,0.5962549, + 8.107158,8.310324,8.714055,7.137055,7.120338,8.675748,6.59028,8.287462,7.284803,7.768993,7.666872,7.588522,7.028204,5.581276,7.013569,9.353371,6.709494,7.783904,10.60043,9.154951,7.213499,8.722286,6.162258,6.672966,8.431442,7.528677,7.774931,7.746336,8.064009,6.485099,7.226797,8.076644,5.900031,8.592883,8.609758,7.697456,8.695261,6.559066,6.581952,7.064257,8.429059,7.995705,7.866086,7.285929,7.998118,7.372897,8.436768,7.190539,6.453888,8.531942,7.999982,5.501744,8.170917,6.671858,6.531389,6.545592,6.747918,7.854245,6.988341,6.132656,6.485718,6.994448,7.220163,5.127896,6.81141,5.781902,7.23515,8.014949,7.734333,8.138156,4.708667,6.469778,7.949528,7.928279,6.765989,6.656735,6.810747,6.651165,5.442433,5.878655,7.028725,7.735877,6.4905,5.72854,5.178658,7.840715,7.743062,8.695075,5.880783,7.002553,6.042687,5.372629,6.838666,6.877537,7.160673,6.288619,8.040274,6.59584,5.986849,7.361898,10.45152,11.12387,9.905162,8.593157,8.479957,10.47347,9.617897,9.53633,7.426809,9.56385,8.318243,12.3091,9.667472,9.429368,10.18412,10.04038,9.59405,9.629914,10.38664,9.251626,9.084293,9.21912,11.65306,10.36273,9.833071,11.04283,9.831854,8.550442,10.94141,9.094039,11.52291,10.11623,8.652343,9.121842,9.89627,9.124365,9.656717,10.30566,12.14445,10.16679,8.760246,7.903638,11.06701,10.28783,8.768788,11.25453,9.726013,10.62293,11.08745,9.134411,0.6178844,0.3780668,1.623548,1.927413,2.605722,1.491735,0.7343316,2.560307,2.11172,1.063366,2.231019,1.641301,2.537821,2.374847,0.2581989,0.8513641,1.226475,3.025879,2.362278,2.407794,3.17848,1.590703,1.619803,2.238063,0,1.679606,1.785815,1.185452,0.741646,1.367142,2.509957,1.864326,1.479839,3.126139,2.405103,1.389554,2.423313,2.358592,3.221084,2.36859,1.126757,1.835141,2.368275,4.554461,1.385359,2.355847,0.6500814,1.426919,2.384368,2.686387, + 9.258822,9.521068,9.890318,8.471459,8.080067,9.841341,7.82323,9.363496,8.555335,8.9289,8.858607,8.890196,8.112171,6.709797,7.967484,10.69102,7.813159,8.740806,11.52173,10.24619,8.232488,9.66568,7.25433,8.044913,9.466374,8.43138,8.745446,8.499523,9.154743,7.730141,8.364285,9.171089,6.925688,9.83245,9.525366,9.005647,9.511595,7.856142,7.663486,8.369505,9.505181,8.956163,8.874893,8.636793,8.986079,8.425411,9.623057,8.052165,7.817864,9.719517,8.217207,4.825651,7.811289,6.237803,6.494129,6.622437,6.885102,7.964614,6.826196,6.409495,6.039687,6.977779,7.340427,5.479795,6.911663,5.586007,6.98736,8.126126,7.535828,7.88314,4.888107,6.585823,7.537952,7.418117,6.810927,6.700402,6.949278,6.692937,5.080809,5.518231,6.835774,7.480084,6.372586,5.70431,5.522499,7.695784,7.50505,8.421462,6.156216,7.362789,6.363301,6.244107,6.800561,6.844436,7.158352,5.59174,7.85022,6.51379,5.661204,7.636402,9.219689,10.01621,8.640109,7.598329,7.589856,9.39156,8.451122,8.435696,6.2574,8.431698,7.193219,11.2015,8.358927,8.362209,9.156875,9.151669,8.428102,8.413528,9.268979,8.127505,8.01922,8.404882,10.62269,9.061344,8.765593,10.0893,8.614407,7.751205,10.03328,7.865139,10.3276,8.962007,7.244988,8.136378,9.059903,8.000404,8.730822,9.44547,10.85872,9.451693,7.663524,6.74711,9.814411,9.385375,7.642011,10.22543,8.414058,9.556196,10.0297,8.073277,1.417621,2.032281,1.771984,0.4679944,0.9449986,0.8338187,1.216148,0.964561,0.4487275,1.583046,1.166637,0.5958859,0.8703152,1.154671,1.422894,1.354674,0.6789111,1.630144,0.8370207,0.9114392,2.07039,2.001607,1.763595,0.5672286,1.679606,0,0.7357707,0.6464657,0.9403204,0.5245827,0.8895152,1.898669,0.4024807,1.738753,1.898853,1.897962,0.7590466,1.701985,2.042475,1.035664,0.798795,0.3113089,2.659924,2.902436,0.3121059,2.590468,1.332281,0.9979176,0.7846497,1.033146, + 8.736808,9.02285,9.375154,8.041379,7.49629,9.321944,7.346895,8.811592,8.091299,8.412261,8.355955,8.439649,7.571122,6.199293,7.382653,10.25003,7.281959,8.151973,10.91064,9.695602,7.667236,9.06796,6.723632,7.639644,8.899293,7.82795,8.160891,7.856218,8.609446,7.260321,7.842238,8.627095,6.373808,9.345735,8.920003,8.55776,8.87918,7.411031,7.125084,7.9245,8.952562,8.367238,8.302122,8.214749,8.405785,7.870606,9.113556,7.439346,7.409837,9.21006,7.491974,4.136396,7.088912,5.519194,5.75893,5.891051,6.156721,7.233003,6.091253,5.694905,5.321758,6.242682,6.61018,4.780316,6.181011,4.850865,6.255707,7.394374,6.802566,7.153005,4.17135,5.85673,6.820234,6.712423,6.077818,5.967385,6.220851,5.959854,4.352059,4.790717,6.101682,6.749499,5.63685,4.970214,4.821524,6.960956,6.773537,7.693137,5.442615,6.654234,5.654057,5.649822,6.06518,6.109113,6.42345,4.911466,7.1169,5.778058,4.931645,6.917446,8.74201,9.480061,8.179842,7.011465,6.967967,8.843288,7.938851,7.893218,5.739893,7.903173,6.658024,10.6672,7.924161,7.805489,8.586309,8.533737,7.915381,7.926141,8.735792,7.594597,7.460724,7.763718,10.05616,8.623231,8.21,9.494188,8.127985,7.104136,9.423256,7.383223,9.832749,8.444857,6.877417,7.54778,8.426477,7.467092,8.123547,8.81972,10.41348,8.788572,7.117273,6.225132,9.348985,8.772215,7.108981,9.657721,7.981513,9.00202,9.472813,7.513331,1.776656,2.05976,2.395124,1.18388,1.08882,0.3327981,1.098929,0.9209413,0.9929039,2.084674,0.4999364,0.1807787,1.283553,0.5954235,1.567348,1.119938,1.253765,1.240428,0.6843402,1.546735,2.768171,2.583727,2.387007,0.8672381,1.785815,0.7357707,0,1.187996,1.180495,0.4756332,1.409193,1.258848,0.4477957,2.360952,1.163647,2.445925,1.20874,2.435327,1.486091,0.5868101,1.337908,1.031815,3.30311,3.196811,0.8641323,3.242035,1.701277,0.4913583,1.351721,1.463169, + 9.115057,9.348607,9.735905,8.231729,8.021295,9.6921,7.635121,9.256127,8.349965,8.780264,8.694111,8.669104,7.997203,6.567923,7.910807,10.45315,7.687866,8.685775,11.48978,10.13378,8.147815,9.619534,7.132112,7.78335,9.378367,8.398943,8.684384,8.530429,9.039896,7.53561,8.224859,9.054535,6.832141,9.645899,9.491046,8.781285,9.519888,7.635016,7.547924,8.145344,9.398144,8.900282,8.797059,8.388292,8.918007,8.326119,9.463088,8.035787,7.560275,9.559115,8.450917,5.31862,8.231771,6.671939,6.804766,6.895458,7.139169,8.234348,7.18002,6.610593,6.476028,7.284902,7.603291,5.644726,7.178688,5.941003,7.369348,8.396388,7.905343,8.272054,5.107699,6.845069,7.972639,7.880822,7.09618,6.985311,7.203314,6.978436,5.483234,5.924522,7.199517,7.867279,6.708924,6.003865,5.690859,8.049049,7.886829,8.818428,6.355678,7.540285,6.54818,6.21312,7.113655,7.156161,7.461817,6.096342,8.21863,6.839411,6.057986,7.846648,9.848517,10.62648,9.272802,8.183179,8.151656,9.996546,9.069522,9.042774,6.87263,9.044316,7.80259,11.81284,8.996435,8.962985,9.751203,9.716778,9.046341,9.039467,9.880157,8.738297,8.619011,8.951038,11.2195,9.698519,9.367059,10.67004,9.2407,8.291909,10.60422,8.492284,10.95214,9.57897,7.889895,8.720448,9.612824,8.610975,9.303351,10.00468,11.49511,9.975987,8.268622,7.361153,10.44637,9.953983,8.2525,10.82154,9.051958,10.1586,10.63101,8.67241,0.7946509,1.561762,1.207961,0.7506533,1.572431,1.098233,1.001822,1.610712,0.9961785,0.941604,1.681875,1.008384,1.407999,1.724179,0.9336596,1.203295,0.0806738,2.259887,1.477322,1.222962,2.093701,1.400513,1.199906,1.193974,1.185452,0.6464657,1.187996,0,0.4960195,0.7450049,1.346601,2.05669,0.7402073,1.956183,2.263496,1.275655,1.293169,1.444259,2.630554,1.634733,0.1566732,0.6828847,2.117362,3.387441,0.3537566,2.058875,0.7094334,1.191891,1.216851,1.537572, + 8.625799,8.855969,9.245107,7.735722,7.54879,9.201945,7.141523,8.772509,7.855017,8.290485,8.202466,8.173432,7.512948,6.080288,7.438922,9.957134,7.202054,8.213586,11.02156,9.648902,7.669317,9.148826,6.647213,7.287543,8.898367,7.932831,8.210749,8.083591,8.555078,7.041533,7.736572,8.569422,6.352996,9.151985,9.023465,8.285509,9.064548,7.139442,7.063873,7.64962,8.914517,8.427715,8.319546,7.892292,8.442572,7.844537,8.971724,7.574594,7.064366,9.067677,8.097309,5.187552,8.013967,6.472809,6.505599,6.570722,6.801594,7.903129,6.910845,6.24409,6.279959,6.981379,7.269608,5.263095,6.849057,5.678842,7.121684,8.065072,7.645715,8.026941,4.759479,6.511807,7.768662,7.704289,6.778624,6.667956,6.865493,6.661498,5.262887,5.704517,6.937942,7.622063,6.428628,5.700943,5.310782,7.776338,7.637108,8.578456,5.989285,7.158183,6.173124,5.750528,6.814934,6.856317,7.155143,5.973051,7.957121,6.550717,5.82899,7.481251,9.922169,10.65019,9.360301,8.162286,8.093882,10.00982,9.115386,9.062404,6.916773,9.076285,7.830345,11.83732,9.103137,8.969713,9.743705,9.659986,9.091846,9.105806,9.907185,8.766785,8.624597,8.868608,11.21425,9.802646,9.374292,10.63654,9.307686,8.203937,10.55477,8.563333,11.0113,9.620248,8.042991,8.696743,9.538278,8.639264,9.259065,9.93842,11.59357,9.862491,8.285915,7.400837,10.52947,9.902099,8.281495,10.81555,9.160281,10.16623,10.63559,8.676564,0.6009706,1.10464,1.426411,1.201339,1.875612,0.9606841,0.5496041,1.850746,1.370086,0.9785254,1.670646,1.010311,1.796232,1.772731,0.4837501,0.762332,0.5597681,2.388506,1.669281,1.690364,2.584647,1.533418,1.419636,1.503219,0.741646,0.9403204,1.180495,0.4960195,0,0.7116276,1.773137,1.728626,0.7946551,2.447554,2.073117,1.361994,1.681797,1.882514,2.665469,1.731017,0.506921,1.098986,2.314146,3.815996,0.6437714,2.272527,0.5317172,0.979257,1.649563,1.945999, + 8.735032,8.999144,9.367017,7.959222,7.557021,9.317756,7.303392,8.838918,8.037392,8.405401,8.336169,8.374459,7.587637,6.186362,7.444553,10.17743,7.288843,8.218138,11.00161,9.72161,7.708241,9.143877,6.729988,7.537562,8.942122,7.910586,8.222371,7.987787,8.63018,7.211125,7.84041,8.646541,6.401157,9.311809,9.004641,8.490392,8.996365,7.340944,7.138979,7.854526,8.980606,8.433472,8.350954,8.126196,8.462625,7.900874,9.100149,7.533032,7.309793,9.196625,7.771515,4.577719,7.488875,5.927519,6.089278,6.195682,6.448501,7.537114,6.450403,5.947505,5.731447,6.571145,6.908802,5.002227,6.481908,5.210147,6.632695,7.699016,7.171875,7.534282,4.432141,6.151634,7.228368,7.135931,6.391198,6.280381,6.512718,6.273247,4.741809,5.182765,6.467183,7.129719,5.984321,5.291884,5.046269,7.320069,7.150442,8.079243,5.693243,6.892074,5.894548,5.722693,6.397494,6.440547,6.749621,5.357363,7.485578,6.11851,5.31779,7.179507,9.215142,9.955672,8.651133,7.484307,7.434805,9.318674,8.414071,8.368781,6.215085,8.37878,7.133655,11.14281,8.392125,8.280615,9.060482,9.000944,8.390616,8.399936,9.211424,8.070228,7.935798,8.224849,10.5305,9.09187,8.685145,9.965427,8.601738,7.563572,9.891918,7.856477,10.30727,8.920268,7.33276,8.020289,8.889738,7.942724,8.593045,9.284959,10.88343,9.240622,7.592794,6.700533,9.821054,9.240391,7.584608,10.13201,8.449174,9.477174,9.947807,7.988327,1.303014,1.676838,1.948979,0.9794069,1.28883,0.363989,0.7606477,1.204719,0.944011,1.612648,0.9742129,0.2998682,1.337498,1.062291,1.131165,0.8611317,0.8183131,1.680176,0.9971482,1.436016,2.572949,2.122759,1.941055,0.9573302,1.367142,0.5245827,0.4756332,0.7450049,0.7116276,0,1.394166,1.40392,0.1387347,2.263121,1.522727,1.978467,1.235687,2.102207,1.960778,1.021214,0.8858297,0.8255506,2.859187,3.35541,0.4757836,2.802502,1.226642,0.4971067,1.29931,1.512275, + 10.1133,10.38522,10.74799,9.353373,8.898958,10.69719,8.693808,10.20305,9.429758,9.785564,9.72084,9.768092,8.957026,7.567657,8.785583,11.57155,8.662718,9.556213,12.31926,11.08677,9.063739,10.47441,8.103783,8.930466,10.29692,9.235219,9.563986,9.263933,9.997836,8.602558,9.218338,10.01488,7.764077,10.7007,10.32775,9.884188,10.28809,8.734791,8.509442,9.248418,10.34438,9.771556,9.701584,9.520139,9.807707,9.262957,10.48295,8.847833,8.702977,10.57946,8.806458,5.071724,8.151632,6.571394,7.006993,7.179546,7.461411,8.514906,7.278111,7.045321,6.37212,7.49038,7.903131,6.158149,7.473084,6.051354,7.396621,8.674741,7.958582,8.273765,5.522788,7.158991,7.856366,7.686634,7.351885,7.242798,7.525081,7.234699,5.484606,5.908428,7.27348,7.876768,6.853328,6.240053,6.19737,8.140628,7.909773,8.795396,6.795907,8.014244,7.015129,7.054529,7.307249,7.352448,7.673953,5.798196,8.272006,7.007188,6.064114,8.253912,8.987491,9.87239,8.386564,7.565799,7.628663,9.272812,8.279204,8.31435,6.120243,8.286682,7.072224,11.048,8.071252,8.266498,9.079977,9.168999,8.257116,8.202689,9.125122,7.99263,7.929837,8.479798,10.52915,8.77257,8.664478,10.05349,8.400337,7.845665,10.02827,7.651163,10.11452,8.793789,6.879107,8.101966,9.112114,7.867434,8.7288,9.477885,10.56871,9.57407,7.556142,6.609886,9.559774,9.390967,7.512237,10.13628,8.122779,9.446744,9.922042,7.985981,2.12767,2.877653,2.090995,0.6001313,0.6332798,1.636098,2.104993,0.8729404,0.4502419,2.130752,1.631459,1.351193,0.2173992,1.498738,2.252221,2.242661,1.329779,1.623581,0.9769818,0.3071761,1.482624,2.376461,2.08312,0.5596861,2.509957,0.8895152,1.409193,1.346601,1.773137,1.394166,0,2.666527,1.258757,0.9709654,2.484292,2.342283,0.2159859,1.561696,2.175629,1.321591,1.453704,0.6748273,2.845035,2.044846,1.136308,2.758145,2.044533,1.814586,0.1323465,0.2134713, + 7.497916,7.796159,8.138878,6.865911,6.238503,8.083655,6.138101,7.560601,6.889007,7.176445,7.127816,7.246379,6.325143,4.97172,6.124758,9.059454,6.04069,6.89353,9.65277,8.444542,6.413039,7.809112,5.483578,6.48791,7.644085,6.569188,6.902868,6.607651,7.360852,6.056527,6.60453,7.378963,5.125089,8.125394,7.66141,7.36617,7.626135,6.225785,5.880797,6.73728,7.70126,7.108764,7.045915,7.045389,7.148263,6.619318,7.8805,6.18132,6.256844,7.976903,6.394237,3.655939,6.325956,4.812022,4.776979,4.847201,5.085136,6.183156,5.188836,4.556274,4.624418,5.252894,5.550848,3.60089,5.127929,3.962454,5.411321,6.345193,5.927388,6.316695,3.051033,4.792551,6.095663,6.065272,5.052605,4.941843,5.149219,4.935263,3.585733,4.02436,5.21951,5.912423,4.703017,3.97233,3.645584,6.05224,5.924478,6.87089,4.301492,5.493421,4.497885,4.391357,5.086312,5.127692,5.426973,4.43998,6.237529,4.823065,4.138611,5.791435,8.796335,9.382573,8.282397,6.815086,6.663409,8.722569,7.924082,7.802691,5.765667,7.848452,6.612356,10.56146,8.08672,7.678587,8.408703,8.215421,7.899922,7.97121,8.655833,7.534377,7.335447,7.378748,9.871423,8.767142,8.079265,9.234114,8.17179,6.709486,9.118702,7.451418,9.832751,8.40964,7.196827,7.335534,8.058464,7.40832,7.84493,8.472179,10.51943,8.308324,7.031978,6.224726,9.422754,8.465857,7.058387,9.47416,8.147783,8.863409,9.320924,7.383072,2.233904,1.915963,3.155037,2.366403,2.306265,1.064852,1.232211,2.091332,2.239218,2.681476,1.239332,1.326949,2.541077,1.457414,1.793413,1.042809,2.137283,2.029508,1.860829,2.783264,3.968428,3.247657,3.148258,2.125191,1.864326,1.898669,1.258848,2.05669,1.728626,1.40392,2.666527,0,1.501612,3.60754,0.7172809,3.064651,2.467577,3.485483,1.887562,1.594484,2.156999,2.209801,4.036692,4.382097,1.870246,3.998526,2.194825,0.9073148,2.602855,2.720038, + 8.864467,9.130763,9.497183,8.095147,7.678606,9.447516,7.436503,8.965098,8.171423,8.535313,8.467339,8.50934,7.714872,6.316449,7.565947,10.31295,7.417103,8.339099,11.11931,9.848071,7.832512,9.263593,6.858179,7.674513,9.066384,8.029053,8.343996,8.098119,8.757111,7.34468,7.969712,8.773623,6.526814,9.44437,9.123022,8.625432,9.109457,7.476041,7.26642,7.989676,9.106721,8.554467,8.474329,8.262502,8.584939,8.026534,9.230805,7.649688,7.446625,9.327294,7.847248,4.58186,7.518593,5.952556,6.148023,6.263167,6.520127,7.605205,6.498361,6.030181,5.7557,6.63073,6.978459,5.092215,6.550697,5.257591,6.673158,7.766978,7.215803,7.573013,4.511627,6.222178,7.253748,7.152432,6.455893,6.345163,6.584342,6.337894,4.775808,5.21585,6.512538,7.168849,6.036715,5.353299,5.135594,7.368269,7.191061,8.115834,5.776321,6.97901,5.980389,5.84194,6.455648,6.499031,6.81007,5.358065,7.529842,6.173596,5.353706,7.260074,9.155963,9.910508,8.588067,7.452184,7.413803,9.276478,8.362557,8.32475,6.163809,8.331211,7.087232,11.09745,8.323786,8.240315,9.024294,8.979325,8.339201,8.342673,9.165299,8.023641,7.895837,8.211165,10.49361,9.024374,8.644693,9.936777,8.544322,7.551797,9.867982,7.797816,10.2522,8.870089,7.251756,7.988942,8.87349,7.896188,8.567751,9.266132,10.81773,9.236189,7.549425,6.650615,9.75937,9.217267,7.537851,10.09534,8.380412,9.436599,9.908099,7.948782,1.369605,1.799297,1.947464,0.8668452,1.155383,0.439745,0.8959326,1.082274,0.8085306,1.646818,0.9434692,0.2688129,1.198993,1.004368,1.237501,0.9998607,0.8063694,1.596537,0.8833688,1.310797,2.467318,2.137273,1.939358,0.8193378,1.479839,0.4024807,0.4477957,0.7402073,0.7946551,0.1387347,1.258757,1.501612,0,2.13923,1.563902,2.002664,1.097678,2.036194,1.910702,0.9426817,0.8906642,0.7108742,2.855835,3.216936,0.4248557,2.795422,1.289924,0.5969412,1.166477,1.374102, + 10.99215,11.24729,11.62157,10.16764,9.817596,11.57374,9.543174,11.10165,10.26886,10.66108,10.58683,10.59661,9.84942,8.442161,9.704853,12.38938,9.549046,10.47773,13.2537,11.98411,9.971239,11.40108,8.990402,9.727315,11.20512,10.16507,10.48299,10.21436,10.89226,9.447565,10.09809,10.90844,8.664184,11.55414,11.25877,10.71048,11.23357,9.561838,9.400533,10.07404,11.24337,10.69311,10.61347,10.32788,10.72413,10.16388,11.35284,9.782765,9.502723,11.44923,9.774626,5.951079,9.054193,7.477079,7.964895,8.144714,8.428786,9.478074,8.221075,8.016286,7.278273,8.447598,8.868552,7.126889,8.43862,7.000612,8.326493,9.637528,8.891462,9.19513,6.493712,8.126191,8.750811,8.559527,8.314468,8.205716,8.492365,8.197523,6.419188,6.83703,8.212421,8.801213,7.804509,7.203025,7.16646,9.079907,8.836874,9.709425,7.766854,8.985072,7.985848,7.979279,8.263483,8.308898,8.631559,6.652801,9.203929,7.961,6.996106,9.224323,9.500649,10.45904,8.884637,8.258493,8.370981,9.884656,8.853354,8.931275,6.748643,8.883992,7.701468,11.61956,8.538961,8.904705,9.727163,9.886329,8.83228,8.742654,9.716779,8.601113,8.575937,9.240248,11.15435,9.232359,9.295196,10.72687,8.935494,8.622515,10.72486,8.193851,10.63745,9.366835,7.280257,8.788848,9.853919,8.478667,9.434965,10.20414,11.01367,10.35913,8.191322,7.231455,10.04693,10.09866,8.129594,10.76718,8.586337,10.06515,10.53898,8.633246,2.613321,3.504157,2.167028,1.297947,1.541652,2.553759,2.888445,1.801598,1.3694,2.438996,2.601992,2.280888,1.153604,2.46315,2.882673,3.058008,1.904617,2.495691,1.938463,0.8287579,0.6447609,2.461674,2.161285,1.529971,3.126139,1.738753,2.360952,1.956183,2.447554,2.263121,0.9709654,3.60754,2.13923,0,3.455116,2.507521,1.186184,1.284319,3.068033,2.284497,1.999385,1.443526,2.660462,1.774037,1.890331,2.564822,2.542829,2.726677,1.009802,1.009805, + 7.935033,8.260358,8.580519,7.407812,6.594615,8.520332,6.640747,7.956729,7.397646,7.622694,7.591569,7.765735,6.746076,5.448892,6.480037,9.576534,6.477872,7.236203,9.943399,8.837468,6.797613,8.131072,5.92757,7.054884,8.01716,6.888189,7.252704,6.844551,7.767688,6.567026,7.048513,7.787501,5.543433,8.600633,7.970443,7.887215,7.882314,6.75954,6.309753,7.266272,8.095478,7.449882,7.413948,7.593036,7.503516,7.017974,8.330698,6.485275,6.823744,8.426544,6.339493,3.121518,5.968658,4.412739,4.595332,4.730537,5.000234,6.071984,4.934832,4.561892,4.217921,5.079051,5.450956,3.679632,5.021368,3.694029,5.110735,6.233175,5.652061,6.011799,3.038725,4.699348,5.712366,5.634477,4.915322,4.804991,5.06427,4.797395,3.219765,3.661026,4.948637,5.607323,4.475883,3.806942,3.71759,5.804753,5.628572,6.556516,4.311975,5.529962,4.530866,4.749438,4.901708,4.94559,5.259804,3.908731,5.966049,4.615528,3.795145,5.775164,8.116309,8.73767,7.593035,6.191878,6.075691,8.082622,7.256512,7.152768,5.083732,7.189826,5.948264,9.920536,7.388072,7.037931,7.784273,7.637443,7.232451,7.291498,8.005103,6.876304,6.693419,6.824306,9.251963,8.072046,7.440648,8.637724,7.492698,6.156777,8.537701,6.766403,9.165273,7.747657,6.482296,6.718911,7.499115,6.749579,7.251743,7.905842,9.832342,7.797604,6.378665,5.549554,8.740037,7.884099,6.39677,8.85366,7.448722,8.228672,8.690817,6.742532,2.649376,2.528859,3.452591,2.344898,1.99124,1.165364,1.691736,1.74021,2.117261,3.050912,0.8607589,1.311738,2.315195,1.038191,2.276519,1.554187,2.339025,1.455285,1.544819,2.671557,3.91066,3.597191,3.444963,1.925236,2.405103,1.898853,1.163647,2.263496,2.073117,1.522727,2.484292,0.7172809,1.563902,3.455116,0,3.432947,2.269825,3.593495,1.20338,1.212412,2.395662,2.194461,4.3601,3.948163,1.986503,4.308847,2.59294,1.097404,2.454454,2.481608, + 9.38624,9.559644,9.978081,8.320416,8.46906,9.945046,7.842249,9.59572,8.508779,9.04664,8.930376,8.790031,8.341173,6.890421,8.364175,10.51537,8.017704,9.130292,11.94642,10.45328,8.546106,10.06837,7.478972,7.833187,9.752958,8.88808,9.117955,9.12722,9.368103,7.731668,8.517951,9.379278,7.239304,9.824573,9.96267,8.89361,10.06627,7.774132,7.898951,8.268514,9.736554,9.340326,9.198252,8.455516,9.335539,8.694287,9.697631,8.558613,7.623209,9.791573,9.360241,6.539478,9.373213,7.834578,7.829911,7.872593,8.088943,9.194495,8.253298,7.495533,7.641871,8.301237,8.559914,6.496503,8.145031,7.026448,8.473327,9.35594,8.991956,9.378808,6.044053,7.804971,9.12988,9.065942,8.086821,7.976644,8.152345,7.970589,6.622917,7.064352,8.284059,8.974184,7.765706,7.024547,6.546447,9.115784,8.987543,9.931767,7.242243,8.379314,7.411483,6.746674,8.138892,8.179333,8.472039,7.32306,9.30218,7.882315,7.187069,8.728944,11.11738,11.90207,10.53801,9.454668,9.41295,11.27211,10.34373,10.31843,8.147476,10.31968,9.078191,13.08838,10.25491,10.23818,11.02515,10.97897,10.32059,10.31034,11.15568,10.01383,9.894098,10.20241,12.49388,10.95751,10.64232,11.93938,10.51136,9.540325,11.8691,9.76235,12.22389,10.85358,9.125811,9.991527,10.868,9.886523,10.56947,11.26342,12.75529,11.21071,9.544226,8.636248,11.71236,11.21792,9.528045,12.0958,10.30973,11.43394,11.9062,9.947396,0.8412671,1.647641,0.3686392,1.794463,2.752129,2.294037,1.834688,2.840304,2.140698,0.3846128,2.945082,2.265184,2.481937,2.998555,1.324031,2.035858,1.225653,3.527195,2.734527,2.09528,2.289246,0.20132,0.3714362,2.391384,1.389554,1.897962,2.445925,1.275655,1.361994,1.978467,2.342283,3.064651,2.002664,2.507521,3.432947,0,2.378739,1.339064,3.905592,2.909982,1.11946,1.816667,0.9888283,4.221739,1.627763,0.9686663,0.8708527,2.336106,2.214804,2.55556, + 9.930072,10.20676,10.56612,9.188803,8.704055,10.51447,8.519653,10.01398,9.258185,9.603411,9.541471,9.599346,8.770151,7.386722,8.590508,11.40507,8.47776,9.360264,12.11885,10.89788,8.872253,10.27668,7.918959,8.77097,10.10493,9.036677,9.368824,9.058464,9.810058,8.429702,9.035133,9.827352,7.575286,10.52459,10.12865,9.716012,10.08424,8.566974,8.323113,9.080727,10.15516,9.575555,9.508597,9.357293,9.613299,9.073422,10.30221,8.647703,8.542823,10.39874,8.590492,4.872109,7.94593,6.365462,6.791756,6.963621,7.245425,8.299103,7.065073,6.830281,6.166156,7.275212,7.687189,5.945243,7.257139,5.837402,7.185854,8.458966,7.747208,8.064443,5.308001,6.943005,7.652343,7.487067,7.136142,7.027027,7.309095,7.018936,5.273301,5.69816,7.061121,7.66693,6.63902,6.024292,5.984244,7.928134,7.699444,8.587375,6.581032,7.799625,6.800674,6.858183,7.092211,7.137382,7.458732,5.603515,8.060769,6.79249,5.853174,8.038292,8.866458,9.734088,8.269647,7.405844,7.457514,9.12939,8.145227,8.170689,5.977047,8.14747,6.927276,10.91221,7.961644,8.118099,8.928838,9.002264,8.122935,8.076531,8.986339,7.851227,7.780009,8.304021,10.38185,8.663807,8.517376,9.895871,8.275023,7.666693,9.865567,7.525131,9.990208,8.6595,6.786819,7.9428,8.940041,7.725555,8.564828,9.309006,10.4614,9.392382,7.40921,6.467404,9.443977,9.226211,7.369407,9.98798,8.014038,9.301717,9.776978,7.835831,2.086452,2.78347,2.153859,0.5874205,0.4528925,1.451721,1.969308,0.6728719,0.3125903,2.137457,1.415857,1.163444,0.115235,1.283147,2.165194,2.09396,1.289176,1.435421,0.7624988,0.4781081,1.69341,2.430358,2.145734,0.3478992,2.423313,0.7590466,1.20874,1.293169,1.681797,1.235687,0.2159859,2.467577,1.097678,1.186184,2.269825,2.378739,0,1.709016,1.977774,1.106361,1.416506,0.6110008,2.946475,2.143499,1.038034,2.862491,2.001667,1.631377,0.2370344,0.2769731, + 10.45954,10.66821,11.06975,9.489299,9.423379,11.03035,8.948385,10.62671,9.643025,10.12204,10.02315,9.94445,9.366504,7.924815,9.31419,11.70183,9.051246,10.08826,12.89921,11.49874,9.535604,11.02469,8.499928,9.018687,10.76106,9.812419,10.08381,9.964844,10.40598,8.843539,9.575865,10.41939,8.219167,10.95147,10.90191,10.05258,10.94705,8.9163,8.918483,9.420337,10.76858,10.30191,10.18711,9.634931,10.31322,9.704555,10.79315,9.4563,8.801977,10.88848,9.872059,6.493689,9.508266,7.932267,8.18395,8.29732,8.550654,9.638987,8.526308,8.041327,7.733694,8.666797,9.01096,7.083032,8.58392,7.285741,8.68934,9.800857,9.237568,9.584826,6.530635,8.253839,9.230969,9.098871,8.491459,8.380692,8.61487,8.373472,6.782197,7.219049,8.536998,9.181902,8.069365,7.389481,7.12856,9.396088,9.207019,10.12238,7.786637,8.977532,7.983102,7.632066,8.491403,8.534874,8.846235,7.247089,9.551939,8.208062,7.362811,9.275613,10.54302,11.43408,9.939056,9.114379,9.158412,10.83375,9.84059,9.875181,7.68109,9.848321,8.632572,12.60957,9.616772,9.825348,10.63715,10.70708,9.818535,9.761471,10.6868,9.553985,9.487835,9.998084,12.08865,10.31673,10.22401,11.60477,9.958652,9.35532,11.57291,9.209984,11.67198,10.35521,8.402577,9.651491,10.6393,9.428692,10.27161,11.01183,12.11024,11.07384,9.115697,8.170952,11.11087,10.93244,9.073262,11.69526,9.667304,11.00717,11.48247,9.543777,1.75041,2.711003,0.9717473,1.302312,2.161028,2.46464,2.426669,2.355688,1.635922,1.40673,2.857755,2.281775,1.76868,2.810735,2.168765,2.635428,1.364486,3.124905,2.365119,1.254594,0.9525154,1.243695,0.9682883,1.913089,2.358592,1.701985,2.435327,1.444259,1.882514,2.102207,1.561696,3.485483,2.036194,1.284319,3.593495,1.339064,1.709016,0,3.634274,2.661151,1.379675,1.431673,1.383242,3.0579,1.62645,1.288471,1.708847,2.592407,1.476777,1.749, + 9.012305,9.359118,9.659108,8.565578,7.606904,9.594826,7.774681,8.997243,8.533223,8.709086,8.692459,8.907789,7.815679,6.570794,7.49255,10.71309,7.562735,8.230236,10.86545,9.870683,7.834736,9.097644,7.021477,8.228016,9.035559,7.861595,8.253634,7.731462,8.819014,7.706657,8.135759,8.840264,6.619805,9.707264,8.924676,9.030132,8.780059,7.913803,7.388929,8.416105,9.133489,8.440751,8.431287,8.753974,8.507911,8.066316,9.417543,7.447492,7.997256,9.512564,6.86114,2.896237,5.987092,4.409186,4.979788,5.209816,5.516147,6.515671,5.1831,5.219357,4.210317,5.455767,5.92952,4.464312,5.504497,3.98606,5.267962,6.671458,5.835496,6.129658,3.754308,5.214626,5.686597,5.511046,5.355858,5.2506,5.577834,5.241754,3.371799,3.779777,5.16654,5.737698,4.791392,4.259392,4.492706,6.032739,5.775269,6.641634,4.985568,6.197902,5.224785,5.784452,5.268094,5.314236,5.640554,3.62649,6.146502,4.956949,3.942657,6.36535,7.256886,7.99994,6.697778,5.557279,5.550647,7.367143,6.453558,6.414572,4.254569,6.420562,5.176547,9.186833,6.44965,6.332593,7.121178,7.110724,6.430132,6.440349,7.254614,6.112941,5.988524,6.374538,8.589096,7.146812,6.736748,8.047398,6.642223,5.726298,7.991031,5.898012,8.346663,6.960285,5.441228,6.095144,7.024447,5.98549,6.688479,7.406604,8.933752,7.440294,5.639616,4.740604,7.865383,7.343538,5.627149,8.19122,6.507726,7.528416,8.000604,6.041876,3.262734,3.442595,3.811636,2.342728,1.54582,1.735269,2.493471,1.304942,1.998352,3.556595,0.9979879,1.661486,1.960796,0.907496,3.025225,2.437027,2.68511,0.5758858,1.269613,2.454948,3.647387,4.028118,3.80328,1.722543,3.221084,2.042475,1.486091,2.630554,2.665469,1.960778,2.175629,1.887562,1.910702,3.068033,1.20338,3.905592,1.977774,3.634274,0,1.006812,2.786315,2.235582,4.702268,3.038363,2.281202,4.632015,3.187247,1.797337,2.212374,2.069919, + 9.077859,9.384363,9.720735,8.458357,7.777409,9.663781,7.731972,9.123093,8.483354,8.759263,8.715596,8.840805,7.897927,6.561148,7.66302,10.65385,7.619534,8.42454,11.14753,10.00602,7.968554,9.326658,7.064243,8.074417,9.194351,8.083645,8.438511,8.055113,8.928325,7.650858,8.186214,8.947231,6.695344,9.716121,9.169425,8.960534,9.091236,7.819499,7.456379,8.331281,9.262901,8.638938,8.592787,8.636711,8.687526,8.182262,9.464937,7.684343,7.843602,9.56122,7.491122,3.832849,6.871178,5.291264,5.685426,5.860252,6.14474,7.194324,5.962542,5.746781,5.092073,6.168858,6.584069,4.88559,6.154127,4.73264,6.090877,7.353989,6.649883,6.97462,4.229127,5.842061,6.585284,6.440908,6.031012,5.922064,6.208262,5.913923,4.177219,4.605878,5.960655,6.575271,5.533486,4.919307,4.922353,6.827092,6.605908,7.502498,5.499705,6.720352,5.723938,5.928571,5.98586,6.031024,6.352395,4.586933,6.963843,5.686382,4.758145,6.946421,8.219446,8.992283,7.648565,6.56326,6.55562,8.363895,7.435086,7.40933,5.237924,7.409703,6.168445,10.17848,7.381734,7.332122,8.124185,8.116703,7.411878,7.40819,8.245765,7.103927,6.988622,7.374582,9.591014,8.082571,7.735891,9.053885,7.609633,6.723182,8.997726,6.862058,9.319709,7.944324,6.312,7.101239,8.027391,6.976638,7.695222,8.411445,9.87659,8.429999,6.635792,5.726423,8.82071,8.350007,6.618159,9.193456,7.438236,8.527052,9.000009,7.04238,2.312283,2.64657,2.805725,1.359353,0.7800719,0.909666,1.685252,0.5281213,1.039732,2.570445,0.3654385,0.7296986,1.131108,0.179497,2.144076,1.695478,1.685393,0.6595688,0.3460426,1.556251,2.79542,3.026549,2.797357,0.7874152,2.36859,1.035664,0.5868101,1.634733,1.731017,1.021214,1.321591,1.594484,0.9426817,2.284497,1.212412,2.909982,1.106361,2.661151,1.006812,0,1.791295,1.240577,3.695498,2.790752,1.282261,3.625517,2.232495,1.042597,1.319816,1.286487, + 9.127831,9.353992,9.745586,8.220563,8.055703,9.703106,7.637964,9.277793,8.347687,8.792074,8.702,8.662475,8.018044,6.583758,7.945818,10.44097,7.70647,8.720494,11.52825,10.15364,8.175895,9.655683,7.152094,7.766775,9.404659,8.439234,8.717668,8.585207,9.059886,7.536905,8.239439,9.074096,6.859513,9.647496,9.530069,8.773714,9.568796,7.629304,7.569074,8.138351,9.419791,8.934631,8.826237,8.374669,8.949434,8.350494,9.471552,8.080148,7.544985,9.567405,8.548931,5.463243,8.364139,6.80718,6.918689,7.002263,7.242128,8.33956,7.301475,6.703596,6.611717,7.397818,7.707593,5.731653,7.284114,6.063589,7.495607,8.501606,8.029165,8.399082,5.206398,6.949281,8.107416,8.020035,7.205141,7.094295,7.306214,7.087537,5.614185,6.05575,7.322707,7.994187,6.827588,6.116477,5.778415,8.169921,8.012796,8.946631,6.448638,7.627593,6.637976,6.256258,7.227797,7.270019,7.57393,6.242194,8.342109,6.956044,6.187558,7.94038,10.00509,10.78284,9.429166,8.337885,8.304113,10.15265,9.226157,9.199008,7.029212,9.200792,7.958954,11.96924,9.152303,9.118861,9.90661,9.869466,9.202973,9.196112,10.03657,8.894707,8.774834,9.101626,11.37506,9.85444,9.522969,10.82426,9.397338,8.441914,10.75747,8.648901,11.10881,9.735573,8.043617,8.875058,9.76415,8.767377,9.456838,10.15669,11.65114,10.12368,8.424768,7.517696,10.60279,10.10703,8.408903,10.97705,9.20777,10.31455,10.78688,8.828188,0.6740175,1.504792,1.063157,0.8535929,1.714842,1.231123,1.047016,1.761535,1.127769,0.7858865,1.833778,1.15762,1.530398,1.879596,0.8857572,1.256029,0.1279081,2.416203,1.632206,1.304235,2.08837,1.247059,1.055242,1.337872,1.126757,0.798795,1.337908,0.1566732,0.506921,0.8858297,1.453704,2.156999,0.8906642,1.999385,2.395662,1.11946,1.416506,1.379675,2.786315,1.791295,0,0.8062092,1.973374,3.484628,0.5103598,1.917352,0.5908941,1.312865,1.322186,1.651242, + 9.548708,9.805684,10.17849,8.740495,8.381921,10.13044,8.103913,9.659327,8.832617,9.217801,9.14453,9.163997,8.406406,6.998807,8.269543,10.96138,8.105612,9.043284,11.8271,10.54151,8.531161,9.969342,7.547009,8.307986,9.76498,8.736133,9.047236,8.808986,9.449375,8.009399,8.654593,9.465461,7.222567,10.11431,9.830186,9.278717,9.819872,8.129426,7.957432,8.642333,9.801103,9.258603,9.17467,8.903654,9.287104,8.722119,9.910116,8.358287,8.081884,10.00653,8.521755,5.066922,8.077324,6.500807,6.788678,6.922853,7.187846,8.264817,7.111675,6.71756,6.302179,7.272608,7.641839,5.790149,7.212736,5.872482,7.265663,8.426188,7.816941,8.1588,5.195476,6.888083,7.799329,7.668819,7.109447,6.999043,7.251994,6.991494,5.355765,5.791332,7.118893,7.756539,6.662288,6.001403,5.832704,7.980733,7.782972,8.694417,6.464487,7.672112,6.672443,6.54823,7.094442,7.138535,7.453703,5.825536,8.131387,6.805528,5.936888,7.943362,9.334743,10.16031,8.747436,7.772973,7.784379,9.542808,8.584859,8.585144,6.398516,8.573851,7.341058,11.34347,8.45432,8.519326,9.320448,9.342091,8.562107,8.53472,9.41239,8.272424,8.177805,8.610021,10.78257,9.157126,8.921544,10.26564,8.734779,7.960688,10.21828,7.98461,10.44991,9.097482,7.311169,8.311189,9.259685,8.145746,8.915468,9.640274,10.95558,9.66999,7.816218,6.889185,9.922527,9.572773,7.787845,10.38631,8.508274,9.710418,10.18487,8.232553,1.475472,2.203169,1.635775,0.1566859,0.9360706,1.144993,1.463794,1.037094,0.3279085,1.546249,1.42712,0.9030587,0.7255068,1.3825,1.577395,1.621396,0.678605,1.772022,0.9766622,0.6254089,1.759081,1.892233,1.627395,0.5782417,1.835141,0.3113089,1.031815,0.6828847,1.098986,0.8255506,0.6748273,2.209801,0.7108742,1.443526,2.194461,1.816667,0.6110008,1.431673,2.235582,1.240577,0.8062092,0,2.490407,2.719454,0.4699855,2.414558,1.390736,1.307645,0.5506379,0.8569664, + 10.23819,10.38699,10.816,9.102866,9.384376,10.78737,8.678477,10.4718,9.320575,9.898448,9.771174,9.583518,9.224451,7.775429,9.281521,11.27138,8.89792,10.04221,12.8544,11.31887,9.446138,10.97859,8.368026,8.601891,10.64046,9.813574,10.02662,10.07871,10.24111,8.564331,9.382473,10.251,8.148525,10.63706,10.87998,9.68257,11.00374,8.583051,8.786932,9.066699,10.61165,10.25018,10.09655,9.227079,10.23849,9.58395,10.5338,9.494054,8.399889,10.62646,10.34907,7.435905,10.32212,8.772468,8.80967,8.858123,9.076466,10.18175,9.223925,8.484319,8.577941,9.282598,9.547202,7.484868,9.13154,7.992879,9.435611,10.34327,9.959667,10.34078,7.03139,8.791789,10.07127,9.991303,9.071174,8.960867,9.139928,8.954722,7.5705,8.012327,9.251847,9.935867,8.739674,8.004349,7.534896,10.08851,9.951183,10.89184,8.231057,9.366384,8.399891,7.691474,9.118846,9.159627,9.45432,8.213594,10.2709,8.859106,8.139507,9.717562,11.80851,12.64985,11.21443,10.25608,10.24869,12.03321,11.07134,11.0755,8.888006,11.06315,9.831359,13.83237,10.90812,11.00932,11.80902,11.81122,11.04871,11.01399,11.90187,10.76231,10.66753,11.05837,13.27221,11.61026,11.41171,12.74785,11.21331,10.40169,12.6932,10.46305,12.92887,11.58454,9.724142,10.79425,11.71638,10.63571,11.39072,12.10393,13.40774,12.09138,10.30659,9.378762,12.3891,12.04525,10.27791,12.87571,10.96048,12.20076,12.67516,10.72215,1.828743,2.594322,0.9102196,2.415407,3.375959,3.200475,2.813033,3.520338,2.781318,1.36159,3.791102,3.124592,3.029573,3.809949,2.312857,3.017802,2.049466,4.261997,3.464265,2.549868,2.21731,0.7942078,0.9181329,3.057813,2.368275,2.659924,3.30311,2.117362,2.314146,2.859187,2.845035,4.036692,2.855835,2.660462,4.3601,0.9888283,2.946475,1.383242,4.702268,3.695498,1.973374,2.490407,0,4.433616,2.443851,0.09598607,1.852914,3.265556,2.736494,3.050389, + 11.86654,12.17511,12.51004,11.23293,10.54261,12.45243,10.51974,11.90235,11.26941,11.54901,11.50633,11.62365,10.68377,9.351815,10.42802,13.43599,10.40812,11.18261,13.86812,12.78397,10.74451,12.07198,9.853602,10.83582,11.96527,10.83,11.2,10.74626,11.71075,10.43711,10.97568,11.73011,9.48073,12.5066,11.90724,11.74272,11.79198,10.59862,10.24371,11.11142,12.0415,11.3959,11.36211,11.4081,11.45121,10.96256,12.25508,10.4233,10.60582,12.35132,9.854536,5.551717,8.642464,7.124401,7.937006,8.202851,8.51858,9.47825,8.058972,8.254507,6.934819,8.400229,8.914072,7.496624,8.495499,6.924492,8.075983,9.629618,8.645221,8.874902,6.791515,8.219761,8.309606,8.034325,8.331773,8.230124,8.578904,8.220892,6.263594,6.627764,8.022502,8.507167,7.718159,7.25667,7.526429,8.871079,8.55717,9.33963,8.022574,9.232057,8.262613,8.697488,8.210814,8.257217,8.583821,6.125294,8.94473,7.893389,6.800763,9.383928,8.131397,9.190478,7.503078,7.231801,7.455585,8.667251,7.58874,7.739316,5.637465,7.658117,6.560933,10.31353,7.121337,7.752758,8.577314,8.879753,7.56974,7.425353,8.466993,7.400581,7.446082,8.349747,9.943709,7.794126,8.121754,9.613329,7.607469,7.789197,9.65949,6.891429,9.268211,8.091541,5.801474,7.737102,8.905115,7.285681,8.411699,9.212558,9.53809,9.512439,7.049364,6.090381,8.63457,9.066945,6.955737,9.571641,7.162441,8.856702,9.321304,7.504396,4.154532,4.920531,3.903118,2.636841,2.108615,3.501853,4.105714,2.295371,2.455366,4.08892,3.153444,3.217049,2.032429,2.941973,4.296547,4.215673,3.364533,2.544524,2.531151,2.188685,2.284422,4.200685,3.896646,2.398931,4.554461,2.902436,3.196811,3.387441,3.815996,3.35541,2.044846,4.382097,3.216936,1.774037,3.948163,4.221739,2.143499,3.0579,3.038363,2.790752,3.484628,2.719454,4.433616,0,3.174877,4.33785,4.073549,3.677819,2.172072,1.872131, + 9.108776,9.358794,9.735998,8.280381,7.966969,9.689235,7.653201,9.229482,8.378557,8.776543,8.699365,8.707063,7.973963,6.558529,7.855246,10.50181,7.670175,8.629892,11.42281,10.11041,8.107834,9.559382,7.112197,7.844676,9.341039,8.330576,8.631797,8.428329,9.017299,7.557328,8.215552,9.032903,6.795895,9.66433,9.424405,8.821223,9.430397,7.672313,7.524652,8.184778,9.371395,8.845005,8.753759,8.442229,8.869417,8.294376,9.466201,7.958481,7.619074,9.562525,8.246641,5.000234,7.943447,6.37717,6.56332,6.671397,6.924216,8.012872,6.919576,6.420465,6.180237,7.04546,7.384585,5.471028,6.957682,5.678939,7.096795,8.174769,7.63851,7.997046,4.906497,6.627404,7.678366,7.575327,6.866623,6.755816,6.988433,6.748662,5.200439,5.640573,6.934743,7.592793,6.455837,5.766631,5.51554,7.789421,7.614679,8.540237,6.166049,7.362615,6.365891,6.141806,6.87136,6.914521,7.224182,5.774285,7.952453,6.59123,5.778134,7.653237,9.49476,10.27452,8.919184,7.836501,7.811345,9.645498,8.716389,8.691299,6.519796,8.691934,7.450659,11.46073,8.643489,8.612714,9.402379,9.375707,8.693225,8.685762,9.528024,8.386184,8.26892,8.615721,10.8702,9.345491,9.016671,10.32465,8.886983,7.958235,10.26154,8.138542,10.59851,9.226015,7.540892,8.374026,9.275458,8.258891,8.960092,9.665414,11.1419,9.648184,7.917465,7.008499,10.0927,9.611914,7.900412,10.47237,8.699101,9.808064,10.28071,8.32246,1.10617,1.746442,1.53974,0.5967397,1.256719,0.838922,1.000038,1.271094,0.7263932,1.294817,1.34726,0.6901616,1.152467,1.376688,1.127308,1.168397,0.403909,1.906373,1.127084,1.088726,2.135745,1.746987,1.531498,0.8782483,1.385359,0.3121059,0.8641323,0.3537566,0.6437714,0.4757836,1.136308,1.870246,0.4248557,1.890331,1.986503,1.627763,1.038034,1.62645,2.281202,1.282261,0.5103598,0.4699855,2.443851,3.174877,0,2.380681,1.020958,0.9682794,1.016836,1.30343, + 10.26218,10.41518,10.84251,9.13753,9.39523,10.81314,8.704797,10.49133,9.350974,9.922392,9.796998,9.616728,9.242326,7.7926,9.291863,11.31019,8.916337,10.05398,12.86742,11.34055,9.460528,10.99089,8.38453,8.638304,10.65772,9.821933,10.03915,10.07942,10.2612,8.591205,9.404006,10.27135,8.160582,10.66765,10.89055,9.716463,11.00893,8.613679,8.803755,9.09908,10.6314,10.26246,10.11143,9.263296,10.25236,9.600586,10.56056,9.499664,8.435136,10.65345,10.32463,7.376978,10.27388,8.721586,8.773887,8.826908,9.047846,10.15262,9.183366,8.461023,8.52666,9.247819,9.518158,7.463494,9.101433,7.950812,9.391742,10.31425,9.91778,10.29667,7.002682,8.762121,10.02102,9.937285,9.038785,8.928371,9.111403,8.922146,7.522441,7.964259,9.210091,9.89171,8.700724,7.968711,7.513264,10.04879,9.907729,10.84701,8.207449,9.347511,8.378346,7.69405,9.083147,9.124143,9.420186,8.153424,10.22938,8.821584,8.092692,9.695214,11.72654,12.57209,11.13155,10.18376,10.18026,11.95668,10.99216,10.99876,8.810329,10.98526,9.754526,13.75415,10.82383,10.93387,11.73465,11.7421,10.96958,10.93301,11.82407,10.68489,10.59236,10.9924,13.19711,11.52584,11.33604,12.67588,11.13218,10.33659,12.623,10.38196,12.84772,11.50554,9.637045,10.72197,11.64929,10.55838,11.32037,12.03578,13.3231,12.02885,10.23047,9.301126,12.30609,11.97551,10.2007,12.80081,10.87604,12.12473,12.59926,10.64709,1.803195,2.593445,0.8562594,2.33635,3.294157,3.14699,2.779145,3.441914,2.702101,1.332562,3.727659,3.064232,2.94435,3.74244,2.290269,2.985685,1.989423,4.186568,3.389732,2.461745,2.121927,0.7696657,0.8638857,2.979497,2.355847,2.590468,3.242035,2.058875,2.272527,2.802502,2.758145,3.998526,2.795422,2.564822,4.308847,0.9686663,2.862491,1.288471,4.632015,3.625517,1.917352,2.414558,0.09598607,4.33785,2.380681,0,1.823206,3.216291,2.650774,2.962678, + 8.756327,8.960405,9.363891,7.783401,7.755613,9.325388,7.240357,8.933363,7.934203,8.418297,8.31679,8.236601,7.673695,6.228001,7.648074,9.99823,7.35589,8.419812,11.23547,9.802103,7.854426,9.357914,6.807429,7.316485,9.07474,8.158345,8.412162,8.356288,8.710609,7.135122,7.875151,8.723449,6.539657,9.242716,9.242369,8.345143,9.31596,7.207822,7.226878,7.712401,9.075047,8.632223,8.506859,7.930882,8.637219,8.016591,9.086708,7.814552,7.098378,9.181906,8.502926,5.712042,8.510283,6.977966,6.959421,7.005219,7.224712,8.329634,7.382952,6.640731,6.786421,7.4312,7.695138,5.64644,7.2789,6.15719,7.605151,8.49123,8.122171,8.510618,5.179545,6.939343,8.270734,8.215824,7.218371,7.108094,7.288252,7.101972,5.761791,6.202763,7.414307,8.10614,6.894939,6.154046,5.695724,8.245109,8.118867,9.06415,6.38682,7.534916,6.560671,5.992999,7.26845,7.308974,7.602368,6.498302,8.432152,7.011476,6.323226,7.875991,10.44148,11.1783,9.876144,8.69367,8.625238,10.53902,9.640026,9.590789,7.441101,9.603081,8.357468,12.36547,9.613596,9.49942,10.27456,10.19128,9.616542,9.626535,10.43478,9.294005,9.154362,9.398243,11.74506,10.31406,9.904003,11.16825,9.828325,8.733142,11.08629,9.082893,11.53386,10.14574,8.536881,9.22825,10.06851,9.166487,9.790729,10.4692,12.10697,10.38791,8.81444,7.926069,11.04668,10.43356,8.808549,11.34638,9.670272,10.69599,11.16566,9.206461,0.08559222,1.006565,1.020397,1.444457,2.273343,1.492387,0.963914,2.290073,1.705511,0.4913309,2.196239,1.526357,2.116242,2.287657,0.4899909,1.165566,0.7153516,2.883524,2.132348,1.888715,2.545403,1.059041,1.015312,1.89404,0.6500814,1.332281,1.701277,0.7094334,0.5317172,1.226642,2.044533,2.194825,1.289924,2.542829,2.59294,0.8708527,2.001667,1.708847,3.187247,2.232495,0.5908941,1.390736,1.852914,4.073549,1.020958,1.823206,0,1.50567,1.91307,2.241078, + 8.299489,8.575525,8.935022,7.571628,7.092695,8.883668,6.890607,8.389233,7.63133,7.972386,7.910117,7.975709,7.142489,5.755391,6.979723,9.784063,6.848256,7.752019,10.52756,9.272818,7.252032,8.674504,6.289342,7.163895,8.485628,7.43844,7.758041,7.501617,8.183478,6.801767,7.404525,8.200452,5.95025,8.89414,8.532197,8.093099,8.514068,6.944979,6.69486,7.458706,8.530643,7.967409,7.891726,7.743085,8.000202,7.449475,8.670887,7.057101,6.934557,8.76741,7.279652,4.208298,7.057615,5.50727,5.613769,5.710708,5.959834,7.051212,5.989202,5.452202,5.313123,6.094393,6.421664,4.505185,5.995643,4.750898,6.183139,7.213195,6.71631,7.086913,3.938624,5.663939,6.80574,6.731826,5.9089,5.798037,6.024038,5.791044,4.3063,4.748098,6.009916,6.681978,5.51711,4.813718,4.549291,6.857946,6.700208,7.635149,5.197806,6.395422,5.398195,5.252733,5.922533,5.965165,6.27179,4.993887,7.029288,5.647583,4.877679,6.685008,9.02728,9.717382,8.478807,7.207905,7.125127,9.071366,8.199988,8.129102,6.005784,8.151067,6.904728,10.90382,8.240695,8.028749,8.794106,8.690572,8.176227,8.206481,8.977408,7.839751,7.683474,7.893267,10.26453,8.935821,8.433082,9.674593,8.408459,7.227822,9.587199,7.669285,10.1029,8.700625,7.236154,7.740442,8.564322,7.712329,8.29397,8.966277,10.71783,8.883399,7.35245,6.484887,9.641595,8.934069,7.35574,9.865766,8.299301,9.224324,9.691529,7.73454,1.567219,1.650433,2.3604,1.463755,1.569763,0.1799629,0.6962006,1.411953,1.37112,1.954888,0.8223568,0.4698773,1.719601,0.9971994,1.24705,0.6606804,1.270723,1.6648,1.175675,1.898207,3.063869,2.499823,2.352911,1.308697,1.426919,0.9979176,0.4913583,1.191891,0.979257,0.4971067,1.814586,0.9073148,0.5969412,2.726677,1.097404,2.336106,1.631377,2.592407,1.797337,1.042597,1.312865,1.307645,3.265556,3.677819,0.9682794,3.216291,1.50567,0,1.735959,1.89971, + 10.02933,10.29719,10.66277,9.255511,8.827089,10.61271,8.60263,10.12463,9.336599,9.700691,9.633618,9.672925,8.876584,7.482071,8.713936,11.4747,8.580509,9.485515,12.25416,11.00807,8.987984,10.40584,8.021542,8.82956,10.22156,9.167869,9.492335,9.207165,9.918144,8.510435,9.134461,9.934938,7.685722,10.61077,10.261,9.788623,10.22843,8.639125,8.428544,9.1526,10.2661,9.700896,9.627398,9.421179,9.735137,9.185121,10.39678,8.782708,8.602488,10.49328,8.787228,5.105261,8.174506,6.593941,7.000558,7.165331,7.443855,8.502787,7.282342,7.016043,6.394623,7.48437,7.888382,6.119565,7.458291,6.052118,7.407981,8.663013,7.968165,8.288782,5.492399,7.141805,7.882406,7.720056,7.340728,7.2313,7.507662,7.223309,5.494712,5.921309,7.280073,7.890534,6.852318,6.228859,6.159542,8.146678,7.922264,8.813405,6.765686,7.982392,6.982623,6.984746,7.302137,7.34714,7.667545,5.838641,8.28196,7.00414,6.075158,8.228958,9.085232,9.960881,8.48626,7.639915,7.693831,9.358198,8.370106,8.399549,6.205593,8.374572,7.156556,11.13798,8.174266,8.348685,9.16038,9.237886,8.347902,8.297798,9.213303,8.079196,8.011071,8.540854,10.61213,8.875998,8.74752,10.12939,8.495893,7.903697,10.10037,7.746303,10.21067,8.884541,6.989046,8.176684,9.176503,7.953705,8.799883,9.54501,10.67285,9.629408,7.639244,6.695712,9.660058,9.461446,7.597908,10.2186,8.226177,9.531135,10.00643,8.067004,1.996058,2.753479,1.969033,0.4686397,0.6888631,1.559294,1.995593,0.9081171,0.3652088,1.999428,1.610984,1.279281,0.2951107,1.493456,2.126957,2.139212,1.198663,1.672318,0.9811959,0.2426529,1.475937,2.252523,1.961086,0.5363443,2.384368,0.7846497,1.351721,1.216851,1.649563,1.29931,0.1323465,2.602855,1.166477,1.009802,2.454454,2.214804,0.2370344,1.476777,2.212374,1.319816,1.322186,0.5506379,2.736494,2.172072,1.016836,2.650774,1.91307,1.735959,0,0.3419266, + 10.19507,10.47476,10.83199,9.462721,8.958527,10.77977,8.790005,10.2743,9.529631,9.869165,9.808987,9.871878,9.032487,7.65349,8.844794,11.67831,8.741631,9.613391,12.36551,11.15829,9.130402,10.52741,8.182996,9.04618,10.36244,9.286435,9.622903,9.29629,10.07153,8.700651,9.300218,10.08904,7.83615,10.79385,10.37749,9.988744,10.32518,8.83989,8.585941,9.353659,10.41533,9.82859,9.765115,9.631683,9.868227,9.333418,10.56884,8.895198,8.817899,10.66536,8.775881,4.963002,8.056295,6.477458,6.957064,7.141841,7.428875,8.473071,7.21138,7.032172,6.278398,7.439454,7.865819,6.161236,7.436106,5.990951,7.318917,8.632206,7.88326,8.190072,5.512906,7.126066,7.756515,7.57614,7.309187,7.200714,7.492283,7.192449,5.410386,5.829545,7.203122,7.795154,6.795013,6.198285,6.199149,8.070609,7.830069,8.706994,6.784507,8.004726,7.007344,7.111249,7.255029,7.300508,7.623539,5.678832,8.195963,6.951941,5.987881,8.232906,8.794441,9.689292,8.191569,7.400292,7.474552,9.093351,8.093618,8.135263,5.941536,8.104495,6.89443,10.86311,7.872993,8.09097,8.906427,9.009683,8.071662,8.012509,8.942473,7.812019,7.755519,8.330806,10.35234,8.573848,8.487859,9.885236,8.209654,7.70089,9.864732,7.461032,9.923022,8.608293,6.674627,7.935562,8.958594,7.687189,8.566798,9.320755,10.36919,9.43239,7.379683,6.430464,9.364075,9.229585,7.332765,9.9603,7.924144,9.268414,9.743656,7.811903,2.324925,3.049814,2.303887,0.8004816,0.5320745,1.719773,2.245676,0.7918867,0.5845699,2.340782,1.621226,1.430279,0.1803605,1.465975,2.428204,2.370906,1.525745,1.504298,0.9420895,0.5015995,1.578824,2.58978,2.296034,0.5962549,2.686387,1.033146,1.463169,1.537572,1.945999,1.512275,0.2134713,2.720038,1.374102,1.009805,2.481608,2.55556,0.2769731,1.749,2.069919,1.286487,1.651242,0.8569664,3.050389,1.872131,1.30343,2.962678,2.241078,1.89971,0.3419266,0 + }; + + pam(dissimilarities, nbSeries, nbClusters, 0, NSTART, MAXITER, result); + + // Label items + uint32_t* labels = (uint32_t*)malloc(nbSeries*sizeof(uint32_t)); + uint32_t* ctrs = result->medoids_ranks; + + // DEBUG: + //printf("CTRS: %f,%f %f,%f %f,%f %f,%f\n",N[2*ctrs[0]],N[2*ctrs[0]+1],N[2*ctrs[1]],N[2*ctrs[1]+1],N[2*ctrs[2]],N[2*ctrs[2]+1],N[2*ctrs[3]],N[2*ctrs[3]+1]); + + for (uint32_t i=0; i maxLabelsCount) + maxLabelsCount = labelsCount[jj]; + } + LUT_ASSERT(50 - maxLabelsCount <= maxDeltaSeries); + } + + free(result->medoids_ranks); + free(labels); + free(result); +} diff --git a/code/test/CMakeLists.txt b/code/test/CMakeLists.txt new file mode 100644 index 0000000..1833bc1 --- /dev/null +++ b/code/test/CMakeLists.txt @@ -0,0 +1,14 @@ +cmake_minimum_required(VERSION 2.8.5) +project(ppam_mpi_tests) + +include("${CMAKE_SOURCE_DIR}/../shared_CMakeLists.txt") + +#ppam tests + +include_directories("${CMAKE_SOURCE_DIR}/../src") + +file(GLOB_RECURSE test_ppam_src "${CMAKE_SOURCE_DIR}/*.c") +add_executable(test_ppam.exe ${test_ppam_src}) +find_library(PPAM_LIBRARY ppam "${CMAKE_BINARY_DIR}") +#TODO: Rblas ?! +target_link_libraries(test_ppam.exe m cds ${PPAM_LIBRARY}) diff --git a/code/test/MPI_Communication/t.pack.c b/code/test/MPI_Communication/t.pack.c new file mode 100644 index 0000000..125fd47 --- /dev/null +++ b/code/test/MPI_Communication/t.pack.c @@ -0,0 +1,106 @@ +#include "lut.h" +#include +#include "MPI_Communication/pack.h" +#include "Util/types.h" +#include +#include "Util/utils.h" + +// Work_t +void t_pack1() +{ + Work_t* work = (Work_t*)malloc(sizeof(Work_t)); + work->inputFileName = "../data/inputTest.bin"; + work->nbSeries = 5; + uint32_t ranks[] = + { + 0, + 12*65536 + 3*256+11, + 32*16777216 + 2*65536 + 17*256 + 42, + 123, + 51*16777216 + 77*65536 + 0*256 + 10 + }; + work->ranks = ranks; + work->nbClusters = 15; + work->clustOnMedoids = 0; + work->p_for_dissims = 1; + + // Hard-coded expected packed work + unsigned char expectedPackedWork[] = + { + // --> ../data/inputTest.bin + 46,46,47,100,97,116,97,47,105,110,112,117,116,84,101,115,116,46,98,105,110, + // continue with 256 - strlen("../data/inputTest.bin") zeros... + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + // --> 5, {ranks}+0,0, 15, 0 on 4-bytes integers little-endian + 5,0,0,0, 0,0,0,0, 11,3,12,0, 42,17,2,32, 123,0,0,0, 10,0,77,51, 0,0,0,0, 0,0,0,0, + 15,0,0,0, 0,0,0,0, 1,0,0,0 + }; + + uint32_t nbSeriesInChunk = 7; + uint32_t work_message_length = get_packedWork_length(nbSeriesInChunk); + unsigned char packedWork[work_message_length]; + pack_work(work, nbSeriesInChunk, packedWork); + + for (uint32_t i=0; inbClusters = 5; + uint32_t medoids_ID[] = + { + 15*65536 + 13*256+11, + 11, + 17*16777216 + 0*65536 + 14*256 + 42, + 123*65536 + 0*256 + 7, + 51*16777216 + 0*65536 + 0*256 + 10 + }; + result->medoids_ID = medoids_ID; + uint32_t medoids_ranks[] = + { + 5*65536 + 32, + 11*256 + 4, + 23*16777216 + 42, + 35*65536 + 5*256 + 77, + 1*16777216 + 1*65536 + 1*256 + 10 + }; + result->medoids_ranks = medoids_ranks; + + // Hard-coded expected result + unsigned char expectedPackedResult[] = + { + // 5, {medoids_ID}, {medoids_ranks} + 5,0,0,0, + 11,13,15,0, 11,0,0,0, 42,14,0,17, 7,0,123,0, 10,0,0,51, + 32,0,5,0, 4,11,0,0, 42,0,0,23, 77,5,35,0, 10,1,1,1 + }; + + uint32_t result_message_length = get_packedResult_length(nbClusters); + unsigned char packedResult[result_message_length]; + pack_result(result, packedResult); + + for (uint32_t i=0; i +#include "MPI_Communication/unpack.h" +#include "Util/types.h" +#include +#include +#include "Util/utils.h" + +// Work_t +void t_unpack1() +{ + // Hard-coded packed work + unsigned char packedWork[] = + { + // --> ../data/inputTest.bin + 46,46,47,100,97,116,97,47,105,110,112,117,116,84,101,115,116,46,98,105,110, + // continue with 256 - strlen("../data/inputTest.bin") zeros... + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + // --> 5, {ranks}+0,0, 15, 0 on 4-bytes integers little-endian + 5,0,0,0, 0,0,0,0, 11,3,12,0, 42,17,2,32, 123,0,0,0, 10,0,77,51, 0,0,0,0, 0,0,0,0, + 15,0,0,0, 0,0,0,0, 2,0,0,0 + }; + + uint32_t nbSeriesInChunk = 7; + Work_t* work = unpack_work(packedWork, nbSeriesInChunk); + + LUT_ASSERT(strcmp(work->inputFileName, "../data/inputTest.bin") == 0); + LUT_ASSERT(work->nbSeries == 5); + uint32_t ranks[] = + { + 0, + 12*65536 + 3*256+11, + 32*16777216 + 2*65536 + 17*256 + 42, + 123, + 51*16777216 + 77*65536 + 0*256 + 10 + }; + for (uint32_t i=0; i < work->nbSeries; i++) + { + LUT_ASSERT(work->ranks[i] == ranks[i]); + } + LUT_ASSERT(work->nbClusters == 15); + LUT_ASSERT(work->clustOnMedoids == 0); + LUT_ASSERT(work->p_for_dissims == 2); + + free_work(work); +} + +// Result_t +void t_unpack2() { + + // Hard-coded packed result + unsigned char packedResult[] = + { + // 5, {medoids_ID}, {medoids_ranks} + 5,0,0,0, + 11,13,15,0, 11,0,0,0, 42,14,0,17, 7,0,123,0, 10,0,0,51, + 32,0,5,0, 4,11,0,0, 42,0,0,23, 77,5,35,0, 10,1,1,1 + }; + + Result_t* result = unpack_result(packedResult); + + LUT_ASSERT(result->nbClusters == 5); + uint32_t medoids_ID[] = + { + 15*65536 + 13*256+11, + 11, + 17*16777216 + 0*65536 + 14*256 + 42, + 123*65536 + 0*256 + 7, + 51*16777216 + 0*65536 + 0*256 + 10 + }; + uint32_t medoids_ranks[] = + { + 5*65536 + 32, + 11*256 + 4, + 23*16777216 + 42, + 35*65536 + 5*256 + 77, + 1*16777216 + 1*65536 + 1*256 + 10 + }; + for (uint32_t i=0; inbClusters; i++) + { + LUT_ASSERT(result->medoids_ID[i] == medoids_ID[i]); + LUT_ASSERT(result->medoids_ranks[i] == medoids_ranks[i]); + } + + free_result(result); +} diff --git a/code/test/TimeSeries/t.deserialize.c b/code/test/TimeSeries/t.deserialize.c new file mode 100644 index 0000000..22e0956 --- /dev/null +++ b/code/test/TimeSeries/t.deserialize.c @@ -0,0 +1,94 @@ +#include "TimeSeries/deserialize.h" +#include "lut.h" +#include +#include +#include +#include "Util/utils.h" + +void t_deserialize1() +{ + // decode sample_byCols.bin into the toy dataset (4 customers, 3 sample points) + const char* ifName = "../data/test/sample_byCols.bin"; + + // check 'header' + uint32_t nbSeries = get_nbSeries(ifName); + LUT_ASSERT(nbSeries == 4); + uint32_t tsLength = get_tsLength(ifName); + LUT_ASSERT(tsLength == 13); //3*3+4 + + uint32_t ranks[] = + { + 0, 2, 1, 3 + }; + PowerCurve* powerCurves = deserialize(ifName, NULL, ranks, nbSeries); + + Real epsilon = 0.1; //epsilon = 0.1 because raw powers are truncated + + LUT_ASSERT(powerCurves[0].ID == 12301); + LUT_ASSERT(fabs(powerCurves[0].values[0] - 23.051) < epsilon); + LUT_ASSERT(fabs(powerCurves[0].values[1] - 33.052) < epsilon); + LUT_ASSERT(fabs(powerCurves[0].values[2] - 43.053) < epsilon); + + LUT_ASSERT(powerCurves[1].ID == 1313); + LUT_ASSERT(fabs(powerCurves[1].values[0] - 50.05) < epsilon); + LUT_ASSERT(fabs(powerCurves[1].values[1] - 51.05) < epsilon); + LUT_ASSERT(fabs(powerCurves[1].values[2] - 52.05) < epsilon); + + LUT_ASSERT(powerCurves[2].ID == 50000); + LUT_ASSERT(fabs(powerCurves[2].values[0] - 150.321) < epsilon); + LUT_ASSERT(fabs(powerCurves[2].values[1] - 160.322) < epsilon); + LUT_ASSERT(fabs(powerCurves[2].values[2] - 140.323) < epsilon); + + LUT_ASSERT(powerCurves[3].ID == 6300); + LUT_ASSERT(fabs(powerCurves[3].values[0] - 500.30) < epsilon); + LUT_ASSERT(fabs(powerCurves[3].values[1] - 501.31) < epsilon); + LUT_ASSERT(fabs(powerCurves[3].values[2] - 502.32) < epsilon); + + for (int i = 0; i < nbSeries; i++) + free(powerCurves[i].values); + free(powerCurves); +} + +void t_deserialize2() +{ + // decode sample_byRows.bin into the toy dataset (4 customers, 3 sample points) + const char* ifName = "../data/test/sample_byRows.bin"; + + // check 'header' + uint32_t nbSeries = get_nbSeries(ifName); + LUT_ASSERT(nbSeries == 4); + uint32_t tsLength = get_tsLength(ifName); + LUT_ASSERT(tsLength == 13); //3*3+4 + + uint32_t ranks[] = + { + 0, 2, 1, 3 + }; + PowerCurve* powerCurves = deserialize(ifName, NULL, ranks, nbSeries); + + Real epsilon = 0.1; //epsilon = 0.1 because raw powers are truncated + + LUT_ASSERT(powerCurves[0].ID == 12301); + LUT_ASSERT(fabs(powerCurves[0].values[0]/100.0-3 - 23.051) < epsilon); + LUT_ASSERT(fabs(powerCurves[0].values[1]/100.0-3 - 33.052) < epsilon); + LUT_ASSERT(fabs(powerCurves[0].values[2]/100.0-3 - 43.053) < epsilon); + + LUT_ASSERT(powerCurves[1].ID == 1313); + LUT_ASSERT(fabs(powerCurves[1].values[0]/100.0-3 - 50.05) < epsilon); + LUT_ASSERT(fabs(powerCurves[1].values[1]/100.0-3 - 51.05) < epsilon); + LUT_ASSERT(fabs(powerCurves[1].values[2]/100.0-3 - 52.05) < epsilon); + + LUT_ASSERT(powerCurves[2].ID == 50000); + LUT_ASSERT(fabs(powerCurves[2].values[0]/100.0-3 - 150.321) < epsilon); + LUT_ASSERT(fabs(powerCurves[2].values[1]/100.0-3 - 160.322) < epsilon); + LUT_ASSERT(fabs(powerCurves[2].values[2]/100.0-3 - 140.323) < epsilon); + + LUT_ASSERT(powerCurves[3].ID == 6300); + LUT_ASSERT(fabs(powerCurves[3].values[0]/100.0-3 - 500.30) < epsilon); + LUT_ASSERT(fabs(powerCurves[3].values[1]/100.0-3 - 501.31) < epsilon); + LUT_ASSERT(fabs(powerCurves[3].values[2]/100.0-3 - 502.32) < epsilon); + + for (int i = 0; i < nbSeries; i++) + free(powerCurves[i].values); + free(powerCurves); +} diff --git a/code/test/TimeSeries/t.serialize.c b/code/test/TimeSeries/t.serialize.c new file mode 100644 index 0000000..1dda321 --- /dev/null +++ b/code/test/TimeSeries/t.serialize.c @@ -0,0 +1,47 @@ +#include "TimeSeries/serialize.h" +#include "lut.h" +#include +#include + +static void checkFilesEqual(const char* fileName1, const char* fileName2) +{ + FILE* output = fopen(fileName1, "rb"); + FILE* refOutput = fopen(fileName2, "rb"); + while (!feof(output) && !feof(refOutput)) + LUT_ASSERT(fgetc(output) == fgetc(refOutput)); + LUT_ASSERT(feof(output) && feof(refOutput)); + fclose(output); + fclose(refOutput); +} + +void t_serialize1() +{ + const char* csvIfName = "../data/test/sample_byCols.csv"; + const char* binaryIfName = "../data/test/sample_byCols.bin"; + const char* tmpBinaryIfName = "../data/test/sample_byCols.tmp.bin"; + + // serialize text file into a temporary binary file + serialize_byCols(csvIfName, tmpBinaryIfName, 0); + + // compare binary result with reference + checkFilesEqual(tmpBinaryIfName, binaryIfName); + + // remove temp file + unlink(tmpBinaryIfName); +} + +void t_serialize2() +{ + const char* csvIfName = "../data/test/sample_byRows.csv"; + const char* binaryIfName = "../data/test/sample_byRows.bin"; + const char* tmpBinaryIfName = "../data/test/sample_byRows.tmp.bin"; + + // serialize text file into a temporary binary file + serialize_byRows(csvIfName, tmpBinaryIfName, 0); + + // compare binary result with reference + checkFilesEqual(tmpBinaryIfName, binaryIfName); + + // remove temp file + unlink(tmpBinaryIfName); +} diff --git a/code/test/Util/t.rng.c b/code/test/Util/t.rng.c new file mode 100644 index 0000000..ee98b98 --- /dev/null +++ b/code/test/Util/t.rng.c @@ -0,0 +1,49 @@ +#include "lut.h" +#include "Util/rng.h" +#include +#include +#include + +// Auxiliary to perform K-S test for a given flag, sample size and bins count +void aux_ks_test(int flag, uint32_t N, uint32_t nBins) +{ + init_rng(flag); + + // Fill the bins + uint32_t bins[nBins]; + for (uint32_t i=0; i= nBins) index = nBins - 1; //in case of... + bins[index]++; + } + + // Test the bins + double ksThreshold = 1.358 / sqrt((double)N); + double countPerBin = (double)N / nBins; + uint32_t cumulativeSum = 0; + for (uint32_t i=0; i +#include +#include "Util/types.h" +#include + +//integers +void t_utils1() +{ + FILE* file = fopen("../data/test/integers.txt", "rb"); + int64_t x; + readInt(file, &x); + LUT_ASSERT(x == 1234); + readInt(file, &x); + LUT_ASSERT(x == -987); + readInt(file, &x); + LUT_ASSERT(x == 654321); + readInt(file, &x); + LUT_ASSERT(x == 12); + readInt(file, &x); + LUT_ASSERT(x == 345678); + readInt(file, &x); + LUT_ASSERT(x == -1234); + fclose(file); +} + +//reals +void t_utils2() +{ + FILE* file = fopen("../data/test/reals.txt", "rb"); + Real x, tol = 1e-10; + readReal(file, &x); + LUT_ASSERT(fabs(x - 1234.056) < tol); + readReal(file, &x); + LUT_ASSERT(fabs(x - 987e-3) < tol); + readReal(file, &x); + LUT_ASSERT(fabs(x - -654321e-2) < tol); + readReal(file, &x); + LUT_ASSERT(fabs(x - 12.34567) < tol); + readReal(file, &x); + LUT_ASSERT(fabs(x - 345678.0) < tol); + readReal(file, &x); + LUT_ASSERT(fabs(x - -1234.05) < tol); + readReal(file, &x); + LUT_ASSERT(fabs(x - 3e-1) < tol); + readReal(file, &x); + LUT_ASSERT(fabs(x - -1.0188) < tol); + fclose(file); +} diff --git a/code/test/lut.h b/code/test/lut.h new file mode 100644 index 0000000..4e36e51 --- /dev/null +++ b/code/test/lut.h @@ -0,0 +1,15 @@ +#ifndef PPAM_LUT_H +#define PPAM_LUT_H + +#include + +// light, minimalist unit-testing "framework" + +#define LUT_ASSERT(condition) \ + do { \ + if ( !(condition) ) { \ + printf("Failure in file %s at line %i\n",__FILE__,__LINE__); \ + } \ + } while (0) + +#endif diff --git a/code/test/main.c b/code/test/main.c new file mode 100644 index 0000000..3d80af6 --- /dev/null +++ b/code/test/main.c @@ -0,0 +1,39 @@ +void t_serialize1(); +void t_serialize2(); +void t_deserialize1(); +void t_deserialize2(); +void t_compute_coefficients1(); +void t_compute_coefficients2(); +void t_pam1(); +void t_pam2(); +void t_pack1(); +void t_pack2(); +void t_unpack1(); +void t_unpack2(); +void t_rng1(); +void t_rng2(); +void t_utils1(); +void t_utils2(); + +// list all unit tests here +int main() +{ + t_serialize1(); + t_serialize2(); + t_deserialize1(); + t_deserialize2(); + //~ t_compute_coefficients1(); + //~ t_compute_coefficients2(); + t_pam1(); //may fail + t_pam2(); + t_pack1(); + t_pack2(); + t_unpack1(); + t_unpack2(); + t_rng1(); //may fail + t_rng2(); + t_utils1(); + t_utils2(); + + return 0; +} diff --git a/latex/article/TODO.txt b/latex/article/TODO.txt new file mode 100644 index 0000000..e69de29 diff --git a/latex/poster/TODO.txt b/latex/poster/TODO.txt new file mode 100644 index 0000000..e69de29 diff --git a/latex/short_paper/JDS2014_short.pdf b/latex/short_paper/JDS2014_short.pdf new file mode 100644 index 0000000..26f34a6 Binary files /dev/null and b/latex/short_paper/JDS2014_short.pdf differ diff --git a/latex/short_paper/JDS2014_short.tex b/latex/short_paper/JDS2014_short.tex new file mode 100644 index 0000000..004f81e --- /dev/null +++ b/latex/short_paper/JDS2014_short.tex @@ -0,0 +1,444 @@ +\documentclass[12pt]{article} +% +% +% Retirez le caractere "%" au debut de la ligne ci--dessous si votre +% editeur de texte utilise des caracteres accentues +%\usepackage[latin1]{inputenc} +\usepackage[utf8]{inputenc} + +% +% Retirez le caractere "%" au debut des lignes ci--dessous si vous +% utiisez les symboles et macros de l'AMS +\usepackage{amsmath} +\usepackage{amsfonts} +% +% +\setlength{\textwidth}{16cm} +\setlength{\textheight}{21cm} +\setlength{\hoffset}{-1.4cm} + +% for figures and tables +\usepackage{float} +\usepackage{graphicx} +\usepackage{wrapfig} +\usepackage{xcolor} +\usepackage{hyperref} +\hypersetup{ + colorlinks, + linkcolor=black, + urlcolor=violet +} +\usepackage{scrextend} +% +% +\begin{document} + +%-------------------------------------------------------------------------- + +\begin{center} +{\Large + {\sc Parallélisation de l'algorithme des $k$-médoïdes. Application au clustering de courbes.} %heuristique ?! +} +\bigskip + +Benjamin Auder $^{1}$ \& Jairo Cugliari $^{2}$ +\bigskip + +{\it +$^{1}$ Laboratoire LMO. Université Paris-Sud. Bât 425. 91405 Orsay Cedex, France.\\benjamin.auder@math.u-psud.fr + +$^{2}$ Laboratoire ERIC. Université Lumière Lyon 2. Bât K. 69676 Bron Cedex, France.\\jairo.cugliari@univ-lyon2.fr +} +\end{center} +\bigskip + +%-------------------------------------------------------------------------- + +{\bf R\'esum\'e.} +Nous présentons une méthode de clustering adaptée à de grandes bases de données de courbes densément discrétisées, donc elle-mêmes en grande dimension. +La classification obtenue peut être utilisée afin de choisir de meilleurs modèles de prédiction de courbes, plus spécifiques, dans chacun des groupes. +La méthode consiste en deux principales étapes : +réduire la dimension des courbes via une base d'ondelettes, puis effectuer le clustering en parallèle. +Les ondelettes sont bien adaptées pour identifier des caractéristiques localisées en temps et échelle. +De plus, l'aspect multi-résolution de la transformée en ondelettes permet de regrouper les coefficients +selon leur contribution à l'énergie totale, fournissant ainsi des représentants compacts pour chaque courbe. +L'algorithme des $k$-médoïdes est appliqué à plusieurs sous-échantillons de l'ensemble des représentations réduites, +puis les centres finaux sont obtenus en recherchant la médiane (ou éventuellement la moyenne) des médoïdes des échantillons. +Des applications sont présentées sur deux jeux de données, dont les consommations électriques irlandaises journalières. +\smallskip + +{\bf Mots-cl\'es.} réduction de dimension, ondelettes, $k$-médoïdes, parallèle +\bigskip\bigskip + +{\bf Abstract.} +We present a clustering method adapted to large databases of densely sampled curves, hence themselves in high dimension. +The resulting classification can help to better tune models to predict new curves, each in every group. +The method consists of two main steps: +use a wavelet basis to reduce curves dimensionality, and then run a parallel clustering algorithm. +Wavelets are well suited to identify characteristics localized both in time and space. +Moreover, the multiresolution nature of the wavelets transform allows to group coefficients according to their +contribution to the total energy, thus providing compact representations for every curve. +The $k$-medoids algorithm is applied to several subsamples of all the reduced representations, and then the final +centers are obtained by computing the median (or mean) of the samples medoids. +Applications are shown on two databases, including Irish daily electrical consumptions. +\smallskip + +{\bf Keywords.} dimensionality reduction, wavelets, $k$-medoids, parallel + +%~ Nous présentons une méthode de clustering adaptée à de grandes bases de données de courbes densément discrétisées, donc elle-mêmes en grande dimension. La classification obtenue peut être utilisée afin de choisir de meilleurs modèles de prédiction de courbes, plus spécifiques, dans chacun des groupes. La méthode consiste en deux principales étapes : réduire la dimension des courbes via une base d'ondelettes, puis effectuer le clustering en parallèle. Les ondelettes sont bien adaptées pour identifier des caractéristiques localisées en temps et échelle. De plus, l'aspect multi-résolution de la transformée en ondelettes permet de regrouper les coefficients selon leur contribution à l'énergie totale, fournissant ainsi des représentants compacts pour chaque courbe. L'algorithme des k-médoïdes est appliqué à plusieurs sous-échantillons de l'ensemble des représentations réduites, puis les centres finaux sont obtenus en recherchant la médiane (ou éventuellement la moyenne) des médoïdes des échantillons. Des applications sont présentées sur deux jeux de données, dont les consommations électriques irlandaises journalières. + +%-------------------------------------------------------------------------- + +\section{Introduction} + +% * clustering +% * parallelisation of clustering +% * fda + wavelets +% * données individuelles de conso + +Récemment, le contexte du \textit{Big Data} a rendu nécessaire le développement d'algorithmes spécifiques à de (très) +grands volumes de données, éventuellement aussi en grande dimension comme c'est le cas dans notre étude. +Ainsi ont vu le jour des algorithmes opérant sur de grands graphes (Kang et al.~2009) ou sur des flux de données haut débit (De Francisci Morales et Bifet~2013), entre entres. +Le livre de Bekkerman et al.~(2011) présente des algorithmes de Machine Learning s'exécutant en parallèle sur diverses architectures, et +ce type de programmation est en plein essor.\\ + +\noindent La classification non supervisée (\textit{clustering}) est une des branches de l'apprentissage non supervisé. +L'objectif est de regrouper les données en \textit{clusters} homogènes, suffisamment distincts deux à deux. +Depuis la proposition originale de Tyron~(1939) un grand nombre d'articles ont été publié à ce sujet (voir Berkhin~2006 pour une revue). +Cependant, il n'y a pas de consensus sur la définition d'un cluster : celle-ci varie en fonction des données, du contexte et de l'algorithme utilisé. +Malgré ce fait, la classification non supervisée reste une technique très populaire qui permet +de réduire la taille des données en les résumant à quelques représentants ; c'est particulièrement intéressant lorsqu'on travaille sur de grosses bases de données.\\ + +\noindent Dans ce travail nous avons choisi d'adapter un algorithme de clustering classique pour une exécution parallèle, opérant sur des données de dimension réduite. +La première partie présente la technique retenue afin d'abaisser la dimension via une base d'ondelettes. +L'algorithme classant les données en parallèle est expliqué dans la seconde partie, puis nous montrons quelques résultats de tests. + +\section{Réduction de dimension} + +Dans cette section nous expliquons comment sont traitées les variables fonctionnelles (voir Antoniadis et al.~(2013) pour plus de détails).\\ + +\noindent Chaque fonction $z$ est d'abord discrétisée sur une fine grille (toutes les 30 minutes pour les consommations électriques), et +la discrétisation est encore notée $z = \{ z(t_i), i = 1, \ldots, N \}$. +$z$ est alors approchée (jusqu'à l'échelle $J$) par un développement tronqué sur une base d'ondelettes avec un coefficient d'échelle $c_{0,0}$ +et les coefficients d'ondelettes $\{d_{j, k}\}_{j, k}$ : +% +\begin{equation} \label{approx} + z_J(t) = c_{0,0} \phi_{0, 0} (t) + \sum_{j=0}^{J-1} \sum_{k=0}^{2^j - 1} d_{j,k} \psi_{j, k} (t). +\end{equation} +Alors, l'énergie $\mathcal{E}_Z = \| z \|^2_{ L_2 }$ de chaque fonction $z$ est égale à la somme des énergies +de ses coefficients en ondelettes distribuées à travers les échelles : +% +\begin{equation} \label{scaledist} + \mathcal{E}_z \approx c_{0,0}^2 + \sum_{j=0}^{J-1} \| \mathbf{W}_j \|^2_2, +\end{equation} +% +où $\| \mathbf{W}_j \|^2_2 = (d_{j, 0}, \ldots d_{j, 2^j - 1})'$, l'approximation étant due à la troncature à l'échelle $J$. +On ne s'intéresse qu'à l'information contenue dans la forme des fonctions, pas à celle de son niveau moyen. +Ainsi, on définit la contribution absolue de l'échelle $j$ à l'énergie globale de la fonction centrée comme + \[ \hbox{cont}_j = \| \mathbf{W}_j \|^2_2, \qquad j=0,\ldots,J-1. \] +Finalement, chaque fonction est caractérisée par le vecteur de ses contributions absolues à l'énergie globale.\\ + +\noindent En pratique nous choisissons $J$ de l'ordre de $\log_2(N)$ : c'est la valeur maximale possible compte-tenu de la discrétisation. + +\section{$k$-médoïdes parallèle} + +Nous rappelons tout d'abord l'algorithme des $k$-médoïdes, puis indiquons comment s'est déroulée la parallélisation.\\ + +%\subsection{Algorithme des $k$-médoïdes} +\noindent \textbf{Algorithme des $k$-médoïdes}\\ +Comme dans l'algorithme des $k$-means, l'idée est de partitionner les données autour de $k$ centres, ici appelés \emph{médoïdes}. +La fonction à minimiser (\emph{distorsion}) est similaire : +$$D(x) = \min_{m_1,\dots,m_k \in \mathbb{R}^d} \sum_{i=1}^{n} \min_{j=1,\dots,k} \| x_i - m_j \| \, ,$$ +avec $x = (x_1,\dots,x_n)$, $\|\,.\,\|$ pouvant désigner n'importe quelle norme ; ici nous choisissons la norme euclidienne. +Les distances n'apparaissant pas au carré, cet algorithme est moins sensible aux outliers que le $k$-means. +Cependant, sa programmation est plus délicate car dans le cas de la médiane spatiale il n'existe pas de formule analogue à celle de la moyenne. +La première implémentation de l'algorithme est celle de Kaufman et Rousseeuw~(1987), PAM pour Partitioning Around Medoids. +Elle est assez coûteuse, mais donne de bons résultats et reste simple à écrire. Diverses heuristiques ou accélérations autour de cette implémentation +ont été développés (Chu et al.~2002, etc.), mais nous utilisons ici la version originale, qui se révèle suffisante.\\ +%TODO: encadré algo PAM. [si reste de la place...] + +%\subsection{Parallélisation avec MPI} +\noindent \textbf{Parallélisation avec MPI}\\ +MPI est une librarie permettant de faciliter l'écriture de programmes en parallèle. +%Elle est disponible pour divers langages dont le C, que nous avons choisi. +%~ Son principe est le suivant : +%~ \begin{enumerate} +%~ \item un certain nombre de coeurs de calcul sont alloués et initialisés avec les mêmes valeurs sauf une : le rang du processus ; +%~ \item chaque coeur exécute séquentiellement deux types d'instructions : locales, comme dans un programme normal, +%~ et de communication, où il envoie un ou plusieurs message à un ou plusieurs autres processus. Ces messages peuvent demander ou envoyer des résultats, mais aussi +%~ effectuer des actions plus élaborées comme [TODO] +%~ \item le calcul se termine lorsque tous les coeurs sont arrêtés. +%~ \end{enumerate} +Nous l'utilisons en mode master-slave, c'est à dire que le travail est divisé en deux types d'entités: un processus coordinateur, +et des coeurs se contentant d'exécuter les demandes du processus maître. +%~ \begin{itemize} +%~ \item master : reçoit l'entrée initiale, coordonne les autres processus pour effectuer la tâche, et rassemble les résultats ; +%~ \item slave : boucle en attendant des instructions du processus maître, exécute les sous-tâches et retourne les résultats partiels. +%~ \end{itemize} +Voici le flot d'exécution du programme final :\\ +%\begin{enumerate} +\begin{addmargin}[1em]{2em}% 1em left, 2em right +\noindent \textbf{1.} le processus maître découpe le problème en sous-tâches sur des jeux de données plus petits, et les envoie à chaque esclave ;\\ +\textbf{2.} pour une sous-tâche donnée, on réduit la dimension puis applique l'algorithme de clustering, et retourne les centres ;\\ +\textbf{3.} le processus principal récupère et aggrège les résultats en un jeu de $k$ centres.\\ +\end{addmargin} +%\end{enumerate} +Le code sera disponible prochainement sur \href{https://github.com/}{github}. +%TODO: code disponible en ligne sur github. (faut beautifier quelques bricoles dans le code d'abord, en particulier serialize/deserialize et type d'ondelette en argument (?!) + +\section{Applications} + +Deux jeux de données ont été utilisés ici : des évolutions de magnitudes d'étoiles, et de consommations électriques. + +\subsection{Magnitudes d'étoiles} + +Ce jeu de données récupéré via le site web de Keogh et al.~(2011) consiste en un ensemble d'entraînement de 1000 courbes, +et une base de test de 8236 courbes. Chacune d'entre elle a un label compris entre 1 et 3 ; la figure \ref{figsltr3clusts} les représente. +On remarque que les groupes 1 et 3 sont assez similaires, contenant des courbes difficiles à classer. + +\begin{figure}[H] +\begin{minipage}[c]{.32\linewidth} + \includegraphics[width=5cm,height=3.5cm]{img/slgr1.png} + \vspace*{-0.3cm} + \caption{Groupe 1} +\end{minipage} +\begin{minipage}[c]{.32\linewidth} + \includegraphics[width=5cm,height=3.5cm]{img/slgr2.png} + \vspace*{-0.3cm} + \caption{Groupe 2} +\end{minipage} +\begin{minipage}[c]{.32\linewidth} + \includegraphics[width=5cm,height=3.5cm]{img/slgr3.png} + \vspace*{-0.3cm} + \caption{Groupe 3} +\end{minipage} +\label{figsltr3clusts} +\end{figure} + +Compte-tenu du relatif faible nombre d'échantillons nous pouvons lancer le programme sur tout le jeu de données ; +cela permet de comparer aux résultats obtenus par la version parallèle, que l'on espère presque aussi bons. +Le tableau \ref{tabDistorSl} contient les distorsions empiriques calculées sur les ensemble d'entraînement et de test, +ainsi que l'adéquation des deux partitions ("intra"), et leur adéquation à la partition réelle ("inter"). Cette dernière est mauvaise à cause de la remarque précitée : +les courbes des clusters 1 et 3 se ressemblent trop pour appliquer un algorithme de partitionnement de type $k$-means.\\ + +\begin{table}[H] +\centering +\begin{tabular}{|l|c|c|c|} +\hline + & Distorsion & "Intra-adéquation" & "Inter-adéquation" \\ +\hline +Entraînement seq. & 1.31e4 & 0.79 & 0.77\\ +\hline +Entraînement // & 1.40e4 & 0.79 & 0.68\\ +\hline +Test seq. & 1.09e5 & 0.78 & 0.76\\ +\hline +Test // & 1.15e5 & 0.78 & 0.69\\ +\hline +\end{tabular} +\caption{Distorsions et indices d'adéquation des partitions} +\label{tabDistorSl} +\end{table} + +%~ 1) Starlight curves : utiliser 1000 (resp. 3000) courbes pour le clustering, puis ~9000 (resp. ~7000) pour classif. +%~ Comparer les médoïdes (renuméroter en sortie du code), et afficher les perfs : taux de classif correcte. + +\subsection{Consommations électriques irlandaises} + +Ce jeu de données consiste en 4621 séries temporelles représentant l'évolution de la consommation életrique d'autant de foyers irlandais. +Celles-ci sont similaires aux courbes EDF sur lesquelles vise à être appliquée notre méthode. +Nous avons choisi d'appliquer l'algorithme avec 3 et 5 classes. Compte-tenu du grand nombre de points de discrétisation (25k) +et de la haute variabilité des données, celles-ci sont difficiles à représenter. Ainsi nous n'indiquons que les résultats numériques ; +ils sont visibles dans le tableau \ref{tabDistorIr}, et sont cette fois plutôt bons.\\ + +\begin{table}[H] +\centering +\begin{tabular}{|l|c|c|} +\hline + & Distorsion & "Intra-adéquation" seq. VS //\\ +\hline +3 clusters seq. & 1.90e7 & 0.90\\ +\hline +3 clusters // & 2.15e7 & 0.90\\ +\hline +5 clusters seq. & 1.61e7 & 0.89\\ +\hline +5 clusters // & 1.84e7 & 0.89\\ +\hline +\end{tabular} +\caption{Distorsions et indices d'adéquation des partitions} +\label{tabDistorIr} +\end{table} +%pour un nombre de clusters égal à 3, 7 et 15. + +\section{Conclusion} + +Nous avons cherché à identifier des groupes de consommateurs à partir de données fonctionnelles +pour bénéficier de l'information supplémentaire fournie par la forme des courbes, qui serait perdue +si on les considérait comme de simples vecteurs. Cette forme est capturée $-$ entre autres caractéristiques $-$ +par les coefficients d'ondelettes, regroupés par niveaux d'énergie. Les dissimilarités sont calculées ensuite +via une distance $L^p$. Alternativement (ou complémentairement), il serait intéressant d'utiliser une mesure de dissimilarité +plus directement basée sur la forme des courbes, comme le font Heckman et Zamar~(2000).\\ + +Ensuite, la procédure de clustering mise en place est prévue pour passer à l'échelle pour plusieurs millions de courbes. +En effet, elle a été conçue initialement pour être appliquée aux séries temporelles des clients EDF (plusieurs dizaines de millions). +Elle consiste à appliquer l'algorithme des $k$-médoïdes sur des groupes de courbes, puis des groupes de médoïdes +jusqu'à obtenir un seul ensemble traité sur un processseur. +Les résultats obtenus sur les deux jeux de données présentés sont assez encourageants, et permettent d'envisager une utilisation à plus grande échelle. + +%~ \section{Exemple de r\'ef\'erences bibliographiques} +%~ La n\'ecessit\'e de produire des r\'esum\'es clairs et bien +%~ r\'ef\'erenc\'es a \'et\'e d\'emontr\'ee par Achin et Quidont~(2000). +%~ Le r\'ecent article de Noteur~(2003) met en \'evidence \dots + +%Quelques rappels : +%% +%\begin{center} +%% +%\begin{tabular}{lr} \hline +%% +%Accent aigu : & \'e; \\ +%Accent grave : & \`a;\\ +%Accent circonflexe : & \^o mais \^{\i};\\ +%Tr\'emas : & \"o mais \"{\i};\\ +%C\'edille : & \c{c}. \\ \hline +%\end{tabular} +%% +%\end{center} + +%-------------------------------------------------------------------------- + +\section*{Bibliographie} + +\noindent [1] A. Antoniadis, X. Brossat, J. Cugliari et J.-M. Poggi (2013), Clustering Functional Data Using Wavelets, {\it International Journal of Wavelets, Multiresolution and Information Processing}, 11(1), 35--64.\\%, \texttt{doi:10.1142/S0219691313500033} +\noindent [2] R. Bekkerman, M. Bilenko et J. Langford - éditeurs (2011), Scaling up Machine Learning: Parallel and Distributed Approaches, {\it Cambridge University Press}.\\ +\noindent [3] P. Berkhin (2006), A Survey of Clustering Data Mining Techniques, {\it Grouping Multidimensional Data, éditeurs : J. Kogan, C. Nicholas, M. Teboulle}.\\ +\noindent [4] F. Chang, J. Dean, S. Ghemawat, W.C. Hsieh, D.A. Wallach, M. Burrows, T. Chandra, A. Fikes, et R.E. Gruber (2006), Bigtable: A Distributed Storage System for Structured Data, {\it Seventh Symposium on Operating System Design and Implementation}.\\ +\noindent [5] S.-C. Chu, J.F. Roddick et J.S. Pan (2002), An Efficient K-Medoids-Based Algorithm Using Previous Medoid Index, Triangular Inequality Elimination Criteria, and Partial Distance Search, {\it Lecture Notes in Computer Science}, 2454, 63--72.\\ +\noindent [6] J. Dean et S. Ghemawat (2004), MapReduce: Simplified Data Processing on Large Clusters, {\it Sixth Symposium on Operating System Design and Implementation}.\\ +\noindent [7] G. De Francisci Morales et A. Bifet (2013), Introducing SAMOA, an open source platform for mining big data streams, {\it http://yahooeng.tumblr.com/post/65453012905/introducing-samoa-an-open-source-platform-for-mining}. +\noindent [8] N.E. Heckman et R.H. Zamar (2000), Comparing the shapes of regression functions. {\it Biometrika}, 87(1), 135--144.\\ +\noindent [9] U. Kang, C.E. Tsourakakis et C. Faloutsos (2009), PEGASUS: A Peta-Scale Graph Mining System - Implementation and Observations, {\it IEEE International Conference on Data Mining}.\\ +\noindent [10] L. Kaufman et P.J. Rousseeuw (1987), Clustering by means of Medoids, {\it Statistical Data Analysis Based on the L\_1-Norm and Related Methods, éditeur : Y. Dodge}.\\ +\noindent [11] E. Keogh, Q. Zhu, B. Hu, Y. Hao, X. Xi, L. Wei et C.A. Ratanamahatana (2011), The UCR Time Series Classification/Clustering, {\it http://www.cs.ucr.edu/\~{}eamonn/time\_series\_data/}.\\ +\noindent [12] R.C. Tryon (1939), Cluster analysis. {\it New York: McGraw Hill}.\\ +%\noindent [7] C.C. Aggarwal - éditeur (2006) Data Streams: Models and Algorithms, \{it Advances in Database Systems}. +%[Pegasus: Mining billion-scale graphs in the cloud ? mars 2012, mais 4 pages...] +%Data Warehousing and Knowledge Discovery. +%TODO : find paper : +%http://melmeric.files.wordpress.com/2013/04/samoa-a-platform-for-mining-big-data-streams.pdf +%http://yahooeng.tumblr.com/post/65453012905/introducing-samoa-an-open-source-platform-for-mining + +%\noindent [2] Auteurs (ann\'ee), Titre, revue, localisation. +%~ \noindent [3] Achin, M. et Quidont, C. (2000), {\it Th\'eorie des +%~ Catalogues}, Editions du Soleil, Montpellier. + +\end{document} + +%~ Possible références : +%~ +%~ == general +%~ +%~ The Elements of Statistical Learning, Trevor Hastie, Robert Tibshirani, Jerome H. Friedman +%~ (14.3.10 vers page 515) +%~ +%~ Titre Clustering by Means of Medoids +%~ Volume 3 ;Volume 87 de Reports of the Faculty of Mathematics and Informatics. Delft University of Technology +%~ Numéro 87,Partie 3 de Reports of the Faculty of Mathematics and Informatics +%~ Auteurs Leonard Kaufman, Peter Rousseeuw +%~ Éditeur Fac., Univ., 1987 +%~ Longueur 14 pages +%~ +%~ Finding Groups in Data: An Introduction to Cluster Analysis (Wiley Series in Probability and Statistics) [Paperback] +%~ Leonard Kaufman (Author), Peter J. Rousseeuw (Author) +%~ +%~ == extensions, generalisations, autres algos... +%~ +%~ K-AP: Generating Specified K Clusters by Efficient Affinity Propagation +%~ Xiangliang Zhang, Wei Wang, Kjetil Nørvag, and Michele Sebag +%~ http://www.idi.ntnu.no/~noervaag/papers/ICDM2010.pdf +%~ +%~ A Coherent and Heterogeneous Approach to Clustering +%~ Arian Maleki, Nima Asgharbeigi +%~ http://www.ece.rice.edu/~mam15/geo_kmedoid_AIPR08.pdf +%~ +%~ An Efficient K-Medoids-Based Algorithm Using Previous Medoid Index, Triangular Inequality Elimination Criteria, and Partial Distance Search +%~ Shu-Chuan Chu, +%~ John F. Roddick, +%~ J. S. Pan +%~ Data Warehousing and Knowledge Discovery +%~ Lecture Notes in Computer Science Volume 2454, 2002, pp 63-72 +%~ +%~ http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.89.3069&rep=rep1&type=pdf +%~ An efficient approach to scale up k-medoid based algorithms in large databases +%~ Maria Camila N. Barioni, Humberto L. Razente, Agma J. M. Traina, Caetano Traina Jr. ∗ +%~ XXI Simpósio Brasileiro de Banco de Dados +%~ +%~ Computational Science and Its Applications – ICCSA 2005 +%~ Lecture Notes in Computer Science Volume 3482, 2005, pp 181-189 +%~ A New and Efficient K-Medoid Algorithm for Spatial Clustering + %~ Qiaoping Zhang, + %~ Isabelle Couloigner +%~ +%~ == parallel +%~ +%~ Scaling Up Machine Learning: Parallel and Distributed Approaches +%~ Ron Bekkerman, Mikhail Bilenko, John Langford +%~ +%~ http://www.cs.umn.edu/tech_reports_upload/tr2001/01-001.pdf +%~ http://www.cs.umn.edu/research/technical_reports/view/01-001 +%~ http://www.cs.cmu.edu/~lingwang/lectures/paralleldatamining2013.pdf +%~ ... +%~ +%~ == k-medoids parallel +%~ +%~ Parallelising the k-Medoids Clustering Problem Using Space-Partitioning +%~ Alejandro Arbelaez, Luis Quesada +%~ http://www.aaai.org/ocs/index.php/SOCS/SOCS13/paper/viewFile/7225/6231 +%~ +%~ K-Medoids: CUDA Implementation +%~ Douglas Roberts +%~ +%~ Parallelization of K-medoid clustering algorithm +%~ Aljoby, W. ; Queen Arwa Univ., Yemen ; Alenezi, K. + %~ Published in: +%~ Information and Communication Technology for the Muslim World (ICT4M), 2013 5th International Conference on +%~ Date of Conference: 26-27 March 2013 +%~ Page(s): + %~ 1 - 4 +%~ Print ISBN: + %~ 978-1-4799-0134-0 +%~ INSPEC Accession Number: + %~ 13518450 +%~ +%~ R package sprint +%~ http://www.ed.ac.uk/schools-departments/pathway-medicine/our-research/ghazal-group/pathway-informatics/sprint/download +%~ http://www.biomedcentral.com/1471-2105/9/558 +%~ Software +%~ SPRINT: A new parallel framework for R +%~ Jon Hill1*, Matthew Hambley1, Thorsten Forster2, Muriel Mewissen2, Terence M Sloan1, Florian Scharinger1, Arthur Trew1 and Peter Ghazal2 +%~ http://www.biomedcentral.com/content/pdf/1471-2105-9-558.pdf +%~ +%~ ??? +%~ +%~ BIRCH: an efficient data clustering method for very large databases +%~ Authors: Tian Zhang Computer Sciences Dept., Univ. of Wisconsin-Madison + %~ Raghu Ramakrishnan Computer Sciences Dept., Univ. of Wisconsin-Madison + %~ Miron Livny Computer Sciences Dept., Univ. of Wisconsin-Madison +%~ Published in: +%~ SIGMOD '96 Proceedings of the 1996 ACM SIGMOD international conference on Management of data +%~ Pages 103-114 +%~ ACM New York, NY, USA ©1996 +%~ ISBN:0-89791-794-4 doi>10.1145/233269.233324 +%~ +%~ find geometric median (not medoid) +%~ http://users.jyu.fi/~samiayr/pdf/ayramo_eurogen05.pdf +%~ +%~ ... +%~ http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.110.9449&rep=rep1&type=pdf +%~ +%~ http://biostats.bepress.com/cgi/viewcontent.cgi?article=1003&context=ucbbiostat +%~ a new PAM algo... +%~ +%~ k-medoids initialization : +%~ http://seer.lcc.ufmg.br/index.php/jidm/article/viewFile/99/82 diff --git a/latex/short_paper/JDS2014_short2.tex b/latex/short_paper/JDS2014_short2.tex new file mode 100644 index 0000000..0700b33 --- /dev/null +++ b/latex/short_paper/JDS2014_short2.tex @@ -0,0 +1,354 @@ +\documentclass[12pt]{article} +% +% +% Retirez le caractere "%" au debut de la ligne ci--dessous si votre +% editeur de texte utilise des caracteres accentues +%\usepackage[latin1]{inputenc} +\usepackage[utf8]{inputenc} + +% +% Retirez le caractere "%" au debut des lignes ci--dessous si vous +% utiisez les symboles et macros de l'AMS +\usepackage{amsmath} +\usepackage{amsfonts} +% +% +\setlength{\textwidth}{16cm} +\setlength{\textheight}{21cm} +\setlength{\hoffset}{-1.4cm} + +% for figures and tables +\usepackage{float} +\usepackage{graphicx} +\usepackage{wrapfig} +\usepackage{xcolor} +\usepackage{hyperref} +\hypersetup{ + colorlinks, + linkcolor=black, + urlcolor=violet +} +\usepackage{scrextend} +\usepackage{booktabs} +% +% +\begin{document} + +%-------------------------------------------------------------------------- + +\begin{center} +{\Large + {\sc Parallélisation de l'algorithme des $k$-médoïdes. Application au clustering de courbes.} %heuristique ?! +} +\bigskip + +Benjamin Auder $^{1}$ \& Jairo Cugliari $^{2}$ +\bigskip + +{\it +$^{1}$ Laboratoire LMO. Université Paris-Sud. Bât 425. 91405 Orsay Cedex, France.\\benjamin.auder@math.u-psud.fr + +$^{2}$ Laboratoire ERIC. Université Lumière Lyon 2. Bât K. 69676 Bron Cedex, France.\\jairo.cugliari@univ-lyon2.fr +} +\end{center} +\bigskip + +%-------------------------------------------------------------------------- + +{\bf R\'esum\'e.} +Nous présentons une méthode de clustering adaptée à de grandes bases de données de courbes densément discrétisées, donc elle-mêmes en grande dimension. +La classification obtenue peut être utilisée afin de choisir de meilleurs modèles de prédiction de courbes, plus spécifiques, dans chacun des groupes. +La méthode consiste en deux principales étapes : +réduire la dimension des courbes via une base d'ondelettes, puis effectuer le clustering en parallèle. +Les ondelettes sont bien adaptées pour identifier des caractéristiques localisées en temps et échelle. +De plus, l'aspect multi-résolution de la transformée en ondelettes permet de regrouper les coefficients +selon leur contribution à l'énergie totale, fournissant ainsi des représentants compacts pour chaque courbe. +L'algorithme des $k$-médoïdes est appliqué à plusieurs sous-échantillons de l'ensemble des représentations réduites, +puis les centres finaux sont obtenus en recherchant la médiane (ou éventuellement la moyenne) des médoïdes des échantillons. +Des applications sont présentées sur deux jeux de données, dont les consommations électriques irlandaises journalières. +\smallskip + +{\bf Mots-cl\'es.} réduction de dimension, ondelettes, $k$-médoïdes, parallèle +\bigskip\bigskip + +{\bf Abstract.} +We present a clustering method adapted to large databases of densely sampled curves, hence themselves in high dimension. +The resulting classification can help to better tune models to predict new curves, each in every group. +The method consists of two main steps: +use a wavelet basis to reduce curves dimensionality, and then run a parallel clustering algorithm. +Wavelets are well suited to identify characteristics localized both in time and space. +Moreover, the multiresolution nature of the wavelets transform allows to group coefficients according to their +contribution to the total energy, thus providing compact representations for every curve. +The $k$-medoids algorithm is applied to several subsamples of all the reduced representations, and then the final +centers are obtained by computing the median (or mean) of the samples medoids. +Applications are shown on two databases, including Irish daily electrical consumptions. +\smallskip + +{\bf Keywords.} dimensionality reduction, wavelets, $k$-medoids, parallel + +%~ Nous présentons une méthode de clustering adaptée à de grandes bases de données de courbes densément discrétisées, donc elle-mêmes en grande dimension. La classification obtenue peut être utilisée afin de choisir de meilleurs modèles de prédiction de courbes, plus spécifiques, dans chacun des groupes. La méthode consiste en deux principales étapes : réduire la dimension des courbes via une base d'ondelettes, puis effectuer le clustering en parallèle. Les ondelettes sont bien adaptées pour identifier des caractéristiques localisées en temps et échelle. De plus, l'aspect multi-résolution de la transformée en ondelettes permet de regrouper les coefficients selon leur contribution à l'énergie totale, fournissant ainsi des représentants compacts pour chaque courbe. L'algorithme des k-médoïdes est appliqué à plusieurs sous-échantillons de l'ensemble des représentations réduites, puis les centres finaux sont obtenus en recherchant la médiane (ou éventuellement la moyenne) des médoïdes des échantillons. Des applications sont présentées sur deux jeux de données, dont les consommations électriques irlandaises journalières. + +%-------------------------------------------------------------------------- + +\section{Introduction} + +% * clustering +% * parallelisation of clustering +% * fda + wavelets +% * données individuelles de conso + +Récemment, le contexte du \textit{Big Data} a rendu nécessaire le développement d'algorithmes spécifiques à de (très) +grands volumes de données, éventuellement aussi en grande dimension comme c'est le cas dans notre étude. +Ainsi ont vu le jour des algorithmes opérant sur de grands graphes (Kang et al.~2009) ou sur des flux de données haut débit (De Francisci Morales et Bifet~2013), entre entres. +Le livre de Bekkerman et al.~(2011) présente des algorithmes de Machine Learning s'exécutant en parallèle sur diverses architectures, et +ce type de programmation est en plein essor.\\ + +\noindent La classification non supervisée (\textit{clustering}) est une des branches de l'apprentissage non supervisé. +L'objectif est de regrouper les données en \textit{clusters} homogènes, suffisamment distincts deux à deux. +Depuis la proposition originale de Tyron~(1939) un grand nombre d'articles ont été publié à ce sujet (voir Berkhin~2006 pour une revue). +Cependant, il n'y a pas de consensus sur la définition d'un cluster : celle-ci varie en fonction des données, du contexte et de l'algorithme utilisé. +Malgré ce fait, la classification non supervisée reste une technique très populaire qui permet +de réduire la taille des données en les résumant à quelques représentants ; c'est particulièrement intéressant lorsqu'on travaille sur de grosses bases de données.\\ + +\noindent Dans ce travail nous avons choisi d'adapter un algorithme de clustering classique pour une exécution parallèle, opérant sur des données de dimension réduite. +La première partie présente la technique retenue afin d'abaisser la dimension via une base d'ondelettes. +L'algorithme classant les données en parallèle est expliqué dans la seconde partie, puis nous montrons quelques résultats de tests. + +\section{Réduction de dimension} + +Dans cette section nous expliquons comment sont traitées les variables fonctionnelles (voir Antoniadis et al.~(2013) pour plus de détails).\\ + +\noindent Chaque fonction $z$ est d'abord discrétisée sur une fine grille (toutes les 30 minutes pour les consommations électriques), et +la discrétisation est encore notée $z = \{ z(t_i), i = 1, \ldots, N \}$. +$z$ est alors approchée (jusqu'à l'échelle $J$) par un développement tronqué sur une base d'ondelettes avec un coefficient d'échelle $c_{0,0}$ +et les coefficients d'ondelettes $\{d_{j, k}\}_{j, k}$ : +% +\begin{equation} \label{approx} + z_J(t) = c_{0,0} \phi_{0, 0} (t) + \sum_{j=0}^{J-1} \sum_{k=0}^{2^j - 1} d_{j,k} \psi_{j, k} (t). +\end{equation} +Alors, l'énergie $\mathcal{E}_Z = \| z \|^2_{ L_2 }$ de chaque fonction $z$ est égale à la somme des énergies +de ses coefficients en ondelettes distribuées à travers les échelles : +% +\begin{equation} \label{scaledist} + \mathcal{E}_z \approx c_{0,0}^2 + \sum_{j=0}^{J-1} \| \mathbf{W}_j \|^2_2, +\end{equation} +% +où $\| \mathbf{W}_j \|^2_2 = (d_{j, 0}, \ldots d_{j, 2^j - 1})'$, l'approximation étant due à la troncature à l'échelle $J$. +On ne s'intéresse qu'à l'information contenue dans la forme des fonctions, pas à celle de son niveau moyen. +Ainsi, on définit la contribution absolue de l'échelle $j$ à l'énergie globale de la fonction centrée comme + \[ \hbox{cont}_j = \| \mathbf{W}_j \|^2_2, \qquad j=0,\ldots,J-1. \] +Finalement, chaque fonction est caractérisée par le vecteur de ses contributions absolues à l'énergie globale.\\ + +\noindent En pratique nous choisissons $J$ de l'ordre de $\log_2(N)$ : c'est la valeur maximale possible compte-tenu de la discrétisation. + +\section{$k$-médoïdes parallèle} + +Nous rappelons tout d'abord l'algorithme des $k$-médoïdes, puis indiquons comment s'est déroulée la parallélisation.\\ + +%\subsection{Algorithme des $k$-médoïdes} +\noindent \textbf{Algorithme des $k$-médoïdes}\\ +Comme dans l'algorithme des $k$-means, l'idée est de partitionner les données autour de $k$ centres, ici appelés \emph{médoïdes}. +La fonction à minimiser (\emph{distorsion}) est similaire : +$$D(x) = \min_{m_1,\dots,m_k \in \mathbb{R}^d} \sum_{i=1}^{n} \min_{j=1,\dots,k} \| x_i - m_j \| \, ,$$ +avec $x = (x_1,\dots,x_n)$, $\|\,.\,\|$ pouvant désigner n'importe quelle norme ; ici nous choisissons la norme euclidienne. +Les distances n'apparaissant pas au carré, cet algorithme est moins sensible aux outliers que le $k$-means. +Cependant, sa programmation est plus délicate car dans le cas de la médiane spatiale il n'existe pas de formule analogue à celle de la moyenne. +La première implémentation de l'algorithme est celle de Kaufman et Rousseeuw~(1987), PAM pour Partitioning Around Medoids. +Elle est assez coûteuse, mais donne de bons résultats et reste simple à écrire. Diverses heuristiques ou accélérations autour de cette implémentation +ont été développés (voir Chu et al.~2002 par exemple), mais nous utilisons ici la version originale, qui se révèle suffisante.\\ +%TODO: encadré algo PAM. [si reste de la place...] + +%\subsection{Parallélisation avec MPI} +\noindent \textbf{Parallélisation avec MPI}\\ +MPI est une librarie permettant de faciliter l'écriture de programmes en parallèle. +%Elle est disponible pour divers langages dont le C, que nous avons choisi. +%~ Son principe est le suivant : +%~ \begin{enumerate} +%~ \item un certain nombre de coeurs de calcul sont alloués et initialisés avec les mêmes valeurs sauf une : le rang du processus ; +%~ \item chaque coeur exécute séquentiellement deux types d'instructions : locales, comme dans un programme normal, +%~ et de communication, où il envoie un ou plusieurs message à un ou plusieurs autres processus. Ces messages peuvent demander ou envoyer des résultats, mais aussi +%~ effectuer des actions plus élaborées comme [TODO] +%~ \item le calcul se termine lorsque tous les coeurs sont arrêtés. +%~ \end{enumerate} +Nous l'utilisons en mode master-slave, c'est à dire que le travail est divisé en deux types d'entités: un processus coordinateur, +et des coeurs se contentant d'exécuter les demandes du processus maître. +%~ \begin{itemize} +%~ \item master : reçoit l'entrée initiale, coordonne les autres processus pour effectuer la tâche, et rassemble les résultats ; +%~ \item slave : boucle en attendant des instructions du processus maître, exécute les sous-tâches et retourne les résultats partiels. +%~ \end{itemize} +Voici le flot d'exécution du programme final :\\ +%\begin{enumerate} +\begin{addmargin}[1em]{2em}% 1em left, 2em right +\noindent \textbf{1.} le processus maître découpe le problème en sous-tâches sur des jeux de données plus petits, et les envoie à chaque esclave ;\\ +\textbf{2.} pour une sous-tâche donnée, on réduit la dimension puis applique l'algorithme de clustering, et retourne les centres ;\\ +\textbf{3.} le processus principal récupère et aggrège les résultats en un jeu de $k$ centres.\\ +\end{addmargin} +%\end{enumerate} +Le code sera disponible prochainement sur \href{https://github.com/}{github}. +%TODO: code disponible en ligne sur github. (faut beautifier quelques bricoles dans le code d'abord, en particulier serialize/deserialize et type d'ondelette en argument (?!) + +\section{Applications} + +Deux jeux de données ont été utilisés ici : des évolutions de magnitudes d'étoiles, et de consommations électriques de clients individuels. + +\subsection{Magnitudes d'étoiles} + +Ce jeu de données récupéré via le site web de Keogh et al.~(2011) consiste en un ensemble d'entraînement de 1000 courbes, +et une base de test de 8236 courbes. Chacune d'entre elle a un label compris entre 1 et 3 ; la figure \ref{figsltr3clusts} les représente. +On remarque que les groupes 1 et 3 sont assez similaires, contenant des courbes difficiles à classer. + +\begin{figure}[H] +\begin{minipage}[c]{.32\linewidth} + \includegraphics[width=5cm,height=3.5cm]{img/slgr1.png} + \vspace*{-0.3cm} + \caption{Groupe 1} +\end{minipage} +\begin{minipage}[c]{.32\linewidth} + \includegraphics[width=5cm,height=3.5cm]{img/slgr2.png} + \vspace*{-0.3cm} + \caption{Groupe 2} +\end{minipage} +\begin{minipage}[c]{.32\linewidth} + \includegraphics[width=5cm,height=3.5cm]{img/slgr3.png} + \vspace*{-0.3cm} + \caption{Groupe 3} +\end{minipage} +\label{figsltr3clusts} +\end{figure} + +Compte-tenu du relatif faible nombre d'échantillons nous pouvons lancer le programme sur tout le jeu de données ; +cela permet de comparer aux résultats obtenus par la version parallèle, que l'on espère presque aussi bons. +Le tableau \ref{tabDistorSl} contient les distorsions empiriques calculées sur les ensemble d'entraînement et de test, +ainsi que l'adéquation des deux partitions ("intra"), et leur adéquation à la partition réelle ("inter"). Cette dernière est mauvaise à cause de la remarque précitée : +les courbes des clusters 1 et 3 se ressemblent trop pour appliquer un algorithme de partitionnement de type $k$-means.\\ + +\begin{table}[H] +\centering +\begin{tabular}{lccc} +\toprule + & & \multicolumn{2}{c}{Adéquation} \\ + & Distorsion & Intra & Inter \\ +\midrule +Entraînement séquentielle. & 1.31e4 & 0.79 & 0.77\\ +%\hline +Entraînement parallèle & 1.40e4 & 0.79 & 0.68\\ +%\hline +Test séquentielle & 1.09e5 & 0.78 & 0.76\\ +%\hline +Test parallèle & 1.15e5 & 0.78 & 0.69\\ +\bottomrule +\end{tabular} +\caption{Distorsions et indices d'adéquation des partitions} +\label{tabDistorSl} +\end{table} + +% \begin{table}[H] +% \centering +% \begin{tabular}{|l|c|c|c|} +% \hline +% & Distorsion & "Intra-adéquation" & "Inter-adéquation" \\ +% \hline +% Entraînement seq. & 1.31e4 & 0.79 & 0.77\\ +% \hline +% Entraînement // & 1.40e4 & 0.79 & 0.68\\ +% \hline +% Test seq. & 1.09e5 & 0.78 & 0.76\\ +% \hline +% Test // & 1.15e5 & 0.78 & 0.69\\ +% \hline +% \end{tabular} +% \caption{Distorsions et indices d'adéquation des partitions} +% \label{tabDistorSl} +% \end{table} + +%~ 1) Starlight curves : utiliser 1000 (resp. 3000) courbes pour le clustering, puis ~9000 (resp. ~7000) pour classif. +%~ Comparer les médoïdes (renuméroter en sortie du code), et afficher les perfs : taux de classif correcte. + +\subsection{Consommations électriques irlandaises} + +Nous utilisons les données de consommation d'électricité de foyers irlandais (Electricity Smart Meter CBT) de l'ISSDA\footnote{\textit{Irish Social Science Data Archive}, \url{http://www.ucd.ie/issda/data/}.}. Après nettoyage des données manquantes, ce jeu de données consiste en 4621 séries temporelles représentant l'évolution de la consommation électrique d'autant de foyers irlandais. +%Celles-ci sont similaires aux courbes EDF sur lesquelles vise à être appliquée notre méthode. +Nous avons choisi d'appliquer l'algorithme avec 3 et 5 classes. Compte-tenu du grand nombre de points de discrétisation (25k) +et de la haute variabilité des données, celles-ci sont difficiles à représenter. Ainsi nous n'indiquons que les résultats numériques ; +ils sont visibles dans le tableau \ref{tabDistorIr}, et sont cette fois plutôt bons.\\ + +\begin{table}[H] +\centering +\begin{tabular}{lcc} \toprule +%\hline + & & Intra-adéquation \\ + & Distorsion & séquentielle vs parallèle \\ +\midrule %\hline +3 clusters séquentielle & 1.90e7 & 0.90\\ +%\hline +3 clusters parallèle & 2.15e7 & 0.90\\ +%\hline +5 clusters séquentielle & 1.61e7 & 0.89\\ +%\hline +5 clusters parallèle & 1.84e7 & 0.89\\ +\bottomrule %\hline +\end{tabular} +\caption{Distorsions et indices d'adéquation des partitions} +\label{tabDistorIr} +\end{table} +%pour un nombre de clusters égal à 3, 7 et 15. + +\section{Conclusion} + +Nous avons cherché à identifier des groupes de consommateurs à partir de données fonctionnelles +pour bénéficier de l'information supplémentaire fournie par la forme des courbes, qui serait perdue +si on les considérait comme de simples vecteurs. Cette forme est capturée $-$ entre autres caractéristiques $-$ +par les coefficients d'ondelettes, regroupés par niveaux d'énergie. Les dissimilarités sont calculées ensuite +via une distance $L^p$. Alternativement (ou complémentairement), il serait intéressant d'utiliser une mesure de dissimilarité +plus directement basée sur la forme des courbes, comme le font Antoniadis et al.~(2013) ou Heckman et Zamar~(2000). + +Ensuite, la procédure de clustering mise en place est prévue pour passer à l'échelle. Initialement conçue pour être appliquée sur un jeu de données de plusieurs dizaines de millions de courbes, elle pourrait être appliquée à l'ensemble de clients d'un pays. Les résultats obtenus sur les deux jeux de données présentés sont assez encourageants, et permettent d'envisager une utilisation à plus grande échelle. + +%~ \section{Exemple de r\'ef\'erences bibliographiques} +%~ La n\'ecessit\'e de produire des r\'esum\'es clairs et bien +%~ r\'ef\'erenc\'es a \'et\'e d\'emontr\'ee par Achin et Quidont~(2000). +%~ Le r\'ecent article de Noteur~(2003) met en \'evidence \dots + +%Quelques rappels : +%% +%\begin{center} +%% +%\begin{tabular}{lr} \hline +%% +%Accent aigu : & \'e; \\ +%Accent grave : & \`a;\\ +%Accent circonflexe : & \^o mais \^{\i};\\ +%Tr\'emas : & \"o mais \"{\i};\\ +%C\'edille : & \c{c}. \\ \hline +%\end{tabular} +%% +%\end{center} + +%-------------------------------------------------------------------------- + +\section*{Bibliographie} + +\noindent [1] A. Antoniadis, X. Brossat, J. Cugliari et J.-M. Poggi (2013), Clustering Functional Data Using Wavelets, {\it International Journal of Wavelets, Multiresolution and Information Processing}, 11(1), 35--64.\\ +\noindent [2] R. Bekkerman, M. Bilenko et J. Langford - éditeurs (2011), Scaling up Machine Learning: Parallel and Distributed Approaches, {\it Cambridge University Press}.\\ +\noindent [3] P. Berkhin (2006), A Survey of Clustering Data Mining Techniques, {\it Grouping Multidimensional Data, éditeurs : J. Kogan, C. Nicholas, M. Teboulle}.\\ +\noindent [4] S.-C. Chu, J.F. Roddick et J.S. Pan (2002), An Efficient K-Medoids-Based Algorithm Using Previous Medoid Index, Triangular Inequality Elimination Criteria, and Partial Distance Search, {\it Lecture Notes in Computer Science}, 2454, 63--72.\\ +\noindent [5] G. De Francisci Morales et A. Bifet (2013), G. De Francisci Morales SAMOA: A Platform for Mining Big Data Streams Keynote Talk at RAMSS ’13: 2nd International Workshop on Real-Time Analysis and Mining of Social Streams WWW, Rio De Janeiro.\\ +\noindent [6] N.E. Heckman et R.H. Zamar (2000), Comparing the shapes of regression functions. {\it Biometrika}, 87(1), 135--144.\\ +\noindent [7] U. Kang, C.E. Tsourakakis et C. Faloutsos (2009), PEGASUS: A Peta-Scale Graph Mining System - Implementation and Observations, {\it IEEE International Conference on Data Mining}.\\ +\noindent [8] L. Kaufman et P.J. Rousseeuw (1987), Clustering by means of Medoids, {\it Statistical Data Analysis Based on the L\_1-Norm and Related Methods, éditeur : Y. Dodge}.\\ +\noindent [9] E. Keogh, Q. Zhu, B. Hu, Y. Hao, X. Xi, L. Wei et C.A. Ratanamahatana (2011), The UCR Time Series Classification/Clustering, \url{ www.cs.ucr.edu/\~eamonn/time\_series\_data/}.\\ +\noindent [10] R.C. Tryon (1939), Cluster analysis. {\it New York: McGraw Hill}.\\ + + + +\end{document} + + + +%\noindent [7] C.C. Aggarwal - éditeur (2006) Data Streams: Models and Algorithms, \{it Advances in Database Systems}. +%[Pegasus: Mining billion-scale graphs in the cloud ? mars 2012, mais 4 pages...] +%Data Warehousing and Knowledge Discovery. + +%\noindent [4] F. Chang, J. Dean, S. Ghemawat, W.C. Hsieh, D.A. Wallach, M. Burrows, T. Chandra, A. Fikes, et R.E. Gruber (2006), Bigtable: A Distributed Storage System for Structured Data, {\it Seventh Symposium on Operating System Design and Implementation}.\\ + +%\noindent [6] J. Dean et S. Ghemawat (2004), MapReduce: Simplified Data Processing on Large Clusters, {\it Sixth Symposium on Operating System Design and Implementation}.\\ diff --git a/latex/short_paper/img/slgr1.png b/latex/short_paper/img/slgr1.png new file mode 100644 index 0000000..0b7d7b9 Binary files /dev/null and b/latex/short_paper/img/slgr1.png differ diff --git a/latex/short_paper/img/slgr2.png b/latex/short_paper/img/slgr2.png new file mode 100644 index 0000000..d21ca70 Binary files /dev/null and b/latex/short_paper/img/slgr2.png differ diff --git a/latex/short_paper/img/slgr3.png b/latex/short_paper/img/slgr3.png new file mode 100644 index 0000000..077ca5e Binary files /dev/null and b/latex/short_paper/img/slgr3.png differ diff --git a/latex/slides/JdS_20140603/201402-JClust.pdf b/latex/slides/JdS_20140603/201402-JClust.pdf new file mode 100644 index 0000000..cd64e26 Binary files /dev/null and b/latex/slides/JdS_20140603/201402-JClust.pdf differ diff --git a/latex/slides/JdS_20140603/201402-JClust.tex b/latex/slides/JdS_20140603/201402-JClust.tex new file mode 100644 index 0000000..fad7fb6 --- /dev/null +++ b/latex/slides/JdS_20140603/201402-JClust.tex @@ -0,0 +1,603 @@ +\documentclass[xcolor=dvipsnames, smaller]{beamer} + +\usepackage[utf8]{inputenc} +\usepackage{amsmath, amsfonts} +\usepackage[francais]{babel} +\usepackage{hyperref, url, booktabs, subcaption, tikz} +%\usepackage{graphicx} +\hypersetup{colorlinks,linkcolor=black,urlcolor=violet} + +\mode{ + \setbeamertemplate{sections/subsections in toc}[square] + \beamertemplatenavigationsymbolsempty +} + +\newcommand{\N}{\mathbb{N}} % naturals +\newcommand{\set}[1]{\lbrace#1\rbrace} % set +\newcommand{\R}{\mathbb{R}} % real + +\colorlet{darkred}{red!80!black} +\colorlet{darkblue}{blue!80!black} +\colorlet{darkgreen}{green!60!black} + +\usetikzlibrary{calc,decorations.pathmorphing,patterns} +\pgfdeclaredecoration{penciline}{initial}{ + \state{initial}[width=+\pgfdecoratedinputsegmentremainingdistance, + auto corner on length=1mm,]{ + \pgfpathcurveto% + {% From + \pgfqpoint{\pgfdecoratedinputsegmentremainingdistance} + {\pgfdecorationsegmentamplitude} + } + {% Control 1 + \pgfmathrand + \pgfpointadd{\pgfqpoint{\pgfdecoratedinputsegmentremainingdistance}{0pt}} + {\pgfqpoint{-\pgfdecorationsegmentaspect + \pgfdecoratedinputsegmentremainingdistance}% + {\pgfmathresult\pgfdecorationsegmentamplitude} + } + } + {%TO + \pgfpointadd{\pgfpointdecoratedinputsegmentlast}{\pgfpoint{1pt}{1pt}} + } + } + \state{final}{} +} +% +\tikzstyle{block} = [draw,rectangle,thick,minimum height=2em,minimum width=2em] + + + +% = = = = = = = = = = = = = = = = = = = = = = = = Separator = = = = + +\AtBeginSection[]{ + \begin{frame}{Sommaire} + \tableofcontents[currentsection] + \end{frame} +} + +%-------------------------------------------------------------------------- + + +\title{Non supervised classification of individual electricity curves} +\author{Jairo Cugliari} +\institute{%Laboratoire ERIC, Université Lyon 2 +% \begin{center} + % \includegraphics[height = 1.5cm]{pics/logo_dis.png} + % ~~~~% separator + \includegraphics[height = 1cm]{pics/logo_eric.png} +% ~~~~% separator +% \includegraphics[height = 1cm]{pics/logo_lyon2.jpg} +%\end{center} +} + + +\begin{document} + +%-------------------------------------------------------------------------- + +% \begin{frame}[plain] + +\begin{frame}[plain, noframenumbering, b] + +% \begin{center} +% % \includegraphics[height = 1.5cm]{pics/logo_dis.png} +% % ~~~~% separator +% \includegraphics[height = 1.5cm]{pics/logo_eric.png} +% ~~~~% separator +% \includegraphics[height = 1.5cm]{pics/logo_lyon2.jpg} +% \end{center} + +\maketitle + + \begin{center}{\scriptsize + Joint work with Benjamin Auder (LMO, Université Paris-Sud) } + \end{center} + + % \begin{flushright} +% \includegraphics[width = 0.15\textwidth]{pics/by-nc-sa.png} +% \end{flushright} + +\end{frame} + + +% \maketitle +% \begin{center}{\scriptsize +% Joint work with Benjamin Auder (LMO, Université Paris-Sud) } +% \end{center} +% \end{frame} + +%-------------------------------------------------------------------------- + +\frame{\frametitle{Outline} + \tableofcontents +} + +%-------------------------------------------------------------------------- + +\section{Motivation} + + +\begin{frame}{Industrial motivation} + +\begin{columns} +\column{0.6\textwidth} +\begin{itemize} + \item Smartgrid \& Smart meters : time real information + \item Lot of data of different nature + \item Many problems : transfer protocol, security, privacy, ... + \item The French touch: 35M Linky smartmeter +\end{itemize} + +\vskip 1cm + +What can we do with all these data ? + +\column{0.4\textwidth} +\includegraphics[width = \textwidth]{./pics/smartgrid.jpg} + +\includegraphics[width = \textwidth]{./pics/linky.jpg} +\end{columns} +\end{frame} + +%-------------------------------------------------------------------------- + +\begin{frame}{Electricity demand data} +\framesubtitle{Some salient features} + +\begin{figure}[!ht] \centering + \begin{subfigure}[t]{0.45\textwidth} + \includegraphics[width=\textwidth]{pics/longtermload.png} + \caption{Long term trand} %\label{fig:gull} + \end{subfigure}% + ~ %spacing between images + \begin{subfigure}[t]{0.45\textwidth} + \includegraphics[width=\textwidth]{pics/twoyearsload.png} + \caption{Weekly cycle} % \label{fig:tiger} + \end{subfigure} + + \begin{subfigure}[t]{0.45\textwidth} + \includegraphics[width=\textwidth]{pics/dailyloads.png} + \caption{Daily load curve} % \label{fig:mouse} + \end{subfigure} + ~ %spacing between images + \begin{subfigure}[t]{0.45\textwidth} + \includegraphics[width=\textwidth]{pics/consotemp.png} + \caption{Electricity load vs. temperature} + \end{subfigure} +\end{figure} +\end{frame} + +%-------------------------------------------------------------------------- + +\begin{frame}[shrink]{FD as slices of a continuous process + \begin{scriptsize} \hfill [Bosq, (1990)] \end{scriptsize}} +% + The prediction problem + +\begin{itemize} + \item Suppose one observes a square integrable continuous-time stochastic process $X=(X(t), t\in\R)$ over the interval $[0,T]$, $T>0$; + \item {We want to predict $X$ all over the segment $[T, T+\delta], \delta>0$} + \item {Divide the interval into $n$ subintervals of equal + size $\delta$.} + \item Consider the functional-valued discrete time stochastic process $ Z = (Z_k, k\in\N) $, where $ \mathbb{N} = \set{ 1,2,\ldots } $, defined by +\end{itemize} + +\begin{columns} + \column{5cm} + \input{tikz/axis2} + \column{5cm} + \[ Z_k(t) = X(t + (k-1)\delta) \] + \[ k\in\N \;\;\; \forall t \in [0,\delta) \] +\end{columns} + +\vfill + If $X$ contents a $\delta-$seasonal component, + $Z$ is particularly fruitful. + +\end{frame} + +%-------------------------------------------------------------------------- + +\begin{frame}{Long term objective} + +\begin{columns} +\column{.6\textwidth} +%\begin{figure}[!ht]\centering + \includegraphics[width = \textwidth]{pics/schema.png} +%\caption{Hierarchical structure of $N$ individual clients among $K$ groups.}\label{fig:schema-hier} +%\end{figure} + +\column{.4\textwidth} +\begin{tikzpicture}[decoration=penciline, decorate] + \node[block, decorate] at (0, 0){$Z_t$} ; + \node[block, decorate] at (3, 0) {$Z_{t + 1}$} ; + + \node[block, decorate] at (0, -2.5) {$\begin{pmatrix} + Z_{t, 1} \\ Z_{t, 2} \\ \vdots \\ Z_{t, K} + \end{pmatrix}$ }; + + \node[block, decorate] at (3, -2.5) {$\begin{pmatrix} + Z_{t+1, 1} \\ Z_{t+1, 2} \\ \vdots \\ Z_{t+1, k} + \end{pmatrix} $}; + + \draw[decorate, darkblue, line width = 2mm, ->] (1, 0) -- (2, 0); + \draw[decorate, darkgreen, line width = 2mm, ->] (1, -2.5) -- (2, -2.5); + \draw[decorate, black, line width = 2mm, ->] (3, -1.3) -- (3, -0.4); + \draw[decorate, darkred, line width = 2mm, ->] (1, -1.5) -- (2, -0.75); + \end{tikzpicture} +\end{columns} + +\begin{itemize} + \item Groups can express tariffs, geographical dispersion, client class ... + \item \textbf{IDEA}: Use a clustering algorithm to learn groups of customer structure + \item \textbf{Aim}: Set up a classical clustering algorithm to run in parallel +\end{itemize} +\end{frame} + +%-------------------------------------------------------------------------- + +\section{Functional clustering} + +\begin{frame}{Aim} + +\begin{columns} + \column{0.6\textwidth} + \begin{block}{ } + \begin{itemize} + \item Segmentation of $X$ may not suffices to render reasonable + the stationary hypothesis. + \item If a grouping effect exists, we may considered stationary within each group. + \item Conditionally on the grouping, functional time series prediction methods + can be applied. + \item We propose a clustering procedure that discover the groups from a bunch + of curves. + \end{itemize} + + We use wavelet transforms to take into account the fact + that curves may present non stationary patters. + \end{block} + + \column{0.4\textwidth} + \includegraphics[width=0.9\textwidth, + height=2.7cm]{pics/conso-traj.png} + + Two strategies to cluster functional time series: + \begin{enumerate} + \item Feature extraction (summary measures of the curves). + \item Direct similarity between curves. + \end{enumerate} + +\end{columns} +\end{frame} + +%--------------------------- + +\begin{frame}[plain]{Wavelets to cope with \textsc{fd}} + +\begin{columns} + \column{.6\textwidth} + %\begin{figure} + \centering + \includegraphics[width = \textwidth]{./pics/weekly-5.png} + % * * * * * * * * * * * * * * * * * * * + \column{.4\textwidth} +\begin{block}{ } %Wavelet transform} +\begin{footnotesize} +\begin{itemize} + \item domain-transform technique for hierarchical decomposing finite energy signals + \item description in terms of a broad trend (\textcolor{PineGreen}{approximation part}), plus a set of localized changes kept in the \textcolor{red}{details parts}. +\end{itemize} +\end{footnotesize} +\end{block} +\end{columns} + +\begin{block}{Discrete Wavelet Transform } + + If $z \in L_2([0, 1])$ we can write it as + + \begin{equation*}\label{eq:zeta} + z(t) = \sum_{k=0}^{2^{j_0}-1} \textcolor{PineGreen}{c_{j_0, k}} \phi_{j_0,k} (t) + + \sum_{j={j_0}}^{\infty} + \sum_{k=0}^{2^j-1} \textcolor{red}{d_{j,k}} \psi_{j,k} (t) , + \end{equation*} + +% +where $ c_{j,k} = $, $ d_{j,k} = $ are the +\textcolor{PineGreen}{scale coefficients} and \textcolor{red}{wavelet coefficients} respectively, and the functions $\phi$ et $\varphi$ are associated to a orthogonal \textsc{mra} of $L_2([0, 1])$. +\end{block} +\end{frame} + +%---------------------------------------- SLIDE --------------------- + +\begin{frame}{Energy decomposition of the DWT} + +\begin{block}{ } + \begin{itemize} + \item Energy conservation of the signal +% + \begin{equation*}\label{eq:energy} + \| z \|_H^2 \approx \| \widetilde{z_J} \|_2^2 + = c_{0,0}^2 + \sum_{j=0}^{J-1} \sum_{k=0}^{2^j-1} d_{j,k} ^2 = + c_{0,0}^2 + \sum_{j=0}^{J-1} \| \mathbf{d}_{j} \|_2^2. + \end{equation*} +% \item characterization by the set of channel variances estimated at the output of the corresponding filter bank + \item For each $j=0,1,\ldots,J-1$, we compute the absolute and + relative contribution representations by +% + \[ \underbrace{\hbox{cont}_j = ||\mathbf{d_j}||^2}_{\fbox{AC}} + \qquad \text{and} \qquad + \underbrace{\hbox{rel}_j = + \frac{||\mathbf{d_j}||^2} + {\sum_j ||\mathbf{d_j}||^2 }}_{\fbox{RC}} .\] + \item They quantify the relative importance of the scales to the global dynamic. +% \item Only the wavelet coefficients $\set{d_{j,k}}$ are used. + \item RC normalizes the energy of each signal to 1. +\end{itemize} +\end{block} +\end{frame} +% ======================================= + +\begin{frame} + \frametitle{Schema of procedure} + \begin{center} + \includegraphics[width = 7cm, height = 2cm]{./pics/Diagramme1.png} + % Diagramme1.png: 751x260 pixel, 72dpi, 26.49x9.17 cm, bb=0 0 751 260 + \end{center} + + \begin{footnotesize} +\begin{description} + \item [0. Data preprocessing.] Approximate sample paths of $z_1(t),\ldots,z_n(t)$ %by the truncated wavelet series at the scale $J$ from sampled data $\mathbf{z}_1, \ldots, \mathbf{z}_n$. + \item [1. Feature extraction.] Compute either of the energetic components using absolute contribution (AC) or relative contribution (RC). + \item [2. Feature selection.] Screen irrelevant variables. \begin{tiny} [Steinley \& Brusco ('06)]\end{tiny} + \item [3. Determine the number of clusters.] Detecting significant jumps in the transformed distortion curve. + \begin{tiny} [Sugar \& James ('03)]\end{tiny} + \item [4. Clustering.] Obtain the $K$ clusters using PAM algorithm. +\end{description} \end{footnotesize} + +\footnotetext[1]{Antoniadis, X. Brossat, J. Cugliari et J.-M. Poggi (2013), Clustering Functional Data Using Wavelets, {\it IJWMIP}, 11(1), 35--64} + +\end{frame} + +% =========================================== + +\section{Parallel $k$-medoids} + +\begin{frame}{Partitioning Around Medoids (PAM) + \begin{scriptsize} \hfill [Kaufman et Rousseeuw~(1987)] \end{scriptsize}} + +\begin{itemize} + \item Partition the $n$ points $R^d$-scatter into $K$ clusters + \item Optimization problem : + \[ D(x) = \min_{m_1,\dots,m_k \in \mathbb{R}^d} \sum_{i=1}^{n} \min_{j=1,\dots,k} \| x_i - m_j \| \, ,\] +with $x = (x_1,\dots,x_n)$, $\|\,.\,\|$ can be any norm. Here we choose to use the euclidean norm. + \item Robust version of $k$-means + \item Computational burden : medians instead of means + \item Several heuristics allow to reduce the computation time. +\end{itemize} +\end{frame} + +% =========================================== + +\begin{frame}{Parallelization with MPI} + +\begin{columns} +\column{.8\textwidth} +\begin{itemize} + \item Easy to use library routines allowing to write algorithms in parallel + \item Available on several languages + \item We use the master-slave mode +\end{itemize} + +\column{.2\textwidth} +\includegraphics[width=\textwidth]{./pics/open-mpi-logo.png} +\end{columns} + +\vfill + +\begin{block}{The outline of code:} +\begin{enumerate} + \item The master process splits the problem in tasks over the data set and sends it to the workers; + \item Each worker reduces the functional nature of the data using the DWT, applies the clustering and returns the centers; + \item The master recuperates and clusters the centers into $K$ meta centers. +\end{enumerate} +\end{block} + +The source code is open and will be available to download from +\href{https://github.com/}{github}. + +\footnotetext[1]{B. Auder \& J. Cugliari. Parallélisation de l'algorithme des $k$-médoïdes. Application au clustering de courbes. (2014, submitted)} +\end{frame} + +\section{Numerical experiences} + +% =========================================== + +\begin{frame}{Application I: Starlight curves} + +\begin{itemize} + \item Data from UCR Time Series Classification/Clustering + \item 1000 curves learning set + 8236 validation set ($d= 1024$)% discretization points +\end{itemize} + +\begin{figure}[H] +\begin{minipage}[c]{.32\linewidth} + \includegraphics[width=\linewidth,height=3.5cm]{pics/slgr1.png} + %\vspace*{-0.3cm} + \caption{Groupe 1} +\end{minipage} +\begin{minipage}[c]{.32\linewidth} + \includegraphics[width=\linewidth,height=3.5cm]{pics/slgr2.png} + %\vspace*{-0.3cm} + \caption{Groupe 2} +\end{minipage} +\begin{minipage}[c]{.32\linewidth} + \includegraphics[width=\linewidth,height=3.5cm]{pics/slgr3.png} + %\vspace*{-0.3cm} + \caption{Groupe 3} +\end{minipage} +\label{figsltr3clusts} +\end{figure} + +\begin{table}[H] +\centering +\begin{tabular}{lccc} \toprule + & & \multicolumn{2}{c}{Adequacy} \\ + & Distortion & Internal & External \\ \midrule +Training (sequential) & 1.31e4 & 0.79 & 0.77 \\ +Training (parallel) & 1.40e4 & 0.79 & 0.68 \\ +Test (sequential) & 1.09e5 & 0.78 & 0.76 \\ +Test (parallel) & 1.15e5 & 0.78 & 0.69 \\ \bottomrule +\end{tabular} +%\caption{Distorsions et indices d'adéquation des partitions} +\label{tabDistorSl} +\end{table} +\end{frame} + +% ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +\begin{frame}{Application II: EDF data} + \begin{figure} + \centering + \includegraphics[width= 0.9\textwidth]{pics/conso-shapes.png} + % conso-traj.eps: 0x0 pixel, 300dpi, 0.00x0.00 cm, bb=18 18 577 824 + \caption{ \begin{footnotesize} +French electricity power demand on autumn (top left), winter (bottom left), spring (top right) and summer (bottom right). \end{footnotesize} } + \label{fig:conso-shapes} + \end{figure} + + \begin{footnotesize} + Feature extraction: + \begin{itemize} + \item The significant scales for revealing the cluster structure are independent of the possible number of clusters. + \item Significant scales are associated to mid-frequencies. + \item The retained scales parametrize the represented cycles of 1.5, 3 and 6 hours (AC). + \end{itemize} \end{footnotesize} +\end{frame} + + +% =========================================== + +\begin{frame} +\begin{figure} + \centering + \includegraphics[width= 0.9\textwidth]{./pics/conso_jump_AC.png} \\ + \caption{ \begin{footnotesize} +Number of clusters by feature extraction of the AC (top). From left to right: distortion curve, transformed distortion curve and first difference on the transformed distortion curve. \end{footnotesize} } + \label{fig:conso-jumps} +\end{figure} + \end{frame} + +% =========================================== + +\begin{frame} +\begin{figure} \centering + \begin{subfigure}[t]{0.45\textwidth} + \includegraphics[width=\textwidth]{./pics/conso_AC-curves.png} + \caption{Cluster} + \end{subfigure} + ~ + \begin{subfigure}[t]{0.45\textwidth} + \includegraphics[width=\textwidth]{./pics/conso_AC-calendar.png} + \caption{Calendar} + \end{subfigure} +% \subfloat[Calendar]{\label{fig:conso_clust_AC_cal} +% \includegraphics[width = 0.45\textwidth]{./pics/conso_AC-calendar.png}} +\caption{Curves membership of the clustering using AC based dissimilarity (a) and the corresponding calendar positioning (b).} + \end{figure} +\end{frame} + + +% =========================================== + + +\begin{frame}{Application III: Electricity Smart Meter CBT (ISSDA)} \small + +\footnotetext[1]{\textit{Irish Social Science Data Archive}, \url{http://www.ucd.ie/issda/data/}} + +\begin{itemize} + \item 4621 Irish households smart meter data % eséries de consommation électrique de foyers irlandais + \item About 25K discretization points + \item We test with $K=$ 3 or 5 classes + \item We compare sequential and parallel versions +\end{itemize} + + +\begin{table}[H] +\centering +\begin{tabular}{lcc} \toprule +% & & \\ + & Distortion & Internal adequacy \\ \midrule +3 clusters sequential & 1.90e7 & 0.90 \\ +3 clusters parallel & 2.15e7 & 0.90 \\ +5 clusters sequential & 1.61e7 & 0.89 \\ +5 clusters parallel & 1.84e7 & 0.89 \\ \bottomrule +\end{tabular} +% \caption{Distorsions et indices d'adéquation des partitions} +\label{tabDistorIr} +\end{table} + +\end{frame} + +%-------------------------------------------------------------------------- + +\section{Conclusion} + +\begin{frame}{Conclusion} + +\begin{itemize} + \item Identification of customers groups from smartmeter data + \item Wavelets allow to capture the functional nature of the data + \item Clustering algorithm upscale envisaged for millions of curves + \item \textit{Divide-and-Conquer} approach thanks to MPI library %pour l'algorithme des $k$-médoïdes : d'abord sur des groupes de données courbes, puis des groupes de médoïdes jusqu'à obtenir un seul ensemble traité sur un processseur. + %\item %Les résultats obtenus sur les deux jeux de données présentés sont assez encourageants, et permettent d'envisager une utilisation à plus grande échelle. +\end{itemize} + +\begin{block}{Further work} +\begin{itemize} + \item Go back to the prediction task + \item Apply the algorithm over many hundreds of processors + \item Connect the clustering method with a prediction model +\end{itemize} +\end{block} +\end{frame} + +%-------------------------------------------------------------------------- + +\begin{frame}[plain]{Bibliographie}\small + +\begin{thebibliography}{10} +\bibitem{1} A. Antoniadis, X. Brossat, J. Cugliari et J.-M. Poggi (2013), Clustering Functional Data Using Wavelets, {\it IJWMIP}, 11(1), 35--64 + +\bibitem{2} R. Bekkerman, M. Bilenko et J. Langford - éditeurs (2011), Scaling up Machine Learning: Parallel and Distributed Approaches, {\it Cambridge University Press} + +\bibitem{3} P. Berkhin (2006), A Survey of Clustering Data Mining Techniques, {\it Grouping Multidimensional Data, éditeurs : J. Kogan, C. Nicholas, M. Teboulle}. + +\bibitem{6} J. Dean et S. Ghemawat (2004), MapReduce: Simplified Data Processing on Large Clusters, {\it Sixth Symposium on Operating System Design and Implementation}. + +\bibitem{7} G. De Francisci Morales et A. Bifet (2013), G. De Francisci Morales SAMOA: A Platform for Mining Big Data Streams Keynote Talk at RAMSS ’13: 2nd International Workshop on Real-Time Analysis and Mining of Social Streams WWW, Rio De Janeiro + +\bibitem{10} L. Kaufman et P.J. Rousseeuw (1987), Clustering by means of Medoids, {\it Statistical Data Analysis Based on the L\_1-Norm and Related Methods, éditeur : Y. Dodge}. +\end{thebibliography} +\end{frame} + + +\end{document} + + +% \begin{frame}{Motivation académique: Big Data} +% \begin{itemize} +% \item Besoins spécifiques: très grands volumes de données, grande dimension +% \item Réponses: algorithmes opérant sur de grands graphes (Kang et al.~2009), sur des flux de données haut débit (De Francisci Morales et Bifet~2013) +% \item Bekkerman et al.~(2011): algorithmes de Machine Learning s'exécutant en parallèle +% \end{itemize} +% +% \begin{itemize} +% \item classification non supervisée (\textit{clustering}): regrouper les données en \textit{clusters} homogènes, suffisamment distincts deux à deux +% \item nombreux algorithmes depuis Tyron~(1939) (voir Berkhin~2006 pour une revue) +% \item cependant la notion de cluster varie en fonction des données, du contexte et de l'algorithme utilisé +% \item technique très populaire qui permet +% de réduire la taille des données en les résumant à quelques représentants +% \end{itemize} +% \end{frame} + diff --git a/latex/slides/JdS_20140603/pics/3centers.png b/latex/slides/JdS_20140603/pics/3centers.png new file mode 100644 index 0000000..6dde281 Binary files /dev/null and b/latex/slides/JdS_20140603/pics/3centers.png differ diff --git a/latex/slides/JdS_20140603/pics/5centers.png b/latex/slides/JdS_20140603/pics/5centers.png new file mode 100644 index 0000000..f897b5c Binary files /dev/null and b/latex/slides/JdS_20140603/pics/5centers.png differ diff --git a/latex/slides/JdS_20140603/pics/Diagramme1.png b/latex/slides/JdS_20140603/pics/Diagramme1.png new file mode 100644 index 0000000..d0582a3 Binary files /dev/null and b/latex/slides/JdS_20140603/pics/Diagramme1.png differ diff --git a/latex/slides/JdS_20140603/pics/Questions.jpg b/latex/slides/JdS_20140603/pics/Questions.jpg new file mode 100644 index 0000000..5cd0adb Binary files /dev/null and b/latex/slides/JdS_20140603/pics/Questions.jpg differ diff --git a/latex/slides/JdS_20140603/pics/conso-shapes.png b/latex/slides/JdS_20140603/pics/conso-shapes.png new file mode 100644 index 0000000..9f866e3 Binary files /dev/null and b/latex/slides/JdS_20140603/pics/conso-shapes.png differ diff --git a/latex/slides/JdS_20140603/pics/conso-traj.png b/latex/slides/JdS_20140603/pics/conso-traj.png new file mode 100644 index 0000000..146d17e Binary files /dev/null and b/latex/slides/JdS_20140603/pics/conso-traj.png differ diff --git a/latex/slides/JdS_20140603/pics/conso_AC-calendar.png b/latex/slides/JdS_20140603/pics/conso_AC-calendar.png new file mode 100644 index 0000000..f4b0c7d Binary files /dev/null and b/latex/slides/JdS_20140603/pics/conso_AC-calendar.png differ diff --git a/latex/slides/JdS_20140603/pics/conso_AC-curves.png b/latex/slides/JdS_20140603/pics/conso_AC-curves.png new file mode 100644 index 0000000..49a7f7d Binary files /dev/null and b/latex/slides/JdS_20140603/pics/conso_AC-curves.png differ diff --git a/latex/slides/JdS_20140603/pics/conso_jump_AC.png b/latex/slides/JdS_20140603/pics/conso_jump_AC.png new file mode 100644 index 0000000..0ca9c68 Binary files /dev/null and b/latex/slides/JdS_20140603/pics/conso_jump_AC.png differ diff --git a/latex/slides/JdS_20140603/pics/consotemp.png b/latex/slides/JdS_20140603/pics/consotemp.png new file mode 100644 index 0000000..a8337c6 Binary files /dev/null and b/latex/slides/JdS_20140603/pics/consotemp.png differ diff --git a/latex/slides/JdS_20140603/pics/dailyloads.png b/latex/slides/JdS_20140603/pics/dailyloads.png new file mode 100644 index 0000000..03c8c48 Binary files /dev/null and b/latex/slides/JdS_20140603/pics/dailyloads.png differ diff --git a/latex/slides/JdS_20140603/pics/linky.jpg b/latex/slides/JdS_20140603/pics/linky.jpg new file mode 100644 index 0000000..75a4c74 Binary files /dev/null and b/latex/slides/JdS_20140603/pics/linky.jpg differ diff --git a/latex/slides/JdS_20140603/pics/logo_dis.png b/latex/slides/JdS_20140603/pics/logo_dis.png new file mode 100644 index 0000000..4c0ba9b Binary files /dev/null and b/latex/slides/JdS_20140603/pics/logo_dis.png differ diff --git a/latex/slides/JdS_20140603/pics/logo_eric.png b/latex/slides/JdS_20140603/pics/logo_eric.png new file mode 100644 index 0000000..db25a2c Binary files /dev/null and b/latex/slides/JdS_20140603/pics/logo_eric.png differ diff --git a/latex/slides/JdS_20140603/pics/logo_lyon2.jpg b/latex/slides/JdS_20140603/pics/logo_lyon2.jpg new file mode 100644 index 0000000..5f42277 Binary files /dev/null and b/latex/slides/JdS_20140603/pics/logo_lyon2.jpg differ diff --git a/latex/slides/JdS_20140603/pics/longtermload.png b/latex/slides/JdS_20140603/pics/longtermload.png new file mode 100644 index 0000000..03ebf2b Binary files /dev/null and b/latex/slides/JdS_20140603/pics/longtermload.png differ diff --git a/latex/slides/JdS_20140603/pics/open-mpi-logo.png b/latex/slides/JdS_20140603/pics/open-mpi-logo.png new file mode 100644 index 0000000..feb144c Binary files /dev/null and b/latex/slides/JdS_20140603/pics/open-mpi-logo.png differ diff --git a/latex/slides/JdS_20140603/pics/schema.png b/latex/slides/JdS_20140603/pics/schema.png new file mode 100644 index 0000000..122e5c1 Binary files /dev/null and b/latex/slides/JdS_20140603/pics/schema.png differ diff --git a/latex/slides/JdS_20140603/pics/screen_demo.png b/latex/slides/JdS_20140603/pics/screen_demo.png new file mode 100644 index 0000000..59c8451 Binary files /dev/null and b/latex/slides/JdS_20140603/pics/screen_demo.png differ diff --git a/latex/slides/JdS_20140603/pics/slgr1.png b/latex/slides/JdS_20140603/pics/slgr1.png new file mode 100644 index 0000000..0b7d7b9 Binary files /dev/null and b/latex/slides/JdS_20140603/pics/slgr1.png differ diff --git a/latex/slides/JdS_20140603/pics/slgr2.png b/latex/slides/JdS_20140603/pics/slgr2.png new file mode 100644 index 0000000..d21ca70 Binary files /dev/null and b/latex/slides/JdS_20140603/pics/slgr2.png differ diff --git a/latex/slides/JdS_20140603/pics/slgr3.png b/latex/slides/JdS_20140603/pics/slgr3.png new file mode 100644 index 0000000..077ca5e Binary files /dev/null and b/latex/slides/JdS_20140603/pics/slgr3.png differ diff --git a/latex/slides/JdS_20140603/pics/smartgrid.jpg b/latex/slides/JdS_20140603/pics/smartgrid.jpg new file mode 100644 index 0000000..d860569 Binary files /dev/null and b/latex/slides/JdS_20140603/pics/smartgrid.jpg differ diff --git a/latex/slides/JdS_20140603/pics/twoyearsload.png b/latex/slides/JdS_20140603/pics/twoyearsload.png new file mode 100644 index 0000000..ef0ee95 Binary files /dev/null and b/latex/slides/JdS_20140603/pics/twoyearsload.png differ diff --git a/latex/slides/JdS_20140603/pics/weekly-5.png b/latex/slides/JdS_20140603/pics/weekly-5.png new file mode 100644 index 0000000..0251c81 Binary files /dev/null and b/latex/slides/JdS_20140603/pics/weekly-5.png differ diff --git a/latex/slides/JdS_20140603/slides.tex b/latex/slides/JdS_20140603/slides.tex new file mode 100644 index 0000000..309dd23 --- /dev/null +++ b/latex/slides/JdS_20140603/slides.tex @@ -0,0 +1,534 @@ +\input{startdoc.tex} + +\usepackage{tikz} +\usepackage{array} + +\usepackage[utf8]{inputenc} +\usepackage{amsmath, amsfonts} +%\usepackage[francais]{babel} +\usepackage{hyperref, url, caption, tikz} +\usepackage{xwrapfig} +%\usepackage{graphicx} +%\hypersetup{colorlinks,linkcolor=black,urlcolor=violet} + +\mode{ + \setbeamertemplate{sections/subsections in toc}[square] + \beamertemplatenavigationsymbolsempty +} + +%\newcommand{\N}{\mathbb{N}} % naturals +\newcommand{\set}[1]{\lbrace#1\rbrace} % set +%\newcommand{\R}{\mathbb{R}} % real + +\colorlet{darkred}{red!80!black} +\colorlet{darkblue}{blue!80!black} +\colorlet{darkgreen}{green!60!black} + +\usetikzlibrary{calc,decorations.pathmorphing,patterns} +\pgfdeclaredecoration{penciline}{initial}{ + \state{initial}[width=+\pgfdecoratedinputsegmentremainingdistance, + auto corner on length=1mm,]{ + \pgfpathcurveto% + {% From + \pgfqpoint{\pgfdecoratedinputsegmentremainingdistance} + {\pgfdecorationsegmentamplitude} + } + {% Control 1 + \pgfmathrand + \pgfpointadd{\pgfqpoint{\pgfdecoratedinputsegmentremainingdistance}{0pt}} + {\pgfqpoint{-\pgfdecorationsegmentaspect + \pgfdecoratedinputsegmentremainingdistance}% + {\pgfmathresult\pgfdecorationsegmentamplitude} + } + } + {%TO + \pgfpointadd{\pgfpointdecoratedinputsegmentlast}{\pgfpoint{1pt}{1pt}} + } + } + \state{final}{} +} +% +\tikzstyle{block} = [draw,rectangle,thick,minimum height=2em,minimum width=2em] + +%~ \usetikzlibrary{calc,decorations.pathmorphing,patterns} +%~ \pgfdeclaredecoration{penciline}{initial}{ + %~ \state{initial}[width=+\pgfdecoratedinputsegmentremainingdistance, + %~ auto corner on length=1mm,]{ + %~ \pgfpathcurveto% + %~ {% From + %~ \pgfqpoint{\pgfdecoratedinputsegmentremainingdistance} + %~ {\pgfdecorationsegmentamplitude} + %~ } + %~ {% Control 1 + %~ \pgfmathrand + %~ \pgfpointadd{\pgfqpoint{\pgfdecoratedinputsegmentremainingdistance}{0pt}} + %~ {\pgfqpoint{-\pgfdecorationsegmentaspect + %~ \pgfdecoratedinputsegmentremainingdistance}% + %~ {\pgfmathresult\pgfdecorationsegmentamplitude} + %~ } + %~ } + %~ {%TO + %~ \pgfpointadd{\pgfpointdecoratedinputsegmentlast}{\pgfpoint{1pt}{1pt}} + %~ } + %~ } + %~ \state{final}{} +%~ } +%~ % +%~ \tikzstyle{block} = [draw,rectangle,thick,minimum height=2em,minimum width=2em] +%~ \colorlet{darkred}{red!80!black} +%~ \colorlet{darkblue}{blue!80!black} +%~ \colorlet{darkgreen}{green!60!black} + +%\newcommand*\mystrut[1]{\vrule width0pt height0pt depth#1\relax} +%http://tex.stackexchange.com/questions/13843/vertical-spacing-with-underbrace-command + +\title[Clustering de courbes de charge EDF] +{Clustering de courbes de charge EDF%\\ +%Application à la prévision de la qualité de l'air +\vspace*{0.5cm}} +\author[Benjamin Auder, Jairo Cugliari] +{Benjamin Auder \inst{1}\\[0.2cm]Jairo Cugliari \inst{2}\hspace*{0.6cm}\vspace*{1cm}} +\date[]{} +\institute[]{\inst{1} CNRS Orsay / Université Paris-Sud\hspace*{1.3cm} \and +\inst{2} Laboratoire ERIC / Université Lumière Lyon 2} +%~ \titlegraphic{ + %~ \includegraphics[width=2cm]{logo_eric.png}\hspace*{4.75cm}~% + %~ \includegraphics[width=2cm]{logo_lyon2.jpg} +%~ } + +\begin{document} + +\begin{frame} +\vspace*{0.5cm} +\titlepage +\end{frame} + +\begin{frame}{Contexte industriel} + +\begin{columns} + +\column{0.5\textwidth} +Smartgrid \& Smart meters : 35M compteurs individuels donnant de l'information en temps réel.\\[0.7cm] +$\Rightarrow$ \textbf{Beaucoup} de données.\\[1cm] +%\textcolor{white}{$\Rightarrow$} problèmes informatiques : protocoles de transfert, sécurité, \dots +Comment les traiter ? + +\column{0.5\textwidth} +\includegraphics[width = \textwidth]{smartgrid.jpg}\\ +\includegraphics[width = \textwidth]{linky.jpg} + +\end{columns} + +\end{frame} + +\begin{frame}{Des données variées, à différentes échelles} + +\begin{figure}[!ht] \centering + \begin{minipage}[c]{0.48\textwidth} + \includegraphics[width=\textwidth,height=3.45cm]{longtermload.png} + \vspace*{-0.35cm} +% \vspace*{-0.85cm} + \caption{Tendance à long terme} %\label{fig:gull} + \end{minipage}% + ~ %spacing between images + \begin{minipage}[c]{0.48\textwidth} + \includegraphics[width=\textwidth,height=3.45cm]{twoyearsload.png} + \vspace*{-0.35cm} +% \vspace*{-0.85cm} + \caption{Cyclicité semaine} % \label{fig:tiger} + \end{minipage} + ~\\[-0.05cm] + \begin{minipage}[c]{0.48\textwidth} + \includegraphics[width=\textwidth,height=3.45cm]{dailyloads.png} + \vspace*{-0.35cm} +% \vspace*{-0.85cm} + \caption{Moyenne journalière} % \label{fig:mouse} + \end{minipage} + ~ %spacing between images + \begin{minipage}[c]{0.48\textwidth} + \includegraphics[width=\textwidth,height=3.45cm]{consotemp.png} + \vspace*{-0.35cm} +% \vspace*{-0.85cm} + \caption{Conso. vs. température} + \end{minipage} +\end{figure} + +\end{frame} + +\begin{frame}{Découpage en tranches non stationnaires} + +Si $\exists \delta \ll D$, tel que les séries $\delta-$agrégées soient stationnaires,\\ +on les agrège et les traite comme des processus stationnaires.\\[0.3cm] + +\begin{columns} + \column{6cm} + \input{tikz/axis2} + ~ + \column{5cm} + \vspace*{-1cm} + \[ Z_k(t) = X(t + (k-1)\delta) \] + \[ k\in\N \;\;\; \forall t \in [0,\delta) \] +\end{columns} + +\textbf{\emph{Mais...}} +Une série temporelle représentant un phénomène complexe +\textcolor{white}{\textbf{\emph{Mais...}} }est en général clairement non stationnaire.\\[0.5cm] + +$\Rightarrow$ On décide de tenir compte de chaque point de discrétisation. + +%Par exemple, la consommation électrique moyenne sur une semaine varie + +%~ \vfill + %~ If $X$ contents a $\delta-$seasonal component, + %~ $Z$ is particularly fruitful. + +%~ C'est pas vraiment notre cas : saisonnier à plusieurs echelles +%~ ==> objectif : tout prendre en compte + +\end{frame} + +\begin{frame}{Réduction de dimension} + +Données enregistrées toutes les 30 minutes pendant un an :\\ +$48 \times 365 =$ \textbf{17520 points de discrétisation}.\\[0.3cm] + +\vspace*{-0.4cm} +\begin{figure}[!ht] +\centering +\includegraphics[width=\textwidth,height=5.5cm]{3centers.png} +\vspace*{-0.35cm} +%\vspace*{-0.95cm} +\caption{Trois types de courbes de charge \emph{(données irlandaises)}}% présentant différents régimes}%{[Spoiler] Cinq centres de clusters} +\end{figure} + +\vspace*{-0.3cm} +$\Rightarrow$ Il faut déterminer une représentation parcimonieuse, capturant\\ +\textcolor{white}{$\Rightarrow$ }bien les variations localisées. On choisit une base d'ondelettes.\\[0.5cm] +%TODO: placer l'equation puis sa version discrète. + +\end{frame} + +\begin{frame}{Wavelets to cope with \textsc{fd}} + +\begin{columns} + \column{.6\textwidth} + %\begin{figure} + \centering + \includegraphics[width = \textwidth]{./pics/weekly-5.png} + % * * * * * * * * * * * * * * * * * * * + \column{.4\textwidth} +\begin{footnotesize} +\begin{itemize} + \item domain-transform technique for hierarchical decomposing finite energy signals + \item description in terms of a broad trend (\textcolor{PineGreen}{approximation part}), plus a set of localized changes kept in the \textcolor{red}{details parts}. +\end{itemize} +\end{footnotesize} +\end{columns} + +\vspace*{-0.1cm} +\begin{block}{Discrete Wavelet Transform } +\begin{footnotesize} + If $z \in L_2([0, 1])$ we can write it as + \vspace*{-0.4cm} + \begin{equation*}\label{eq:zeta} + z(t) = \sum_{k=0}^{2^{j_0}-1} \textcolor{PineGreen}{c_{j_0, k}} \phi_{j_0,k} (t) + + \sum_{j={j_0}}^{\infty} + \sum_{k=0}^{2^j-1} \textcolor{red}{d_{j,k}} \psi_{j,k} (t) , + \end{equation*} +% +~\\[-0.6cm] +where $ c_{j,k} = $, $ d_{j,k} = $ are the +\textcolor{PineGreen}{scale coefficients} and \textcolor{red}{wavelet coefficients} respectively, and the functions $\phi$ et $\varphi$ are associated to a orthogonal \textsc{mra} of $L_2([0, 1])$. +\end{footnotesize} +\end{block} +\end{frame} + +%---------------------------------------- SLIDE --------------------- + +\begin{frame}{Energy decomposition of the DWT} + +\begin{block}{ } + \begin{itemize} + \item Energy conservation of the signal +\vspace*{-0.15cm} + \begin{equation*}\label{eq:energy} + \| z \|_H^2 \approx \| \widetilde{z_J} \|_2^2 + = c_{0,0}^2 + \sum_{j=0}^{J-1} \sum_{k=0}^{2^j-1} d_{j,k} ^2 = + c_{0,0}^2 + \sum_{j=0}^{J-1} \| \mathbf{d}_{j} \|_2^2. + \end{equation*} +% \item characterization by the set of channel variances estimated at the output of the corresponding filter bank + \item For each $j=0,1,\ldots,J-1$, we compute the absolute and + relative contribution representations by +\vspace*{-0.15cm} + \[ \underbrace{\hbox{cont}_j = ||\mathbf{d_j}||^2}_{\fbox{AC}} + \qquad \text{and} \qquad + \underbrace{\hbox{rel}_j = + \frac{||\mathbf{d_j}||^2} + {\sum_j ||\mathbf{d_j}||^2 }}_{\fbox{RC}} .\] + \item They quantify the relative importance of the scales to the global dynamic. +% \item Only the wavelet coefficients $\set{d_{j,k}}$ are used. + \item RC normalizes the energy of each signal to 1. +\end{itemize} +\end{block} +\end{frame} + +%=========================================================================================== +% fin de l'intro... +%=========================================================================================== + +\begin{frame}{Objectif} + +\begin{figure}[!ht]\centering + \includegraphics[width = \textwidth]{pics/schema.png} +%\caption{Hierarchical structure of $N$ individual clients among $K$ groups.}\label{fig:schema-hier} +\end{figure} + +Regroupement par tarifs, zones géographiques, types de clients \dots\\[0.3cm] + +$\Rightarrow$ \textbf{Idée} : clustering pour déterminer ces groupes.\\[0.3cm] + +\textcolor{white}{$\Rightarrow$ }\textbf{Méthode} : paralléliser un algorithme classique. + +%~ functional clustering +%~ wavelets to reduce dimension +%~ open MPI to cluster a bounded number of vectors at a time + +\end{frame} + +\begin{frame}{Fonction objectif} + +On cherche à minimiser la distorsion +$$\Delta = \sum_{i=1}^{n} \min_{k=1..K} \| x_i - c_k \|_2^{}$$ +avec pour variables les $\{c_1,\dots,c_K\} \subset \{x_1,\dots,x_n\}, c_i \neq c_j \, \forall i \neq j$.\\[0.3cm] + +C'est un problème NP-dur {\footnotesize (O. Kariv \& S. L. Hakimi, \emph{An Algorithmic Approach to Network Location Problems. II: The p-Medians})}.\\[0.1cm] +%SIAM J. Appl. Math., 37(3), 539–560. (22 pages) +%~ C'est-à-dire : +%~ \begin{itemize} +%~ \item Soit $P$ le problème de décision associé : $P(c_1,\dots,c_k) = 1$ si $(c_1,\dots,c_k)$ est optimal, 0 sinon. +%~ \item Soit $C$ un problème de décision bien connu comme étant NP-complet +%~ \item Il existe un algorithme ... +%~ \end{itemize} + +Pire : garantir un facteur $(1+\varepsilon)$ de l'optimum est NP-dur +{\footnotesize (J-H. Lin \& J. S. Vitter $\varepsilon$-Approximations with Minimum Packing Constraint Violation)}.\\[0.2cm]%(Extended Abstract) + +\begin{block}{NP : ``Non-deterministic Polynomial-time algorithms''} +{\footnotesize Exécution en temps polynomial sur une machine de Turing non déterministe.} +\end{block} + +\begin{block}{NP-dur} +``Au moins aussi dur que le plus complexe des problèmes NP'' +\end{block} + +%~ Tous les algorithmes existants déterminant les $c_k$ sont donc des heuristiques d'approximation +%~ ...et parler de la parallélisation ??! donc 16 slides au total. +%NP-complet : c'est à dire... expliquer. +%Algos existants = heuristiques pr s'approcher de l'optimum (d'un...) + +\end{frame} + +\begin{frame}{Algorithme PAM} + +%PAM : montrer algo, dire comment on parallélise naïvement + +\begin{enumerate} +\setcounter{enumi}{-1} +\item Initialize: randomly select (without replacement) $K$ of the $n$ data points as the medoids. +\item Associate each data point to the closest medoid. (``closest'' here is defined using any valid distance metric, most commonly Euclidean distance, Manhattan distance or Minkowski distance). +\item For each medoid $m$\\ +\quad For each non-medoid data point $o$ \emph{in the same cluster}\\ +\quad\quad Swap $m$ and $o$ and compute the total cost. +\item Select the configuration with the lowest cost.\\ +If any change occurred in the medoids, go to step 1. +\end{enumerate} + +\begin{block}{Réduire le coût des étapes 2 et 3 ?} +\begin{itemize} +\item Dans R, pam(do.swap=FALSE) supprime les étapes 2 et 3. +\item A. P. Reynolds et al. (2006) : quelques astuces algorithmiques. +\end{itemize} +\end{block} + +\end{frame} + +\begin{frame}{Parallélisation} + +\begin{block}{Deux approches (entre autres)} +\begin{itemize} +\item Découpage de l'espace en $Z < K$ zones, et recherche de $K/Z$ clusters dans chaque zone. +\item Partition des données $P_1,\dots,P_Z$ puis clustering à $K$ groupes dans chaque $P_k$. +(Puis ``fusion'' des médoïdes). +\end{itemize} +\end{block} + +~\\[-0.1cm] +{\footnotesize +Choix de la seconde alternative et implémentation avec OpenMPI : +\begin{enumerate} +\setcounter{enumi}{-1} +\item Le processus ``maître'' a pour numéro 0. Il divise les données en sous-ensembles de cardinal au plus +$C$ ($C = 5000$ par exemple). Il envoie ensuite une tâche de clustering par sous-ensemble, et attend les résultats. +\item Chaque processus ``esclave'' (numérotés de 1 à $p-1$) reçoit une liste de (références de) courbes, qu'il récupère +et classe via l'algorithme PAM. Il retourne les centres au processus 0. +\item Si on obtient plus de $C$ médoïdes, on recommence depuis l'étape 1. Sinon, on applique une dernière +fois l'algorithme PAM (sur les médoïdes). +\end{enumerate} +} + +\end{frame} + +\begin{frame}{Exécution du programme} + +\vspace*{-0.5cm} +\begin{figure} +\includegraphics[width=\linewidth,height=8cm]{pics/screen_demo.png} + %~ \vspace*{-0.35cm} + %~ \caption{Groupe 1} +\end{figure} + +\end{frame} + +\begin{frame}{Application I: Electricity Smart Meter CBT} + +%\footnotetext[1]{\textit{Irish Social Science Data Archive}, } + +\begin{itemize} + \item 4621 Irish households smart meter data + (\href{http://www.ucd.ie/issda/data/}{ISSDA}) + % eséries de consommation électrique de foyers irlandais + \item About 25K discretization points + \item We test with $K=$ 3 or 5 classes + \item We compare sequential and parallel versions +\end{itemize} + +\begin{table}[H] +\centering +\begin{tabular}{lcc} \hline +% & & \\ + & Distortion & (Internal) adequacy \\ \hline +3 clusters sequential & 1.90e7 & 0.90 \\ +3 clusters parallel & 2.15e7 & 0.90 \\ +5 clusters sequential & 1.61e7 & 0.89 \\ +5 clusters parallel & 1.84e7 & 0.89 \\ \hline +\end{tabular} +% \caption{Distorsions et indices d'adéquation des partitions} +\end{table} + +\textbf{Adequacy :} given $P_1 = (i_1,\dots,i_n)$ and $P_2 = (j_1,\dots,j_n)$,\\ +\textcolor{white}{\textbf{Adequacy :}} find a matching which maximize $S = \sum_{k=1}^{n} \mathbb{1}_{i_k = j_k}$\\ +\textcolor{white}{\textbf{Adequacy :}} (hungarian algorithm), and then return $S/n$. + +\end{frame} + +\begin{frame}{Application II: Starlight curves} + +\begin{itemize} + \item Data from \href{http://www.cs.ucr.edu/~eamonn/time_series_data/}{UCR Time Series Classification/Clustering} + %\url{http://www.cs.ucr.edu/~eamonn/time_series_data/}} + \item 1000 curves learning set + 8236 validation set ($d = 1024$)% discretization points +\end{itemize} + +\begin{figure}[H] +\begin{minipage}[c]{.32\linewidth} + \includegraphics[width=\linewidth,height=3.5cm]{pics/slgr1.png} + \vspace*{-0.35cm} + \caption{Groupe 1} +\end{minipage} +\begin{minipage}[c]{.32\linewidth} + \includegraphics[width=\linewidth,height=3.5cm]{pics/slgr2.png} + \vspace*{-0.35cm} + \caption{Groupe 2} +\end{minipage} +\begin{minipage}[c]{.32\linewidth} + \includegraphics[width=\linewidth,height=3.5cm]{pics/slgr3.png} + \vspace*{-0.35cm} + \caption{Groupe 3} +\end{minipage} +\end{figure} + +\begin{footnotesize} +\vspace*{-0.3cm} +\begin{table}[H] +\centering +\begin{tabular}{lccc} \hline + & & \multicolumn{2}{c}{Adequacy} \\ + & Distortion & Internal & External \\ \hline +Training (sequential) & 1.31e4 & 0.79 & 0.77 \\ +Training (parallel) & 1.40e4 & 0.79 & 0.68 \\ +Test (sequential) & 1.09e5 & 0.78 & 0.76 \\ +Test (parallel) & 1.15e5 & 0.78 & 0.69 \\ \hline +\end{tabular} +%\caption{Distorsions et indices d'adéquation des partitions} +\end{table} +\end{footnotesize} + +\end{frame} + +\begin{frame}{Conclusion} + +%~ On peut clusteriser +%~ Faudrait etre moins naif +%~ Faudrait aussi étendre/généraliser le code... + +\begin{block}{Résumé} +\begin{itemize} +\itemsep0.1em +\item Les smartmètres mesurent la charge électrique pour chaque client, en temps réel $\Rightarrow$ données fonctionnelles. +\item Les ondelettes fournissent des représentations parcimonieuses tout en préservant la nature fonctionnelle des données. +\item L'analyse de ces représentations à l'aide de l'algorithme PAM permet d'identifier des groupes de clients. +\item L'algorithme PAM est appliqué en parallèle sur des jeux de données de tailles raisonnables. +\end{itemize} +\end{block} + +% \item \textit{Divide-and-Conquer} approach thanks to MPI library %pour l'algorithme des $k$-médoïdes : d'abord sur des groupes de données courbes, puis des groupes de médoïdes jusqu'à obtenir un seul ensemble traité sur un processseur. + %\item %Les résultats obtenus sur les deux jeux de données présentés sont assez encourageants, et permettent d'envisager une utilisation à plus grande échelle. +%\end{itemize} + +\begin{exampleblock}{Perspectives} +\begin{itemize} +\itemsep0.1em +\item L'étude des groupes de clients peut donner lieu à l'élaboration de $K$ modèles prédictifs spécialisés. +\item La méthode de clustering parallèle proposée peut être adaptée pour traiter les 35M séries (sur un supercalculateur ?). +%\item Apply the algorithm over many hundreds of processors +\end{itemize} +\end{exampleblock} + +\end{frame} + +\begin{frame}{Références} + +\begin{thebibliography}{4} +\bibitem{1} \textcolor{black}{A. Antoniadis, X. Brossat, J. Cugliari, J.-M. Poggi} (2013), Clustering Functional Data Using Wavelets, \textcolor{black}{{\it Wavelets, Multiresolution and Information Processing}, 11(1), 35--64} + +\bibitem{2} \textcolor{black}{A. Arbelaez, L. Quesada} (2013), Parallelising the k-Medoids Clustering Problem Using Space-Partitioning, \textcolor{black}{{\it Symposium on Combinatorial Search}, AAAI Publications} + +\bibitem{3} \textcolor{black}{R. Bekkerman, M. Bilenko, J. Langford - éditeurs} (2011), +Scaling up Machine Learning: Parallel and Distributed Approaches, \textcolor{black}{Cambridge University Press} + +\bibitem{4} \textcolor{black}{A. P. Reynolds, G. Richards, B. de la Iglesia, V. J. Rayward-Smith} (2006), Clustering Rules: A Comparison of Partitioning and Hierarchical Clustering Algorithms, \textcolor{black}{{\it Mathematical Modelling and Algorithms}, 5(4), 475--504} + +%\bibitem{3} P. Berkhin (2006), A Survey of Clustering Data Mining Techniques, {\it Grouping Multidimensional Data, éditeurs : J. Kogan, C. Nicholas, M. Teboulle}. + +%\bibitem{6} J. Dean et S. Ghemawat (2004), MapReduce: Simplified Data Processing on Large Clusters, {\it Sixth Symposium on Operating System Design and Implementation}. + +%\bibitem{7} G. De Francisci Morales et A. Bifet (2013), G. De Francisci Morales SAMOA: A Platform for Mining Big Data Streams Keynote Talk at RAMSS ’13: 2nd International Workshop on Real-Time Analysis and Mining of Social Streams WWW, Rio De Janeiro + +%\bibitem{10} L. Kaufman et P.J. Rousseeuw (1987), Clustering by means of Medoids, {\it Statistical Data Analysis Based on the L\_1-Norm and Related Methods, éditeur : Y. Dodge}. +\end{thebibliography} + +%[2013] A. Antoniadis, X. Brossat, J. Cugliari & J.-M. Poggi. Clustering functional data using Wavelets Inter. J. of Wavelets, Multiresolution and Information Procesing. doi:10.1142/S0219691313500033 + +%~ Scaling up Machine Learning: Parallel and Distributed Approaches [Anglais] [Relié] +%~ Ron Bekkerman (Sous la direction de), Mikhail Bilenko (Sous la direction de), John Langford + +\end{frame} + +\begin{frame} + +\centering +\includegraphics[width=7cm,height=7cm]{Questions.jpg} + +\end{frame} + +\end{document} diff --git a/latex/slides/JdS_20140603/startdoc.tex b/latex/slides/JdS_20140603/startdoc.tex new file mode 100644 index 0000000..4d3facc --- /dev/null +++ b/latex/slides/JdS_20140603/startdoc.tex @@ -0,0 +1,133 @@ +\documentclass[xcolor=dvipsnames,pdftex,12pt]{beamer} + +\usepackage{hyperref} +\usepackage{colortbl} +\usepackage[french]{babel} +\usepackage[utf8]{inputenc} +\usepackage{amsmath,amsfonts,amssymb} +\usepackage{bbold,dsfont} +\usepackage{theorem} +\usepackage{wrapfig} +\usepackage{graphics} +\usepackage{xcolor} +%\usepackage{times} +\usepackage{bm} +\usepackage{stmaryrd} +\usepackage{dashundergaps} + +\graphicspath{ {./pics/} } + +\definecolor{vert}{RGB}{0,139,0} +\definecolor{violet}{RGB}{74,0,255}%{102,0,204} +\definecolor{gris}{RGB}{100,100,100} +\definecolor{ebgreen}{RGB}{230,243,230} +\newcommand{\blue}{\textcolor{blue}} +\newcommand{\red}{\textcolor{red}} +\newcommand{\green}{\textcolor{vert}} +\newcommand{\violet}{\textcolor{violet}} + +\hypersetup{ + colorlinks, + linkcolor=black, + urlcolor=violet, +% hrefcolor=violet +} + +\usepackage{listings} + +%\usepackage{minted} +% \begin{minted}{c} +% int main() { +% printf("hello, world"); +% return 0; +% } +% \end{minted} + +\usepackage{textcomp} +%\usepackage{bera} +\definecolor{listinggray}{gray}{0.9} +\definecolor{lbcolor}{rgb}{0.9,0.9,0.9} +\lstset{ + backgroundcolor=\color{lbcolor}, + tabsize=4, + rulecolor=, + language=SQL, + basicstyle=\scriptsize, + upquote=true, + %aboveskip={1.5\baselineskip}, + columns=fixed, + showstringspaces=false, + extendedchars=true, + breaklines=true, + prebreak = \raisebox{0ex}[0ex][0ex]{\ensuremath{\hookleftarrow}}, + frame=single, + showtabs=false, + showspaces=false, + showstringspaces=false, + identifierstyle=\ttfamily, + keywordstyle=\color[rgb]{0,0,1}, + commentstyle=\color[rgb]{0.133,0.545,0.133}, + stringstyle=\color[rgb]{0.627,0.126,0.941}, + escapeinside="" +} + +\newcommand{\cC}{{\cal C}} +\newcommand{\cF}{{\cal F}} +\newcommand{\cH}{{\cal H}} +\newcommand{\cM}{{\cal M}} +\newcommand{\cO}{{\cal O}} +\newcommand{\cP}{{\cal P}} +\newcommand{\cU}{{\cal U}} +\newcommand{\cV}{{\cal V}} +\newcommand{\cS}{{\cal S}} +\newcommand{\cX}{{\cal X}} +\newcommand{\cY}{{\cal Y}} +\newcommand{\cZ}{{\cal Z}} + +\newcommand{\N}{\mathbb{N}} +\newcommand{\R}{\mathbb{R}} +\newcommand{\C}{\mathbb{C}} +\newcommand{\E}{\mathbb{E}} +\newcommand{\M}{\mathbb{M}} +\newcommand{\Z}{\mathbb{Z}} +\newcommand{\Prob}{\mathbb{P}} +\newcommand{\esp}{\thinspace} +\newcommand{\1}{\mathbb{1}} +\newcommand{\puiss}{e\thinspace \mbox{\small -}} +\newcommand{\tr}{{}^t \negthinspace} + +\usetheme{Boadilla}%{Frankfurt}{Madrid} +\setbeamertemplate{navigation symbols}{} + +%~ \setbeamercolor{section in head/foot}{fg=white, bg=black} +%~ +%~ \makeatletter +%~ \setbeamertemplate{footline} +%~ { + %~ \leavevmode% + %~ \hbox{% + %~ \begin{beamercolorbox}[wd=.333333\paperwidth,ht=2.25ex,dp=1ex,center]{section in head/foot}% + %~ \usebeamerfont{author in head/foot}\insertshortauthor~~\beamer@ifempty{\insertshortinstitute}{}{(\insertshortinstitute)} + %~ \end{beamercolorbox}% + %~ \begin{beamercolorbox}[wd=.333333\paperwidth,ht=2.25ex,dp=1ex,center]{section in head/foot}% + %~ \usebeamerfont{title in head/foot}\insertshorttitle + %~ \end{beamercolorbox}% + %~ \begin{beamercolorbox}[wd=.333333\paperwidth,ht=2.25ex,dp=1ex,right]{section in head/foot}% + %~ \usebeamerfont{date in head/foot}\insertshortdate{}\hspace*{2em} + %~ \insertframenumber{} / \inserttotalframenumber\hspace*{2ex} + %~ \end{beamercolorbox}}% + %~ \vskip0pt% +%~ } +%~ \makeatother + +\AtBeginSection[]{ +\begin{frame} + \tableofcontents[currentsection] +\end{frame} +} + +\AtBeginSubsection[]{ +\begin{frame} + \tableofcontents[currentsubsection] +\end{frame} +} diff --git a/latex/slides/JdS_20140603/tikz/axis.tex b/latex/slides/JdS_20140603/tikz/axis.tex new file mode 100644 index 0000000..6169985 --- /dev/null +++ b/latex/slides/JdS_20140603/tikz/axis.tex @@ -0,0 +1,25 @@ + \begin{tikzpicture}[scale=0.5] + + % Axis + \draw[<->, thick] (0,4) node (yaxis) [left] {$X_t$} + |- (11,0) node (xaxis) [right] {$t$} ; + % Dashed grid + % \foreach \t in {1, 2, 3, 4, 5, 6} + \draw[dashed, color=PineGreen] (1.5*6 cm, 4) -- (1.5*6 cm, -3pt) + node[anchor=north] {$T $}; + + \draw[dashed, color=PineGreen] (1.5*7,4) -- (1.5*7,-3pt) + node[below] {$T+\delta$}; + + \draw[color=Gray] plot[only marks, mark = *] file {tikz/data0.dat}; + \draw[color=PineGreen] plot[smooth] file {tikz/data.dat}; + + \draw (0,0) -- (0,-3pt) node[below, color= PineGreen] {0}; + + % \foreach \t in {1, 2, 5} + % \draw[color=PineGreen] (-0.75+1.5*\t, 1.5) node[below, scale=0.75] {$Z_\t(t)$}; + + % \foreach \t in {3, 4, 6} + % \draw[color=PineGreen] (-0.75+1.5*\t, 3.5) node[below, scale=0.75] {$Z_\t(t)$}; + + \end{tikzpicture} diff --git a/latex/slides/JdS_20140603/tikz/axis0.tex b/latex/slides/JdS_20140603/tikz/axis0.tex new file mode 100644 index 0000000..51c030d --- /dev/null +++ b/latex/slides/JdS_20140603/tikz/axis0.tex @@ -0,0 +1,18 @@ + \begin{tikzpicture}[scale=0.5, domain = 0:4] + + % Axis + \draw[<->, thick] (0,4) node (yaxis) [left] {$X_t$} + |- (11,0) node (xaxis) [right] {$t$} ; + + \draw[dashed, color=PineGreen] (1.5*6 cm, 4) -- (1.5*6 cm, -3pt) + node[anchor=north] {$T $}; + + \draw[dashed, color=PineGreen] (1.5*7,4) -- (1.5*7,-3pt) + node[below] {$T+\delta$}; + + \draw[color=PineGreen] plot[only marks, mark = *] file {tikz/data0.dat}; + + \draw (0,0) -- (0,-3pt) node[below, color= PineGreen] {0}; + + + \end{tikzpicture} diff --git a/latex/slides/JdS_20140603/tikz/axis2.tex b/latex/slides/JdS_20140603/tikz/axis2.tex new file mode 100644 index 0000000..5a775b8 --- /dev/null +++ b/latex/slides/JdS_20140603/tikz/axis2.tex @@ -0,0 +1,23 @@ + \begin{tikzpicture}[scale=0.5] + + % Axis + \draw[<->, thick] (0,4) node (yaxis) [left] {$X_t$} + |- (11,0) node (xaxis) [right] {$t$} ; + % Dashed grid + \foreach \t in {1, 2, 3, 4, 5, 6} + \draw[dashed, color=PineGreen] (1.5*\t cm, 4) -- (1.5*\t cm, -3pt) + node[anchor=north] {$\t \delta$}; + + \draw[color=PineGreen] plot[smooth] file {tikz/data.dat}; + + \draw (0,0) -- (0,-3pt) node[below, color= PineGreen] {0}; + \draw[dashed, color=PineGreen] (1.5*7,4) -- (1.5*7,-3pt) + node[below] {};%$T+\delta$ + + \foreach \t in {1, 2, 5} + \draw[color=PineGreen] (-0.75+1.5*\t, 1.5) node[below, scale=0.75] {$Z_\t(t)$}; + + \foreach \t in {3, 4, 6} + \draw[color=PineGreen] (-0.75+1.5*\t, 3.5) node[below, scale=0.75] {$Z_\t(t)$}; + + \end{tikzpicture} diff --git a/latex/slides/JdS_20140603/tikz/data.dat b/latex/slides/JdS_20140603/tikz/data.dat new file mode 100644 index 0000000..c29e614 --- /dev/null +++ b/latex/slides/JdS_20140603/tikz/data.dat @@ -0,0 +1,100 @@ +0 2 +0.090909090909091 2.39572396673197 +0.181818181818182 2.76713758488136 +0.272727272727273 3.09179896756969 +0.363636363636364 3.35085309659774 +0.454545454545455 3.53046225933653 +0.545454545454545 3.6228338956898 +0.636363636363636 3.62676380011348 +0.727272727272727 3.54765182027653 +0.818181818181818 3.39698984770719 +0.90909090909091 3.19136455219595 +1 2.95105651629515 +1.09090909090909 2.69835000425096 +1.18181818181818 2.45569091340709 +1.27272727272727 2.24384261847393 +1.36363636363636 2.08018944652641 +1.45454545454545 1.97732541282102 +1.54545454545455 1.94204258733052 +1.63636363636364 1.97480093564330 +1.72727272727273 2.06972232260852 +1.81818181818182 2.21510875689866 +1.90909090909091 2.39444234343259 +2 2.58778525229247 +2.09090909090909 2.77346548148703 +2.18181818181818 2.92991092377299 +2.27272727272727 3.03748213119569 +2.36363636363636 3.08015418798714 +2.45454545454545 3.0469102527437 +2.54545454545455 2.93273263101816 +2.63636363636364 2.73910980272190 +2.72727272727273 2.47401701751283 +2.81818181818182 2.15137071113821 +2.90909090909091 1.78999963219583 +3 1.41221474770753 +3.09090909090909 1.04209254288455 +3.18181818181818 0.703609608190143 +3.27272727272727 0.418778528682967 +3.36363636363636 0.205935073647667 +3.45454545454545 0.0783145289076148 +3.54545454545455 0.0430317034171102 +3.63636363636364 0.100546562764549 +3.72727272727273 0.244658232817553 +3.81818181818182 0.463027451681711 +3.90909090909091 0.738184882066176 +4 1.04894348370485 +4.09090909090909 1.37210056148691 +4.18181818181818 1.68429178720401 +4.27272727272727 1.96384732843198 +4.36363636363636 2.19250019059555 +4.45454545454546 2.35680898807206 +4.54545454545455 2.44918062442534 +4.63636363636364 2.46841089411130 +4.72727272727273 2.41970018113883 +4.81818181818182 2.31414405002983 +4.90909090909091 2.16774114695089 +5 2 +5.09090909090909 1.83225885304911 +5.18181818181818 1.68585594997017 +5.27272727272727 1.58029981886117 +5.36363636363636 1.53158910588870 +5.45454545454546 1.55081937557466 +5.54545454545455 1.64319101192794 +5.63636363636364 1.80749980940444 +5.72727272727273 2.03615267156802 +5.81818181818182 2.31570821279599 +5.90909090909091 2.62789943851309 +6 2.95105651629515 +6.09090909090909 3.26181511793382 +6.18181818181818 3.53697254831829 +6.27272727272727 3.75534176718245 +6.36363636363636 3.89945343723545 +6.45454545454546 3.95696829658289 +6.54545454545455 3.92168547109238 +6.63636363636364 3.79406492635233 +6.72727272727273 3.58122147131703 +6.81818181818182 3.29639039180986 +6.90909090909091 2.95790745711545 +7 2.58778525229247 +7.09090909090909 2.21000036780418 +7.18181818181818 1.84862928886180 +7.27272727272727 1.52598298248717 +7.36363636363636 1.26089019727810 +7.45454545454546 1.06726736898184 +7.54545454545455 0.9530897472563 +7.63636363636364 0.919845812012857 +7.72727272727273 0.962517868804312 +7.81818181818182 1.07008907622701 +7.90909090909091 1.22653451851297 +8 1.41221474770753 +8.0909090909091 1.60555765656741 +8.18181818181818 1.78489124310134 +8.27272727272727 1.93027767739148 +8.36363636363636 2.02519906435670 +8.45454545454546 2.05795741266948 +8.54545454545454 2.02267458717898 +8.63636363636364 1.91981055347359 +8.72727272727273 1.75615738152607 +8.81818181818182 1.54430908659291 +8.90909090909091 1.30164999574904 +9 1.04894348370485 diff --git a/latex/slides/JdS_20140603/tikz/data0.dat b/latex/slides/JdS_20140603/tikz/data0.dat new file mode 100644 index 0000000..882c988 --- /dev/null +++ b/latex/slides/JdS_20140603/tikz/data0.dat @@ -0,0 +1,21 @@ +0 1.67273350755174 +0.45 3.13882181770101 +0.9 3.017089912852 +1.35 1.65134750605358 +1.8 2.52522057375659 +2.25 3.37903181047814 +2.7 2.68992495416515 +3.15 0.422519510839068 +3.6 0.242752259814769 +4.05 1.16971858025608 +4.5 2.63932959618825 +4.95 2.27556178324668 +5.4 1.02763452226128 +5.85 2.69128107677898 +6.3 4.01913296955656 +6.75 3.36191433829617 +7.2 1.8843945189995 +7.65 0.838357097191256 +8.1 1.92453252104293 +8.55 2.22915116806076 +9 0.480368221871564 diff --git a/script_clustering_by_pam.r b/script_clustering_by_pam.r new file mode 100644 index 0000000..3243973 --- /dev/null +++ b/script_clustering_by_pam.r @@ -0,0 +1,49 @@ +################################################################## +## File: script_clustering_by_pam.r +## +## Description: Using PAM to clustering conso using pam +## Last modified: jan 2012 by JC +## +################################################################## + +## Function: Converts a matrix of curves to the discret wavelet domain +toDWT <- function(x, filter.number = 6, family = "DaubLeAsymm"){ + x2 <- spline(x, n = 2^ceiling( log(length(x), 2) ), + method = 'natural')$y + Dx2 <- wd(x2, family = family, filter.number = filter.number)$D + return(Dx2) +} + +## Function: Computes the absolute contribution of the wavelet's scale +## to the total total of the curve. +contrib <- function(x) { + J <- log( length(x)+1, 2) + nrj <- numeric(J) + t0 <- 1 + t1 <- 0 + for( j in 1:J ) { + t1 <- t1 + 2^(J-j) + nrj[j] <- sqrt( sum( x[t0:t1]^2 ) ) + t0 <- t1 + 1 + } + return(nrj) +} + +## 1. Load libraries & data #### +library(wavethresh) +library(cluster) + + +# powerload is a matrix that contains on each line one observation +# of length delta + +## 2. DWT ################## +delta <- ncol(powerload) +n <- nrow(powerload) +Xdwt <- t(apply(powerload, 1, toDWT)) # DWT over the lines of powerload. +Xnrj <- t(apply(Xdwt, 1, contrib)) # Absolute contribution to the energy. + +## 3. Cluster ############## +K <- 8 # Number of clusters +Xnrj_dist <- dist(Xnrj) +Xnrj_pam <- pam(as.dist(Xnrj_dist), K)