diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..c651d1bf56b4e7b5bc9bd873c1fee7a457d25909
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,35 @@
+SHELL := /bin/bash
+
+BUILD_DIR := build
+SRC_DIR := src
+INC_DIR := include
+
+CC := gcc
+CFLAGS := -Wall -Wextra -Werror -pedantic -I$(INC_DIR)
+
+SRCS := $(wildcard $(SRC_DIR)/*.c)
+OBJS := $(patsubst $(SRC_DIR)/%.c,$(BUILD_DIR)/%.o,$(SRCS))
+
+TARGETS := $(patsubst $(SRC_DIR)/test_%.c,$(BUILD_DIR)/test_%,$(wildcard $(SRC_DIR)/test_*.c))
+
+.PHONY: all clean
+
+all: $(BUILD_DIR) $(TARGETS)
+
+run: $(TARGETS)
+	@for target in $(TARGETS); do \
+		echo "Running $$target..."; \
+		./$$target; \
+	done
+
+$(BUILD_DIR):
+	mkdir -p $@
+
+$(BUILD_DIR)/%.o: $(SRC_DIR)/%.c | $(BUILD_DIR)
+	$(CC) $(CFLAGS) -c $< -o $@
+
+$(BUILD_DIR)/test_%: $(BUILD_DIR)/test_%.o $(filter-out $(BUILD_DIR)/test_%.o,$(OBJS))
+	$(CC) $(CFLAGS) -o $@ $^
+
+clean:
+	rm -r $(BUILD_DIR)
diff --git a/README.md b/README.md
index 702cd1a8ea38d44dcc43c2520f8761409bc4d496..501b9d6f0f8fbd9a5d856a0ea34964f320f2edc9 100644
--- a/README.md
+++ b/README.md
@@ -1,93 +1,37 @@
-# Problem_maze_generation_and_resolution1
+# Tests
 
+To automatize testing, name each test file as: `test_XXX.c`. All `test_XXX.c` files must be in the `src/` directory.
 
+Use the command `make` to compile each source files. They will be placed in the `build/` directory created by the command.
 
-## Getting started
+To run all the tests, use: `make run`.
 
-To make it easy for you to get started with GitLab, here's a list of recommended next steps.
+NB: If you have implemented the functions of `maze.h` directly in your `test_XXX.c` file, the compilation will fail. To solve the definition conflicts, you have to delete the functions from your `test_XXX.c` file and add at the beginning of your file: `include "maze.h"`.
 
-Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
+## How to redefined a function from a header file in a source file?
 
-## Add your files
+If you need to redefined a function from a header file in your source file (for instance, to count the number of times the function is called), without having to redefined all the functions that calls it, you must add at the beginning of your source file the following:
 
-- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
-- [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:
-
-```
-cd existing_repo
-git remote add origin https://git.unistra.fr/ouldhammouda/problem_maze_generation_and_resolution1.git
-git branch -M main
-git push -uf origin main
+```c
+#define function_name_in_header_file(arg1, arg2, ..., argN) function_name_in_source_file(arg1, arg2, ..., argN)
+#include "header.h"
+#undef function_name_in_header_file
 ```
 
-## Integrate with your tools
-
-- [ ] [Set up project integrations](https://git.unistra.fr/ouldhammouda/problem_maze_generation_and_resolution1/-/settings/integrations)
-
-## Collaborate with your team
-
-- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
-- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
-- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
-- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
-- [ ] [Set auto-merge](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)
-
-## Test and Deploy
-
-Use the built-in continuous integration in GitLab.
-
-- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
-- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
-- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
-- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
-- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
-
-***
-
-# Editing this README
-
-When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thanks to [makeareadme.com](https://www.makeareadme.com/) for this template.
+It will replace all the instances of `function_name_in_header_file` by `function_name_in_source_file` in the code included from `header.h`.
 
-## Suggestions for a good README
+### Example
 
-Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
+To count how many times the function `add_wall()` is called by `generate_maze_aux()`, I need to redefined the function in my source file to increment, for instance, a global variable each time a wall is added to the maze. To do so, I create a function called `test_add_wall()` with the same signature that the original `add_wall()` function.
 
-## Name
-Choose a self-explaining name for your project.
+Then, I implement my new function. In this example, I just need to copy-paste the original function algorithm and I add the code to increment my global variable into it.
 
-## Description
-Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
+For the `generate_maze_aux()` function to call my `test_add_wall()` function, I need to add at the beginning of my source file:
 
-## Badges
-On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
-
-## Visuals
-Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
-
-## Installation
-Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
-
-## Usage
-Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
-
-## Support
-Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
-
-## Roadmap
-If you have ideas for releases in the future, it is a good idea to list them in the README.
-
-## Contributing
-State if you are open to contributions and what your requirements are for accepting them.
-
-For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
-
-You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
-
-## Authors and acknowledgment
-Show your appreciation to those who have contributed to the project.
-
-## License
-For open source projects, say how it is licensed.
+```c
+#define add_wall(graph, i, j, width, size) test_add_wall(graph, i, j, width, size)
+#include "maze.h"
+#undef add_wall
+```
 
-## Project status
-If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.
+That's it!
diff --git a/final_report_link.txt b/final_report_link.txt
new file mode 100644
index 0000000000000000000000000000000000000000..98424bf0a4264055e44d278b8c70caa30641c1e3
--- /dev/null
+++ b/final_report_link.txt
@@ -0,0 +1 @@
+https://docs.google.com/document/d/1rCqWaVAFo6i-NUgiz2tCx8GR06m5_JzwXnAzeOzzs9I/edit?usp=sharing
\ No newline at end of file
diff --git a/include/colors.h b/include/colors.h
new file mode 100644
index 0000000000000000000000000000000000000000..190e0c56d832eadb06eb0359b42af868db635246
--- /dev/null
+++ b/include/colors.h
@@ -0,0 +1,9 @@
+#ifndef COLORS_H
+#define COLORS_H
+
+#define ANSI_COLOR_RESET "\x1b[0m"
+#define ANSI_COLOR_RED "\x1b[38;5;1m"
+#define ANSI_COLOR_GREEN "\x1b[38;5;2m"
+#define ANSI_COLOR_GOLD "\x1b[38;5;220m"  // Doré
+
+#endif //COLORS_H
diff --git a/include/maze.h b/include/maze.h
new file mode 100644
index 0000000000000000000000000000000000000000..9e6beb2ee97dd5886ade710bf63b3dc4a6204ea7
--- /dev/null
+++ b/include/maze.h
@@ -0,0 +1,96 @@
+#ifndef MAZE_H
+#define MAZE_H
+
+#include <stdlib.h>
+
+struct vertex
+{
+	unsigned long long int id;
+
+	// Pointers to the neighbours of the vertex.
+	struct vertex *top;
+	struct vertex *left;
+	struct vertex *bottom;
+	struct vertex *right;
+
+	// Pointer to the parent vertex in the BFS algorithm.
+	struct vertex *parent;
+
+	// Boolean to know if the vertex is the exit of the graph.
+	unsigned int is_end;
+};
+
+struct graph
+{
+	struct vertex *vertices;
+
+	unsigned long long int width;
+	unsigned long long int height;
+};
+
+/*
+ * Preconditions: - step must be a positive integer.
+ * Postconditions: None.
+ *
+ * Returns an integer n equals to min + k * step (k >= 0) such that
+ * n is between min and max included.
+ */
+long long int random_int(long long int min, long long int max, int const step);
+
+/*
+ * Preconditions: None.
+ * Postconditions: None.
+ *
+ * Returns a pointer on the graph, or NULL on error.
+ */
+struct graph *init_graph(long long int const width, long long int const height);
+
+/*
+ * Preconditions: None.
+ * Postconditions: If a wall has been added, graph has lost an edge.
+ *                 Otherwise, graph is not modified, or NULL.
+ */
+void add_wall(struct graph *const graph, long long int const i, long long int const j);
+
+/*
+ * Preconditions: - graph must be initialized.
+ *                - first_vertex_id must be the first vertex id of graph.
+ *                - cur_width must be equal to the width of graph.
+ *                - cur_height must be equal to the height of graph.
+ * Postconditions: graph represents a maze randomly generated.
+ */
+void generate_maze_aux(struct graph *const graph, long long int const first_vertex_id,
+	long long int const cur_width, long long int const cur_height);
+
+/*
+ * Preconditions: None.
+ * Postconditions: graph represents a maze randomly generated, or NULL.
+ */
+void generate_maze(struct graph *const graph);
+
+/*
+ * Preconditions: None.
+ * Postconditions: The memory allocated for graph by init_graph() is freed,
+ *                 or does nothing if graph is NULL.
+ */
+void free_graph(struct graph *graph);
+
+/*
+ * Preconditions: None.
+ * Postconditions: None.
+ *
+ * Returns a NULL-terminated list of the vertex's neighbours.
+ */
+struct vertex **get_neighbours(struct vertex *const vertex);
+
+/*
+ * Preconditions: If a call to find_exit() has already happen for a graph,
+ *				  the said graph must reset all vertices parent to NULL.
+ * Postconditions: Some vertices (or all) will have a new parent vertex.
+ *
+ * Returns the exit vertex which contains the path to the start vertex,
+ * or NULL on error.
+ */
+struct vertex *find_exit(struct graph *const graph, long long int const start);
+
+#endif //MAZE_H
diff --git a/include/queue.h b/include/queue.h
new file mode 100644
index 0000000000000000000000000000000000000000..3152ce2e98f6796592103855697c5938a84c26ba
--- /dev/null
+++ b/include/queue.h
@@ -0,0 +1,62 @@
+#ifndef QUEUE_H
+#define QUEUE_H
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+/**
+ * @brief Structure to represent a queue.
+ * 
+ * This queue uses an array to store the elements. It keeps track of the front,
+ * rear, size, and capacity to handle enqueue and dequeue operations efficiently.
+ */
+typedef struct queue queue_t;
+struct queue {
+    int *data;       ///< Array to hold the data in the queue.
+    int front;       ///< Index of the front of the queue.
+    int rear;        ///< Index of the rear of the queue.
+    int size;        ///< Number of elements currently in the queue.
+    int capacity;    ///< Maximum capacity of the queue.
+};
+
+/**
+ * @brief Function to initialize the queue.
+ * 
+ * Initializes a queue with the given capacity, setting all necessary variables.
+ * 
+ * @param capacity The maximum number of elements the queue can hold.
+ * @return A pointer to the newly created queue.
+ */
+queue_t *createQueue(int capacity);
+
+/**
+ * @brief Function to add an element to the queue.
+ * 
+ * Adds an item to the rear of the queue. The queue resizes if necessary.
+ * 
+ * @param q The queue to add the element to.
+ * @param item The item to add to the queue.
+ */
+void enqueue(queue_t *q, int item);
+
+/**
+ * @brief Function to remove an element from the queue.
+ * 
+ * Removes the element at the front of the queue.
+ * 
+ * @param q The queue to remove the element from.
+ * @return The item that was removed from the front of the queue.
+ */
+int dequeue(queue_t *q);
+
+/**
+ * @brief Function to check if the queue is empty.
+ * 
+ * Checks if the queue has any elements.
+ * 
+ * @param q The queue to check.
+ * @return True if the queue is empty, false otherwise.
+ */
+bool isEmpty(queue_t *q);
+
+#endif // QUEUE_H
diff --git a/include/test.h b/include/test.h
new file mode 100644
index 0000000000000000000000000000000000000000..fd1dbfc66bef969d868171ef8e4026dd009d5323
--- /dev/null
+++ b/include/test.h
@@ -0,0 +1,10 @@
+#ifndef TEST_H
+#define TEST_H
+
+#include <stdio.h>
+#include "colors.h"
+
+void print_failure(char const *const msg);
+void print_success(char const *const msg);
+
+#endif //TEST_H
diff --git a/maze-statement.pdf b/maze-statement.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..be65f699af83ba7d3f1c00e1abde3555c81dda55
Binary files /dev/null and b/maze-statement.pdf differ
diff --git a/performance.png b/performance.png
new file mode 100644
index 0000000000000000000000000000000000000000..72c8721c7727e908c3b664722661913873d267e3
Binary files /dev/null and b/performance.png differ
diff --git a/performance.py b/performance.py
new file mode 100644
index 0000000000000000000000000000000000000000..18d0b45c4bd0f8ca62c17724897d98aafc1358cb
--- /dev/null
+++ b/performance.py
@@ -0,0 +1,38 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+performances = np.loadtxt("test.txt", delimiter=";", skiprows=1);
+
+sizes = performances[:,0] / 10000
+times = performances[:,1]
+
+x = np.linspace(1, sizes[-1], np.size(sizes))
+
+data3 = np.polyfit(sizes, times, 3)
+p3 = np.poly1d(data3)
+data4 = np.polyfit(sizes, times, 4)
+p4 = np.poly1d(data4)
+data5 = np.polyfit(sizes, times, 5)
+p5 = np.poly1d(data5)
+
+x1 = 1685.9236
+x2 = 3166.3129
+y1 = 1008.042130
+y2 = 5133.954117
+
+fig, ax = plt.subplots()
+
+ax.scatter(sizes, times, c="green", marker='+', label="Raw data")
+ax.set_title("Performance of the maze resolution algorithm for random squared mazes")
+ax.set_xlabel("Size (in 10,000 of cells)")
+ax.set_ylabel("Time (in ms)")
+
+ax.plot(x, p3(x), c="black", label="Linear regression: degre 3")
+ax.plot(x, p4(x), c="red", label="Linear regression: degre 4")
+ax.plot(x, p5(x), c="magenta", label="Linear regression: degre 5")
+plt.plot((x1, x2), (y1, y2), c="blue", label="Linear function")
+
+ax.legend()
+
+
+plt.show()
\ No newline at end of file
diff --git a/reports/Final_report_(b).pdf b/reports/Final_report_(b).pdf
new file mode 100644
index 0000000000000000000000000000000000000000..b4a17db9d5cd11f4ee5c7f017bf9ea1cf171208a
Binary files /dev/null and b/reports/Final_report_(b).pdf differ
diff --git a/reports/Weekly_report_3.pdf b/reports/Weekly_report_3.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..587b8b56080edf530c07ce853813d1056ca92887
Binary files /dev/null and b/reports/Weekly_report_3.pdf differ
diff --git a/reports/Weekly_report_4.pdf b/reports/Weekly_report_4.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..c3c6b61dd46fb40298fbfa7b19950278d9cf6009
Binary files /dev/null and b/reports/Weekly_report_4.pdf differ
diff --git a/reports/Weekly_report_5.pdf b/reports/Weekly_report_5.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..9a19a0d6914578330132ce46623c2d2f0b2f5718
Binary files /dev/null and b/reports/Weekly_report_5.pdf differ
diff --git a/reports/c-complexity.pdf b/reports/c-complexity.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..1790b74073e5e8bdf7a247a940c863ad4fcfc2a5
Binary files /dev/null and b/reports/c-complexity.pdf differ
diff --git a/reports/final_report_e-short_start.pdf b/reports/final_report_e-short_start.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..a3ab741a7b66cccecd95c39935b0383bdd034f58
Binary files /dev/null and b/reports/final_report_e-short_start.pdf differ
diff --git a/reports/weekly_report_2.pdf b/reports/weekly_report_2.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..51e663411a1e1eab7a93a048550259226026ddfa
Binary files /dev/null and b/reports/weekly_report_2.pdf differ
diff --git a/src/generate_data.c b/src/generate_data.c
new file mode 100644
index 0000000000000000000000000000000000000000..39cf64a8eedd51b52fb5e11ad503819948d200d7
--- /dev/null
+++ b/src/generate_data.c
@@ -0,0 +1,127 @@
+#include "maze.h"
+#include "test.h"
+#include <string.h>
+#include <time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h> 
+
+#define NB_LOOPS 30
+#define MAX_EXPONENT 15
+#define BASE_2 2
+
+#define TEN_E3 (unsigned long long int) 1e3
+#define TEN_E6 (unsigned long long int) 1e6
+#define TEN_E9 (unsigned long long int) 1e9
+
+void check_error(int const error_code, char const *const msg)
+{
+	if (error_code == -1)
+	{
+		perror(msg);
+		exit(EXIT_FAILURE);
+	}
+}
+
+unsigned int power(unsigned int const x, unsigned int const n)
+{
+	unsigned int result = 1;
+	
+	for (unsigned int i = 0; i < n; i++)
+		result *= x;
+
+	return result;
+}
+
+void clear_maze(struct graph *const graph)
+{
+	if (graph == NULL || graph->vertices == NULL)
+		return;
+
+	unsigned long long int size = graph->width * graph->height;
+
+	for (unsigned long long int i = 0; i < size; i++)
+		graph->vertices[i].parent = NULL;
+}
+
+unsigned long long int substract_positive(long long int x, long long int y)
+{
+	return (x >= y) ? x - y : y - x;
+}
+
+int main(int argc, char const *argv[])
+{
+	if (argc != 2)
+	{
+		fprintf(stderr, "Usage: %s output_file\n", argv[0]);
+		exit(EXIT_FAILURE);
+	}
+
+	char const *const filename = argv[1];
+
+//	int const fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+	int const fd = open(filename, O_WRONLY | O_CREAT | O_APPEND, 0644);
+	check_error(fd, "open");
+
+//	dprintf(fd, "SIZE;TIME\n");
+
+	struct timespec start, end;
+
+	srand(time(NULL));
+
+	struct graph *graph = NULL;
+	long long int size;
+	unsigned long long int s, ns;
+	long double ms;
+
+//	unsigned int base = 2;
+
+	for (int i = 4194; i <= 1e4; i++)
+	{
+//		size = power(base, i);
+		size = i;
+		printf("Size of the maze: %llu\n", size * size);
+
+		printf("Maze initialization...\n");
+		graph = init_graph(size, size);
+
+		if (graph == NULL)
+		{
+			print_failure("Failed to init graph\n");
+			check_error(close(fd), "close");
+			exit(EXIT_FAILURE);
+		}
+
+		printf("Maze generation...\n");
+		generate_maze(graph);
+		s = 0;
+		ns = 0;
+
+		printf("Performance test in progress\n");
+		for (int j = 0; j < NB_LOOPS; j++)
+		{
+			clock_gettime(CLOCK_MONOTONIC, &start);
+			find_exit(graph, 0);
+			clock_gettime(CLOCK_MONOTONIC, &end);
+
+			s += substract_positive(end.tv_sec, start.tv_sec);
+			ns += substract_positive(end.tv_nsec, start.tv_nsec);
+
+			s += ns / TEN_E9;
+			ns = ns % TEN_E9;
+
+			clear_maze(graph);
+		}
+		free_graph(graph);
+		printf("\n");
+
+		ms = s * TEN_E3 / ((long double) NB_LOOPS) + ns / ((long double) NB_LOOPS * TEN_E6);
+
+		dprintf(fd, "%llu;%.6Lf\n", size * size, ms);
+	}
+
+	check_error(close(fd), "close");
+
+	return 0;
+}
\ No newline at end of file
diff --git a/src/maze.c b/src/maze.c
new file mode 100644
index 0000000000000000000000000000000000000000..b312a28c7d7d804b8f6b9313a974399b75babcd4
--- /dev/null
+++ b/src/maze.c
@@ -0,0 +1,298 @@
+#include "maze.h"
+
+long long int random_int(long long int min, long long int max, int const step)
+{
+	if (min > max)
+	{
+		int tmp = min;
+		min = max;
+		max = tmp;
+	}
+
+	long long int k = (max - min) / step;
+
+	return min + step * (rand() % (k+1));
+}
+
+struct graph *init_graph(long long int const width, long long int const height)
+{
+	if (width < 1 || height < 1)
+		return NULL;
+
+	long long int const size = width * height;
+
+	struct graph *graph = (struct graph *) calloc(1, sizeof(struct graph));
+	if (graph == NULL)
+		return NULL;
+
+	graph->vertices = (struct vertex *) calloc(size, sizeof(struct vertex));
+	if (graph->vertices == NULL)
+	{
+		free(graph);
+		return NULL;
+	}
+
+	graph->width = width;
+	graph->height = height;
+
+	// If the maze is only one cell
+	if (width == 1 && height == 1)
+	{
+		graph->vertices[0].id = 0;
+		graph->vertices[0].parent = NULL;
+		graph->vertices[0].is_end = 1;
+
+		graph->vertices[0].top = NULL;
+		graph->vertices[0].bottom = NULL;
+		graph->vertices[0].left = NULL;
+		graph->vertices[0].right = NULL;
+
+		return graph;
+	}
+
+	for (long long int i = 0; i < size; i++)
+	{
+		graph->vertices[i].id = i;
+		graph->vertices[i].parent = NULL;
+		graph->vertices[i].is_end = (i == size-1) ? 1 : 0;
+
+		if (i < width) // If it is a top cell of the maze
+		{
+			graph->vertices[i].top = NULL;
+			graph->vertices[i].bottom = (height == 1) ? NULL : &graph->vertices[i+width];
+			graph->vertices[i].left = (i == 0) ? NULL : &graph->vertices[i-1];
+			graph->vertices[i].right = (i == width-1) ? NULL : &graph->vertices[i+1];
+		}
+		else if (i % width == 0) // Else if it is a left cell of the maze
+		{
+			graph->vertices[i].top = &graph->vertices[i-width];
+			graph->vertices[i].bottom = (i == size - width) ? NULL : &graph->vertices[i+width];
+			graph->vertices[i].left = NULL;
+			graph->vertices[i].right = (width == 1) ? NULL : &graph->vertices[i+1];
+		}
+		else if (i % width == width-1) // Else if it is a right cell of the maze
+		{
+			graph->vertices[i].top = &graph->vertices[i-width];
+			graph->vertices[i].bottom = (i == size - 1) ? NULL : &graph->vertices[i+width];
+			graph->vertices[i].left = &graph->vertices[i-1];
+			graph->vertices[i].right = NULL;
+		}
+		else if (i >= size - width) // Else if it is a bottom cell of the maze
+		{
+			graph->vertices[i].top = &graph->vertices[i-width];
+			graph->vertices[i].bottom = NULL;
+			graph->vertices[i].left = &graph->vertices[i-1];
+			graph->vertices[i].right = &graph->vertices[i+1];
+		}
+		else // Else it is a cell inside of the maze (not an edge)
+		{
+			graph->vertices[i].top = &graph->vertices[i-width];
+			graph->vertices[i].bottom = &graph->vertices[i+width];
+			graph->vertices[i].left = &graph->vertices[i-1];
+			graph->vertices[i].right = &graph->vertices[i+1];
+		}
+	}
+
+	return graph;
+}
+
+void add_wall(struct graph *const graph, long long int const i, long long int const j)
+{
+	long long int const width = graph->width;
+	long long int const height = graph->height;
+	long long int const size = width * height;
+
+	if (graph == NULL || graph->vertices == NULL || i < 0 || j < 0 || i >= size || j >= size)
+		return;
+
+	// If graph->vertices[j] is at the right of graph->vertices[i]
+	// and graph->vertices[i] is not a right border cell
+	if (i + 1 == j && i % width != width-1)
+	{
+		graph->vertices[i].right = NULL;
+		graph->vertices[j].left = NULL;
+	}
+	// Else if graph->vertices[j] is at the bottom of graph->vertices[i]
+	else if (i + width == j)
+	{
+		graph->vertices[i].bottom = NULL;
+		graph->vertices[j].top = NULL;
+	}
+	// Else if graph->vertices[j] is at the left of graph->vertices[i]
+	// and graph->vertices[i] is not a left border cell
+	else if (i - 1 == j && i % width != 0)
+	{
+		graph->vertices[i].left = NULL;
+		graph->vertices[j].right = NULL;
+	}
+	// Else if graph->vertices[j] is at the top of graph->vertices[i]
+	else if (i - width == j)
+	{
+		graph->vertices[i].top = NULL;
+		graph->vertices[j].bottom = NULL;
+	}
+
+	// Else graph->vertices[i] and graph->vertices[j] are not connected,
+	// so no wall can separate them.
+}
+
+void generate_maze_aux(struct graph *const graph, long long int const first_vertex_id,
+	long long int const cur_width, long long int const cur_height)
+{
+	if (cur_width == 1 || cur_height == 1)
+		return;
+
+	unsigned long long int const width = graph->width;
+
+	if (cur_width >= cur_height)
+	{
+		long long int const r_vertex_id = random_int(first_vertex_id,
+											first_vertex_id + cur_width - 2, 1);
+		long long int const r_door_id = random_int(r_vertex_id,
+											r_vertex_id + width * (cur_height - 1), width);
+		long long int vertex_i;
+
+		for (long long int i = 0; i < cur_height; i++)
+		{
+			vertex_i = r_vertex_id + width * i;
+
+			if (vertex_i != r_door_id)
+				add_wall(graph, vertex_i, vertex_i + 1);
+		}
+
+		long long int const left_width = r_vertex_id - first_vertex_id + 1;
+		generate_maze_aux(graph, first_vertex_id, left_width, cur_height);
+		generate_maze_aux(graph, r_vertex_id + 1, cur_width - left_width, cur_height);
+	}
+	else
+	{
+		long long int const r_vertex_id = random_int(first_vertex_id,
+									width * (cur_height - 1 + first_vertex_id / width) - 1, width);
+		long long int const r_door_id = random_int(r_vertex_id, r_vertex_id + cur_width - 1, 1);
+		long long int vertex_i;
+
+		for (long long int i = 0; i < cur_width; i++)
+		{
+			vertex_i = r_vertex_id + i;
+
+			if (vertex_i != r_door_id)
+				add_wall(graph, vertex_i, vertex_i + width);
+		}
+
+		long long int const top_height = (r_vertex_id - first_vertex_id) / width + 1;
+		generate_maze_aux(graph, first_vertex_id, cur_width, top_height);
+		generate_maze_aux(graph, r_vertex_id + width, cur_width, cur_height - top_height);
+	}
+}
+
+void generate_maze(struct graph *const graph)
+{
+	generate_maze_aux(graph, 0, graph->width, graph->height);
+}
+
+void free_graph(struct graph *graph)
+{
+	if (graph != NULL)
+	{
+		if (graph->vertices != NULL)
+			free(graph->vertices);
+
+		free(graph);
+	}
+}
+
+struct vertex **get_neighbours(struct vertex *const vertex)
+{
+	if (vertex == NULL)
+		return NULL;
+
+	struct vertex **neighbours = (struct vertex **) calloc(5, sizeof(struct vertex *));
+	if (neighbours == NULL)
+		return NULL;
+
+	unsigned char i = 0;
+
+	if (vertex->right != NULL && vertex->right->parent == NULL)
+	{
+		neighbours[i] = vertex->right;
+		i++;
+	}
+	if (vertex->bottom != NULL && vertex->bottom->parent == NULL)
+	{
+		neighbours[i] = vertex->bottom;
+		i++;
+	}
+	if (vertex->top != NULL && vertex->top->parent == NULL)
+	{
+		neighbours[i] = vertex->top;
+		i++;
+	}
+	if (vertex->left != NULL && vertex->left->parent == NULL)
+	{
+		neighbours[i] = vertex->left;
+		i++;
+	}
+
+	neighbours[i] = NULL;
+
+	return neighbours;
+}
+
+struct vertex *find_exit(struct graph *const graph, long long int const start)
+{
+	long long int const size = graph->width * graph->height;
+
+	if (graph == NULL || graph->vertices == NULL || start < 0 || start >= size)
+		return NULL;
+
+	struct vertex **queue = (struct vertex **) calloc(size, sizeof(struct vertex *));
+	if (queue == NULL)
+		return NULL;
+
+	graph->vertices[start].parent = &graph->vertices[start];
+
+	unsigned long long int queue_i = 0;
+	unsigned long long int queue_size = 1;
+	queue[queue_i] = &graph->vertices[start];
+
+
+	unsigned char j = 0;
+	struct vertex **neighbours;
+	struct vertex *cur_neighbour;
+
+	struct vertex *cur_vertex = queue[queue_i];
+	
+	while (!cur_vertex->is_end)
+	{
+		neighbours = get_neighbours(cur_vertex);
+		if (neighbours == NULL)
+		{
+			free(queue);
+			return NULL;
+		}
+
+		j = 0;
+		cur_neighbour = neighbours[j];
+		while (cur_neighbour != NULL)
+		{
+			cur_neighbour->parent = cur_vertex;
+			if (cur_neighbour->is_end)
+			{
+				free(neighbours);
+				free(queue);
+
+				return cur_neighbour;
+			}
+
+			queue[queue_size++] = cur_neighbour;
+			cur_neighbour = neighbours[++j];
+		}
+
+		cur_vertex = queue[++queue_i];
+		free(neighbours);
+	}
+
+	free(queue);
+
+	return cur_vertex;
+}
diff --git a/src/queue.c b/src/queue.c
new file mode 100644
index 0000000000000000000000000000000000000000..ccb13105489a38e2ffbd9b496a615241dcefb4d4
--- /dev/null
+++ b/src/queue.c
@@ -0,0 +1,71 @@
+#include "queue.h"
+
+/**
+ * @brief Function to initialize the queue.
+ * 
+ * Initializes a queue with the given capacity. The queue is empty upon creation.
+ * 
+ * @param capacity The maximum number of elements the queue can hold.
+ * @return A pointer to the newly created queue.
+ */
+queue_t *createQueue(int capacity) {
+    queue_t *q = (queue_t *)malloc(sizeof(queue_t)); // Allocate memory for the queue structure.
+    q->data = (int *)malloc(capacity * sizeof(int));  // Allocate memory for the queue's data array.
+    q->front = 0;                                    // The front is at index 0 initially.
+    q->size = 0;                                     // Queue is empty at initialization.
+    q->capacity = capacity;                          // Set the queue's maximum capacity.
+    q->rear = capacity - 1;                          // The rear starts at the last index.
+    return q;
+}
+
+/**
+ * @brief Function to add an element to the queue.
+ * 
+ * Adds an item to the rear of the queue. If the queue is full, it resizes to accommodate more elements.
+ * 
+ * @param q The queue to add the element to.
+ * @param item The item to add to the queue.
+ */
+void enqueue(queue_t *q, int item) {
+    if (q->size == q->capacity) {
+        // Optionally, implement resizing logic here if needed.
+        // This can involve reallocating memory for the queue's data array.
+        return;
+    }
+
+    q->rear = (q->rear + 1) % q->capacity; // Use modulo to wrap around the rear if needed.
+    q->data[q->rear] = item;                // Insert the item at the rear of the queue.
+    q->size++;                               // Increase the size of the queue.
+}
+
+/**
+ * @brief Function to remove an element from the queue.
+ * 
+ * Removes the element from the front of the queue and shifts the front pointer.
+ * 
+ * @param q The queue to remove the element from.
+ * @return The item that was removed from the front of the queue.
+ */
+int dequeue(queue_t *q) {
+    if (isEmpty(q)) {
+        // Optionally, handle the case where the queue is empty.
+        return -1; // Return a sentinel value indicating the queue is empty.
+    }
+
+    int item = q->data[q->front];             // Store the item at the front of the queue.
+    q->front = (q->front + 1) % q->capacity;  // Use modulo to wrap around the front pointer.
+    q->size--;                                // Decrease the size of the queue.
+    return item;                              // Return the removed item.
+}
+
+/**
+ * @brief Function to check if the queue is empty.
+ * 
+ * Checks if the queue has any elements by comparing the size to zero.
+ * 
+ * @param q The queue to check.
+ * @return True if the queue is empty, false otherwise.
+ */
+bool isEmpty(queue_t *q) {
+    return q->size == 0; // Queue is empty if size is zero.
+}
diff --git a/src/test.c b/src/test.c
new file mode 100644
index 0000000000000000000000000000000000000000..7aa0892c2d1aa5805f5ab135e9756a8616101c19
--- /dev/null
+++ b/src/test.c
@@ -0,0 +1,11 @@
+#include "test.h"
+
+void print_failure(char const *const msg)
+{
+	fprintf(stderr, "%s[FAILED] %s%s", ANSI_COLOR_RED, msg, ANSI_COLOR_RESET);
+}
+
+void print_success(char const *const msg)
+{
+	printf("%s[PASSED] %s%s", ANSI_COLOR_GREEN, msg, ANSI_COLOR_RESET);
+}
diff --git a/src/test_bfstree.c b/src/test_bfstree.c
new file mode 100644
index 0000000000000000000000000000000000000000..128063bd74f6e4068da124998a49138cde6f3d24
--- /dev/null
+++ b/src/test_bfstree.c
@@ -0,0 +1,125 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include "maze.h"
+#include "queue.h"
+
+// Structure to represent an edge
+struct edge {
+    int parent;
+    int child;
+};
+
+struct edge *bfs_tree(struct graph *graph, int width, int height, int start, int *num_edges) {
+    //Pré-condition : start ne doit pas être la valeur de la sortie 
+    //Exemple : 24 est la sortie, donc on ne doit pas mettre 24 en argument
+    
+    // Vérifie si le graphe est valide
+    if (graph == NULL || graph->vertices == NULL) {
+        return NULL;
+    }
+
+    // Créer un tableau pour garder une trace des sommets visités
+    int *visited = (int *)calloc(width * height, sizeof(int));
+    if (visited == NULL) {
+        return NULL;  // Échec de l'allocation
+    }
+
+    // Créer une file d'attente pour BFS
+    struct vertex **queue = (struct vertex **)malloc(width * height * sizeof(struct vertex *));
+    int front = 0, rear = 0;
+
+    // Initialiser la file d'attente avec le sommet de départ
+    struct vertex *start_vertex = &graph->vertices[start];
+    queue[rear++] = start_vertex;
+    visited[start] = 1;
+
+    // Variable pour garder une trace des arêtes du BFS
+    struct edge *edges = (struct edge *)malloc(width * height * sizeof(struct edge));
+    int edge_count = 0;
+
+    // BFS
+    while (front < rear) {
+        struct vertex *current = queue[front++];
+
+        // Récupère les voisins du sommet courant
+        struct vertex **neighbours = get_neighbours(current);
+        for (int i = 0; neighbours[i] != NULL; i++) {
+            struct vertex *neighbour = neighbours[i];
+
+            // Si le voisin n'a pas été visité, on l'ajoute à la file d'attente
+            if (!visited[neighbour->id]) {
+                visited[neighbour->id] = 1;
+                queue[rear++] = neighbour;
+
+                // Enregistrer l'arête en utilisant 'parent' et 'child'
+                edges[edge_count].parent = current->id;
+                edges[edge_count].child = neighbour->id;
+                edge_count++;
+            }
+        }
+    }
+
+    // Nettoyer la mémoire
+    free(visited);
+    free(queue);
+
+    *num_edges = edge_count;
+
+    return edges;  // Retourne les arêtes du BFS
+}
+
+
+
+// Function to print the spanning tree
+void print_bfs_tree(struct edge *tree, int num_edges, int root) {
+    printf("Spanning tree (BFS):\n");
+
+    queue_t *q = createQueue(num_edges);
+    enqueue(q, root);
+
+    while (!isEmpty(q)) {
+        int parent = dequeue(q);
+        printf("Node %d: ", parent);
+
+        // Traverse the children of the current parent node
+        for (int i = 0; i < num_edges; i++) {
+            if (tree[i].parent == parent) {
+                printf("%d ", tree[i].child);
+                enqueue(q, tree[i].child);
+            }
+        }
+        printf("\n"); // New line for each parent after listing its children
+    }
+
+    free(q->data);
+    free(q);
+}
+
+int main() {
+    int width = 5;
+    int height = 5;
+    int start_id = 0;
+
+    // Initialiser le graphe (maze)
+    struct graph *graph = init_graph(width, height);  // La fonction retourne un pointeur vers un struct graph, pas un struct vertex
+
+    if (graph == NULL) {
+        printf("Échec de l'initialisation du graphe.\n");
+        return 1;
+    }
+
+    // Générer le labyrinthe
+    generate_maze(graph);  // On passe simplement le graphe, sans largeur ni hauteur
+
+    int num_edges;
+    struct edge *tree = bfs_tree(graph, width, height, start_id, &num_edges);
+    print_bfs_tree(tree, num_edges, start_id);
+
+
+    // Libérer le graphe
+    free_graph(graph);  // La fonction attend un graphe, pas un sommet
+
+    return 0;
+}
+
diff --git a/src/test_big_maze.c b/src/test_big_maze.c
new file mode 100644
index 0000000000000000000000000000000000000000..63ba48e6de569dfdfa3d434ca4f985c977852b63
--- /dev/null
+++ b/src/test_big_maze.c
@@ -0,0 +1,49 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include "maze.h"
+#include "test.h"
+
+void test_big_maze(void) {
+    int width = 100;  // Set width for a large maze
+    int height = 100; // Set height for a large maze
+
+    printf("Initializing a %dx%d maze...\n", width, height);
+
+    struct graph *maze = init_graph(width, height);
+    if (!maze) {
+        print_failure("Failed to initialize the maze.");
+        return;
+    }
+
+    printf("Generating maze...\n");
+    generate_maze(maze);
+
+    printf("Solving maze...\n");
+    struct vertex *exit_vertex = find_exit(maze, 0);
+    if (!exit_vertex) {
+        print_failure("Failed to find the exit in the maze.");
+        free_graph(maze);
+        return;
+    }
+
+    // Validate the path from start to exit
+    struct vertex *current = exit_vertex;
+    int steps = 0;
+
+    while (current->id != 0) {
+        current = current->parent;
+        steps++;
+    }
+
+    printf("Maze solved in %d steps.\n", steps);
+    print_success("The solution path is valid.");
+
+    free_graph(maze);
+}
+
+int main(void) {
+    srand(time(NULL));  // Seed for random number generation
+    test_big_maze();
+    return 0;
+}
diff --git a/src/test_border.c b/src/test_border.c
new file mode 100644
index 0000000000000000000000000000000000000000..1a6b8a3f295f62c6b3118d8e6e89a935fa354111
--- /dev/null
+++ b/src/test_border.c
@@ -0,0 +1,86 @@
+#include <stdio.h>
+#include "maze.h"
+int test_bordure(struct vertex *const graph, int const width, int const height)
+{
+    if (graph == NULL || width < 1 || height < 1)
+        return 0; // Test error if the graph is not initialized.
+
+    int const size = width * height;
+
+    // Check the first row (top == NULL)
+    for (int i = 0; i < width; i++)
+    {
+        if (graph[i].top != NULL)
+        {
+            printf("Error: Cell %d (first row) has a non-NULL 'top'.\n", graph[i].id);
+            return 0;
+        }
+    }
+
+    // Check the last row (bottom == NULL)
+    for (int i = size - width; i < size; i++)
+    {
+        if (graph[i].bottom != NULL)
+        {
+            printf("Error: Cell %d (last row) has a non-NULL 'bottom'.\n", graph[i].id);
+            return 0;
+        }
+    }
+
+    // Check the first column (left == NULL)
+    for (int i = 0; i < size; i += width)
+    {
+        if (graph[i].left != NULL)
+        {
+            printf("Error: Cell %d (first column) has a non-NULL 'left'.\n", graph[i].id);
+            return 0;
+        }
+    }
+
+    // Check the last column (right == NULL)
+    for (int i = width - 1; i < size; i += width)
+    {
+        if (graph[i].right != NULL)
+        {
+            printf("Error: Cell %d (last column) has a non-NULL 'right'.\n", graph[i].id);
+            return 0;
+        }
+    }
+
+    printf("The borders of the maze are correctly initialized.\n");
+    return 1;
+}
+
+//------------------------------------------------------------------------------
+/* Guide for the main
+int main()
+{
+    int width = 5;
+    int height = 4;
+    int id_start = 0;
+
+    struct vertex *graph = init_graph(width, height, id_start);
+
+    if (graph != NULL)
+    {
+        int result = test_bordure(graph, width, height);
+        if (result)
+        {
+            printf("The border test passed.\n");
+        }
+        else
+        {
+            printf("The border test failed.\n");
+        }
+
+        free_graph(graph);
+    }
+    else
+    {
+        printf("Error: Unable to initialize the graph.\n");
+    }
+
+    return 0;
+}*/
+
+
diff --git a/src/test_check_maze_bottom_left_exit.c b/src/test_check_maze_bottom_left_exit.c
new file mode 100644
index 0000000000000000000000000000000000000000..cf08cb6151fe56fc79305a4cc507c21d4f67ca13
--- /dev/null
+++ b/src/test_check_maze_bottom_left_exit.c
@@ -0,0 +1,47 @@
+#include "maze.h"
+#include "test.h"
+
+#define WIDTH 1000
+#define HEIGHT 1000
+
+/*
+ * Test if the exit is located at the bottom-left of the maze.
+ */
+int test_exit_bottom_left(struct vertex *const graph)
+{
+    if (graph == NULL)
+        return 0;
+
+    // Check if the vertex at the bottom-left (last row, first column) is the end
+    if (graph[(HEIGHT - 1) * WIDTH].is_end == 1)
+        return 1;
+
+    return 0;
+}
+
+int main()
+{
+    struct vertex *graph = init_graph(WIDTH, HEIGHT, 0);
+
+    if (graph == NULL)
+    {
+        print_failure("Failed to create a 1000x1000 maze.\n");
+        return EXIT_FAILURE;
+    }
+    
+    // Ensure the exit is set at the desired position
+    graph[(HEIGHT - 1) * WIDTH].is_end = 1; // Set the bottom-left corner as the exit
+
+    // Check if the exit is correctly placed
+    if (!test_exit_bottom_left(graph))
+    {
+        print_failure("The exit is not located at the bottom-left.\n");
+        return EXIT_FAILURE;
+    }
+
+    print_success("The exit is correctly located at the bottom-left.\n");
+
+    free_graph(graph);
+
+    return 0;
+}
diff --git a/src/test_check_path_start_end.c b/src/test_check_path_start_end.c
new file mode 100644
index 0000000000000000000000000000000000000000..afe48eb4e8ad3bd6fff5255d23eaa8cac062b73b
--- /dev/null
+++ b/src/test_check_path_start_end.c
@@ -0,0 +1,42 @@
+#include "maze.h"
+#include "test.h"
+
+#define WIDTH 1000
+#define HEIGHT 1000
+
+/*
+ * Test if the first element is the start and the last element is the end.
+ */
+int test_start_and_end(struct vertex *const graph)
+{
+    if (graph == NULL)
+        return 0;
+
+    if (graph[0].is_start == 1 && graph[WIDTH * HEIGHT - 1].is_end == 1)
+        return 1;
+
+    return 0;
+}
+
+int main()
+{
+    struct vertex *graph = init_graph(WIDTH, HEIGHT, 0);
+
+    if (graph == NULL)
+    {
+        print_failure("Failed to create a 1000x1000 maze.\n");
+        return EXIT_FAILURE;
+    }
+
+    if (!test_start_and_end(graph))
+    {
+        print_failure("The start or end vertex is incorrect.\n");
+        return EXIT_FAILURE;
+    }
+
+    print_success("The start and end vertices are correct.\n");
+
+    free_graph(graph);
+
+    return 0;
+}
diff --git a/src/test_check_unique_exit.c b/src/test_check_unique_exit.c
new file mode 100644
index 0000000000000000000000000000000000000000..9558c43618d36e930f251b33f44e56af9aab4510
--- /dev/null
+++ b/src/test_check_unique_exit.c
@@ -0,0 +1,46 @@
+#include "maze.h"
+#include "test.h"
+
+#define WIDTH 1000
+#define HEIGHT 1000
+
+/*
+ * Test if there is exactly one exit.
+ */
+int test_unique_exit(struct vertex *const graph)
+{
+    if (graph == NULL)
+        return 0;
+
+    int exit_count = 0;
+    for (int i = 0; i < WIDTH * HEIGHT; i++)
+    {
+        if (graph[i].is_end == 1)
+            exit_count++;
+    }
+
+    return (exit_count == 1);
+}
+
+int main()
+{
+    struct vertex *graph = init_graph(WIDTH, HEIGHT, 0);
+
+    if (graph == NULL)
+    {
+        print_failure("Failed to create a 1000x1000 maze.\n");
+        return EXIT_FAILURE;
+    }
+
+    if (!test_unique_exit(graph))
+    {
+        print_failure("There is not exactly one exit.\n");
+        return EXIT_FAILURE;
+    }
+
+    print_success("There is exactly one exit.\n");
+
+    free_graph(graph);
+
+    return 0;
+}
diff --git a/src/test_checkpath.c b/src/test_checkpath.c
new file mode 100644
index 0000000000000000000000000000000000000000..12eef6b8c210b355943229a6e8de6278c02000b5
--- /dev/null
+++ b/src/test_checkpath.c
@@ -0,0 +1,75 @@
+#include "maze.h"
+#include "test.h"
+#include <time.h>
+
+#define WIDTH 10
+#define HEIGHT 10
+
+// Fonction pour vérifier si le chemin est correct
+int verify_path(struct graph *const graph, struct vertex *path) {
+    if (path == NULL) {
+        return 0;  // Pas de chemin trouvé
+    }
+
+    unsigned int const width = graph->width;
+    unsigned int const height = graph->height;
+    struct vertex *cur_vertex = path;
+
+    // Vérifie que chaque vertex dans le chemin pointe correctement vers son parent
+    while (cur_vertex->parent != NULL) {
+        // Le parent doit être un voisin valide du vertex actuel (top, bottom, left, right)
+        struct vertex *parent = cur_vertex->parent;
+
+        // Vérification de la validité du voisinage
+        if (parent->id == cur_vertex->id - 1 && parent->top == cur_vertex)  // parent à gauche
+            ;
+        else if (parent->id == cur_vertex->id + 1 && parent->right == cur_vertex)  // parent à droite
+            ;
+        else if (parent->id == cur_vertex->id - width && parent->bottom == cur_vertex)  // parent en haut
+            ;
+        else if (parent->id == cur_vertex->id + width && parent->top == cur_vertex)  // parent en bas
+            ;
+        else {
+            return 0;  // Parent invalide
+        }
+        cur_vertex = parent;
+    }
+
+    // Vérifier que l'on est bien arrivé à la sortie
+    return (cur_vertex->is_end == 1);
+}
+
+/*
+int main() {
+    srand(time(NULL));
+
+    struct graph *graph = init_graph(WIDTH, HEIGHT);
+
+    if (graph == NULL) {
+        print_failure("Failed to create 10x10 maze.\n");
+        return EXIT_FAILURE;
+    }
+
+    // Générer le labyrinthe
+    generate_maze(graph);
+    
+    // Afficher le labyrinthe généré
+    display_maze(graph);
+
+    // Trouver la sortie et afficher le chemin
+    struct vertex *path = find_exit(graph, 0);
+    display_path(graph, path);
+
+    // Vérification du chemin
+    if (verify_path(graph, path)) {
+        print_success("Path is correct!\n");
+    } else {
+        print_failure("Path is incorrect!\n");
+    }
+
+    // Libérer la mémoire allouée
+    free_graph(graph);
+
+    return EXIT_SUCCESS;
+}
+*/
diff --git a/src/test_n_x_one_maze.c b/src/test_n_x_one_maze.c
new file mode 100644
index 0000000000000000000000000000000000000000..fae333a0b09cdc56c7129767a5b36405823fd0ac
--- /dev/null
+++ b/src/test_n_x_one_maze.c
@@ -0,0 +1,137 @@
+// Replace add_wall() in maze.h by test_add_wall()
+#define add_wall(graph, i, j) test_add_wall(graph, i, j)
+#include "maze.h"
+#undef add_wall // Undo the previous modification
+
+#include "test.h"
+
+#define WIDTH 10
+#define HEIGHT 1
+
+/*
+ * Preconditions: None.
+ * Postconditions: None.
+ *
+ * Returns 1 if the width and height of the graph are equals to 1.
+ * Otherwise, it returns 0.
+ */
+int test_is_n_x_one(struct graph *const graph)
+{
+	if (graph == NULL)
+		return 0;
+
+	unsigned int is_n_x_one = 1;
+	unsigned int size = WIDTH * HEIGHT;
+
+	for (unsigned int i = 0; i < size && is_n_x_one == 1; i++)
+	{
+		is_n_x_one = is_n_x_one && graph->vertices[i].top == NULL && graph->vertices[i].bottom == NULL;
+
+		if (i == 0)
+			is_n_x_one = is_n_x_one && graph->vertices[i].left == NULL;
+		else
+			is_n_x_one = is_n_x_one && graph->vertices[i].left == &graph->vertices[i-1];
+
+		if (i == size - 1)
+			is_n_x_one = is_n_x_one && graph->vertices[i].right == NULL;
+		else
+			is_n_x_one = is_n_x_one && graph->vertices[i].right == &graph->vertices[i+1];			
+	}
+
+	return is_n_x_one;
+}
+
+unsigned int nb_walls_added = 0;
+
+/*
+ * Postconditions: - nb_walls_added is incremented by one each time a wall
+ *                 is added to the graph->
+ */
+void test_add_wall(struct graph *const graph, int const i, int const j)
+{
+	int const width = graph->width;
+	int const height = graph->height;
+	int const size = width * height;
+
+	if (graph == NULL || i < 0 || j < 0 || i >= size || j >= size)
+		return;
+
+	// If graph->vertices[j] is at the right of graph->vertices[i]
+	// and graph->vertices[i] is not a right border cell
+	if (i + 1 == j && i % width != width-1)
+	{
+		graph->vertices[i].right = NULL;
+		graph->vertices[j].left = NULL;
+		nb_walls_added++;
+	}
+	// Else if graph->vertices[j] is at the bottom of graph->vertices[i]
+	else if (i + width == j)
+	{
+		graph->vertices[i].bottom = NULL;
+		graph->vertices[j].top = NULL;
+		nb_walls_added++;
+	}
+	// Else if graph->vertices[j] is at the left of graph->vertices[i]
+	// and graph->vertices[i] is not a left border cell
+	else if (i - 1 == j && i % width != 0)
+	{
+		graph->vertices[i].left = NULL;
+		graph->vertices[j].right = NULL;
+		nb_walls_added++;
+	}
+	// Else if graph->vertices[j] is at the top of graph->vertices[i]
+	else if (i - width == j)
+	{
+		graph->vertices[i].top = NULL;
+		graph->vertices[j].bottom = NULL;
+		nb_walls_added++;
+	}
+
+	// Else graph->vertices[i] and graph->vertices[j] are not connected,
+	// so no wall can separate them.
+}
+
+/*
+ * Preconditions: None.
+ * Postconditions: graph represents a maze randomly generated, or NULL.
+ *
+ * Returns 1 if the function add_wall() is never called.
+ * Otherwise, it returns 0.
+ */
+int test_do_not_create_wall(struct graph *const graph)
+{
+	generate_maze(graph);
+
+	return nb_walls_added == 0;
+}
+
+int main()
+{
+	struct graph *graph = init_graph(WIDTH, HEIGHT);
+
+	if (graph == NULL)
+	{
+		print_failure("Failed to create a 10x1 maze.\n");
+		return EXIT_FAILURE;
+	}
+
+	if (!test_is_n_x_one(graph))
+	{
+		print_failure("The maze is not a 10x1 maze.\n");
+		return EXIT_FAILURE;
+	}
+
+	print_success("The maze is a 10x1 maze.\n");
+
+	if (!test_do_not_create_wall(graph))
+	{
+		print_failure("Walls have been created in the 10x1 maze.\n");
+		return EXIT_FAILURE;
+	}
+
+	print_success("No wall has been created in the 10x1 maze.\n");
+
+	free_graph(graph);
+
+	return 0;
+}
\ No newline at end of file
diff --git a/src/test_one_x_n_maze.c b/src/test_one_x_n_maze.c
new file mode 100644
index 0000000000000000000000000000000000000000..c6e40086760b6042de32b8c4347cd8d03e2d2290
--- /dev/null
+++ b/src/test_one_x_n_maze.c
@@ -0,0 +1,137 @@
+// Replace add_wall() in maze.h by test_add_wall()
+#define add_wall(graph, i, j) test_add_wall(graph, i, j)
+#include "maze.h"
+#undef add_wall // Undo the previous modification
+
+#include "test.h"
+
+#define WIDTH 1
+#define HEIGHT 10
+
+/*
+ * Preconditions: None.
+ * Postconditions: None.
+ *
+ * Returns 1 if the width and height of the graph are equals to 1.
+ * Otherwise, it returns 0.
+ */
+int test_is_one_x_n(struct graph *const graph)
+{
+	if (graph == NULL)
+		return 0;
+
+	unsigned int is_one_x_n = 1;
+	unsigned int size = WIDTH * HEIGHT;
+
+	for (unsigned int i = 0; i < size && is_one_x_n == 1; i++)
+	{
+		is_one_x_n = is_one_x_n && graph->vertices[i].left == NULL && graph->vertices[i].right == NULL;
+
+		if (i == 0)
+			is_one_x_n = is_one_x_n && graph->vertices[i].top == NULL;
+		else
+			is_one_x_n = is_one_x_n && graph->vertices[i].top == &graph->vertices[i-1];
+
+		if (i == size - 1)
+			is_one_x_n = is_one_x_n && graph->vertices[i].bottom == NULL;
+		else
+			is_one_x_n = is_one_x_n && graph->vertices[i].bottom == &graph->vertices[i+1];
+	}
+
+	return is_one_x_n;
+}
+
+unsigned int nb_walls_added = 0;
+
+/*
+ * Postconditions: - nb_walls_added is incremented by one each time a wall
+ *                 is added to the graph->
+ */
+void test_add_wall(struct graph *const graph, int const i, int const j)
+{
+	int const width = graph->width;
+	int const height = graph->height;
+	int const size = width * height;
+
+	if (graph == NULL || i < 0 || j < 0 || i >= size || j >= size)
+		return;
+
+	// If graph->vertices[j] is at the right of graph->vertices[i]
+	// and graph->vertices[i] is not a right border cell
+	if (i + 1 == j && i % width != width-1)
+	{
+		graph->vertices[i].right = NULL;
+		graph->vertices[j].left = NULL;
+		nb_walls_added++;
+	}
+	// Else if graph->vertices[j] is at the bottom of graph->vertices[i]
+	else if (i + width == j)
+	{
+		graph->vertices[i].bottom = NULL;
+		graph->vertices[j].top = NULL;
+		nb_walls_added++;
+	}
+	// Else if graph->vertices[j] is at the left of graph->vertices[i]
+	// and graph->vertices[i] is not a left border cell
+	else if (i - 1 == j && i % width != 0)
+	{
+		graph->vertices[i].left = NULL;
+		graph->vertices[j].right = NULL;
+		nb_walls_added++;
+	}
+	// Else if graph->vertices[j] is at the top of graph->vertices[i]
+	else if (i - width == j)
+	{
+		graph->vertices[i].top = NULL;
+		graph->vertices[j].bottom = NULL;
+		nb_walls_added++;
+	}
+
+	// Else graph->vertices[i] and graph->vertices[j] are not connected,
+	// so no wall can separate them.
+}
+
+/*
+ * Preconditions: None.
+ * Postconditions: graph represents a maze randomly generated, or NULL.
+ *
+ * Returns 1 if the function add_wall() is never called.
+ * Otherwise, it returns 0.
+ */
+int test_do_not_create_wall(struct graph *const graph)
+{
+	generate_maze(graph);
+
+	return nb_walls_added == 0;
+}
+
+int main()
+{
+	struct graph *graph = init_graph(WIDTH, HEIGHT);
+
+	if (graph == NULL)
+	{
+		print_failure("Failed to create a 1x10 maze.\n");
+		return EXIT_FAILURE;
+	}
+
+	if (!test_is_one_x_n(graph))
+	{
+		print_failure("The maze is not a 1x10 maze.\n");
+		return EXIT_FAILURE;
+	}
+
+	print_success("The maze is a 1x10 maze.\n");
+
+	if (!test_do_not_create_wall(graph))
+	{
+		print_failure("Walls have been created in the 1x10 maze.\n");
+		return EXIT_FAILURE;
+	}
+
+	print_success("No wall has been created in the 1x10 maze.\n");
+
+	free_graph(graph);
+
+	return 0;
+}
\ No newline at end of file
diff --git a/src/test_one_x_one_maze.c b/src/test_one_x_one_maze.c
new file mode 100644
index 0000000000000000000000000000000000000000..003db37d8db7a5bfbe157700c6872e7175152e45
--- /dev/null
+++ b/src/test_one_x_one_maze.c
@@ -0,0 +1,124 @@
+// Replace add_wall() in maze.h by test_add_wall()
+#define add_wall(graph, i, j) test_add_wall(graph, i, j)
+#include "maze.h"
+#undef add_wall // Undo the previous modification
+
+#include "test.h"
+
+#define WIDTH 1
+#define HEIGHT 1
+
+/*
+ * Preconditions: None.
+ * Postconditions: None.
+ *
+ * Returns 1 if the width and height of the graph are equals to 1.
+ * Otherwise, it returns 0.
+ */
+int test_is_one_x_one(struct graph *const graph)
+{
+	if (graph == NULL)
+		return 0;
+
+	struct vertex first_vertex = *graph->vertices;
+
+	// If the graph is a 1x1 graph, there is only one vertex.
+	// Therefore, it should not have any neighbour.
+	return first_vertex.top == NULL && first_vertex.left == NULL &&
+	       first_vertex.bottom == NULL && first_vertex.right == NULL;
+}
+
+unsigned int nb_walls_added = 0;
+
+/*
+ * Postconditions: - nb_walls_added is incremented by one each time a wall
+ *                 is added to the graph->
+ */
+void test_add_wall(struct graph *const graph, int const i, int const j)
+{
+	int const width = graph->width;
+	int const height = graph->height;
+	int const size = width * height;
+
+	if (graph == NULL || i < 0 || j < 0 || i >= size || j >= size)
+		return;
+
+	// If graph->vertices[j] is at the right of graph->vertices[i]
+	// and graph->vertices[i] is not a right border cell
+	if (i + 1 == j && i % width != width-1)
+	{
+		graph->vertices[i].right = NULL;
+		graph->vertices[j].left = NULL;
+		nb_walls_added++;
+	}
+	// Else if graph->vertices[j] is at the bottom of graph->vertices[i]
+	else if (i + width == j)
+	{
+		graph->vertices[i].bottom = NULL;
+		graph->vertices[j].top = NULL;
+		nb_walls_added++;
+	}
+	// Else if graph->vertices[j] is at the left of graph->vertices[i]
+	// and graph->vertices[i] is not a left border cell
+	else if (i - 1 == j && i % width != 0)
+	{
+		graph->vertices[i].left = NULL;
+		graph->vertices[j].right = NULL;
+		nb_walls_added++;
+	}
+	// Else if graph->vertices[j] is at the top of graph->vertices[i]
+	else if (i - width == j)
+	{
+		graph->vertices[i].top = NULL;
+		graph->vertices[j].bottom = NULL;
+		nb_walls_added++;
+	}
+
+	// Else graph->vertices[i] and graph->vertices[j] are not connected,
+	// so no wall can separate them.
+}
+
+/*
+ * Preconditions: None.
+ * Postconditions: graph represents a maze randomly generated, or NULL.
+ *
+ * Returns 1 if the function add_wall() is never called.
+ * Otherwise, it returns 0.
+ */
+int test_do_not_create_wall(struct graph *const graph)
+{
+	generate_maze(graph);
+
+	return nb_walls_added == 0;
+}
+
+int main()
+{
+	struct graph *graph = init_graph(WIDTH, HEIGHT);
+
+	if (graph == NULL)
+	{
+		print_failure("Failed to create a 1x1 maze.\n");
+		return EXIT_FAILURE;
+	}
+
+	if (!test_is_one_x_one(graph))
+	{
+		print_failure("The maze is not a 1x1 maze.\n");
+		return EXIT_FAILURE;
+	}
+
+	print_success("The maze is a 1x1 maze.\n");
+
+	if (!test_do_not_create_wall(graph))
+	{
+		print_failure("Walls have been created in the 1x1 maze.\n");
+		return EXIT_FAILURE;
+	}
+
+	print_success("No wall has been created in the 1x1 maze.\n");
+
+	free_graph(graph);
+
+	return 0;
+}
\ No newline at end of file
diff --git a/src/test_performance_m.c b/src/test_performance_m.c
new file mode 100644
index 0000000000000000000000000000000000000000..8c0762d932a36781a1f7911be76888874aafacd1
--- /dev/null
+++ b/src/test_performance_m.c
@@ -0,0 +1,54 @@
+#include <stdio.h>
+#include <time.h>
+#include "maze.h"
+#include <linux/time.h>
+
+// Fonction pour mesurer le temps écoulé en millisecondes
+double get_time_diff(struct timespec start, struct timespec end) {
+    return (end.tv_sec - start.tv_sec) * 1000.0 + (end.tv_nsec - start.tv_nsec) / 1000000.0;
+}
+
+// Teste les performances des fonctions generate_maze et find_exit
+void test_performance(int width, int height) {
+    struct timespec start, end;
+    struct graph *maze;
+
+    // Mesure du temps pour la génération du labyrinthe
+    clock_gettime(CLOCK_MONOTONIC, &start);
+    maze = init_graph(width, height);
+    if (maze == NULL) {
+        printf("Erreur lors de l'initialisation du labyrinthe\n");
+        return;
+    }
+    generate_maze(maze);
+    clock_gettime(CLOCK_MONOTONIC, &end);
+    double generate_time = get_time_diff(start, end);
+
+    // Mesure du temps pour trouver la sortie
+    clock_gettime(CLOCK_MONOTONIC, &start);
+    struct vertex *exit_vertex = find_exit(maze, 0);
+    clock_gettime(CLOCK_MONOTONIC, &end);
+    double find_exit_time = get_time_diff(start, end);
+
+    // Affiche les résultats
+    printf("Dimensions du labyrinthe : %dx%d\n", width, height);
+    printf("Temps pour générer le labyrinthe : %.3f ms\n", generate_time);
+    printf("Temps pour trouver la sortie : %.3f ms\n", find_exit_time);
+    
+    // Libération de la mémoire
+    free_graph(maze);
+}
+
+int main() {
+    // Différentes tailles de labyrinthe pour observer la complexité
+    int sizes[][2] = {{10, 10}, {20, 20}, {30, 30}, {40, 40}, {50, 50}};
+    int num_sizes = sizeof(sizes) / sizeof(sizes[0]);
+
+    for (int i = 0; i < num_sizes; i++) {
+        int width = sizes[i][0];
+        int height = sizes[i][1];
+        test_performance(width, height);
+    }
+
+    return 0;
+}
diff --git a/src/test_performance_resolution.c b/src/test_performance_resolution.c
new file mode 100644
index 0000000000000000000000000000000000000000..e4d7fe341babee158f2236ad0a5802c790f8881c
--- /dev/null
+++ b/src/test_performance_resolution.c
@@ -0,0 +1,60 @@
+#include "maze.h"
+#include <stdio.h>
+#include "queue.h"
+#include <time.h>
+#include <fcntl.h>
+
+
+int main(int argc, char *argv[]){
+    if (argc != 6){
+        printf("Usage: height, width, nbr of test, start, name of the file \n");
+        exit(EXIT_FAILURE);
+    }
+
+    int const height = atoi(argv[1]);
+    int const width = atoi(argv[2]);
+    int const n = atoi(argv[3]); //the number of time we make the test
+    int const start = atoi(argv[4]);
+    int const size = height*width;
+    struct graph *g;
+    g = init_graph(width,height);
+    if (g == NULL){
+        printf("erreur lors de init_graph\n");
+        exit(EXIT_FAILURE);
+    }
+    clock_t t_start, t_end;
+    double result = 0;
+    generate_maze(g);
+
+    if(start <= 0 && start > size){
+        printf("start pas dans le graphe\n");
+        exit(EXIT_FAILURE);
+    }
+
+    // struct vertex *c = find_exit(g,start);
+    for (int i = 0; i < n; i++){
+        for (int j = 0; j < size; j++) {
+            g->vertices[j].parent = NULL;
+        }
+        t_start = clock();
+        (void)find_exit(g,start);
+        t_end = clock();
+        result += (((double)(t_end - t_start)/CLOCKS_PER_SEC)*1000); // the time in ms for each test
+    }
+
+    free_graph(g);
+
+    //calculat the mean
+    printf("la moyenne du temps prit pour la résolution est de : %f\n", result/n);
+
+    FILE* file = fopen(argv[5], "a");
+    //see if the file is empty for init the colum
+    int empty = ftell(file);
+    if (empty == 0){
+        fprintf(file, "TIME SIZE\n");
+    }
+    fseek (file, 0, SEEK_END);
+    fprintf(file, "%f %d\n", result/n, size);
+    fclose(file);
+    return 0;
+}
\ No newline at end of file
diff --git a/src/test_solve_n_x_n_maze.c b/src/test_solve_n_x_n_maze.c
new file mode 100644
index 0000000000000000000000000000000000000000..706ac03a101888ef9c612db38793746cc3b296e8
--- /dev/null
+++ b/src/test_solve_n_x_n_maze.c
@@ -0,0 +1,100 @@
+#include "maze.h"
+#include "test.h"
+#include <time.h>
+#include "colors.h"
+
+
+#define WIDTH 10
+#define HEIGHT 10
+
+void display_maze(struct graph *const graph) {
+    if (graph == NULL || graph->vertices == NULL)
+    	return;
+
+    unsigned int const width = graph->width;
+    unsigned int const height = graph->height;
+
+    for (unsigned int j = 0; j < 3 * height; j++)
+    {
+    	for (unsigned int i = 0; i < width; i++)
+    	{
+    		if (j % 3 == 0)
+    		{
+    			printf("+%s+",
+    				(graph->vertices[i + (j / 3) * width].top == NULL) ? "---" : "   ");
+    		}
+    		else if (j % 3 == 1)
+    		{
+    				printf("%c   %c",
+    					(graph->vertices[i + (j / 3) * width].left == NULL) ? '|' : ' ',
+    					(graph->vertices[i + (j / 3) * width].right == NULL) ? '|' : ' ');
+    		}
+    		else
+    		{
+
+    			printf("+%s+",
+    				(graph->vertices[i + (j / 3) * width].bottom == NULL) ? "---" : "   ");
+    		}
+    	}
+    	printf("\n");
+    }
+}
+
+#define CURSOR_UP(POS) printf("\x1b[%dA", POS)
+#define CURSOR_DOWN(POS) printf("\x1b[%dB", POS)
+#define CURSOR_HORIZONTAL_ABSOLUTE(POS) printf("\x1b[%dG", POS)
+
+void display_path(struct graph *const graph, struct vertex *path)
+{
+	if (graph == NULL || path == NULL)
+		return;
+
+	unsigned int const width = graph->width;
+	unsigned int const height = graph->height;
+
+	while (path != path->parent)
+	{
+		CURSOR_UP(3 * (height - path->id / width - 1) + 2);
+		CURSOR_HORIZONTAL_ABSOLUTE(5 * (path->id % width + 1) - 2);
+		printf(ANSI_COLOR_GOLD"#"ANSI_COLOR_RESET);
+		CURSOR_HORIZONTAL_ABSOLUTE(-5 * (path->id % width + 1) + 2);
+		CURSOR_DOWN(3 * (height - path->id / width - 1) + 2);
+		path = path->parent;
+	}
+	CURSOR_UP(3 * (height - path->id / width - 1) + 2);
+	CURSOR_HORIZONTAL_ABSOLUTE(5 * (path->id % width + 1) - 2);
+	printf("%s#%s",ANSI_COLOR_GOLD,ANSI_COLOR_RESET);
+	CURSOR_HORIZONTAL_ABSOLUTE(-5 * (path->id % width + 1) + 2);
+	CURSOR_DOWN(3 * (height - path->id / width - 1) + 2);
+}
+
+int main()
+{
+	srand(time(NULL));
+
+	struct graph *graph = init_graph(WIDTH, HEIGHT);
+
+	if (graph == NULL)
+	{
+		print_failure("Failed to create 10x10 maze.\n");
+		return EXIT_FAILURE;
+	}
+
+	generate_maze(graph);
+	display_maze(graph);
+
+	struct vertex *path = find_exit(graph, 0);
+	display_path(graph, path);
+/*
+	struct vertex *cur_vertex = path;
+	while (cur_vertex != cur_vertex->parent)
+	{
+		printf("%3u <- ", cur_vertex->id);
+		cur_vertex = cur_vertex->parent;
+	}
+	printf("%3u\n", cur_vertex->id);
+*/
+	free_graph(graph);
+
+	return EXIT_SUCCESS;
+}
\ No newline at end of file
diff --git a/src/test_solve_n_x_one_maze.c b/src/test_solve_n_x_one_maze.c
new file mode 100644
index 0000000000000000000000000000000000000000..041f818cd03463ea971b88b8579eb657665c7693
--- /dev/null
+++ b/src/test_solve_n_x_one_maze.c
@@ -0,0 +1,88 @@
+#include "maze.h"
+#include "test.h"
+#include "colors.h"
+
+#define WIDTH 10
+#define HEIGHT 1
+
+void display_maze(struct graph *const graph) {
+    if (graph == NULL || graph->vertices == NULL)
+    	return;
+
+    unsigned int const width = graph->width;
+    unsigned int const height = graph->height;
+
+    for (unsigned int j = 0; j < 3 * height; j++)
+    {
+    	for (unsigned int i = 0; i < width; i++)
+    	{
+    		if (j % 3 == 0)
+    		{
+    			printf("+%s+",
+    				(graph->vertices[i + (j / 3) * width].top == NULL) ? "---" : "   ");
+    		}
+    		else if (j % 3 == 1)
+    		{
+    				printf("%c   %c",
+    					(graph->vertices[i + (j / 3) * width].left == NULL) ? '|' : ' ',
+    					(graph->vertices[i + (j / 3) * width].right == NULL) ? '|' : ' ');
+    		}
+    		else
+    		{
+
+    			printf("+%s+",
+    				(graph->vertices[i + (j / 3) * width].bottom == NULL) ? "---" : "   ");
+    		}
+    	}
+    	printf("\n");
+    }
+}
+
+#define CURSOR_UP(POS) printf("\x1b[%dA", POS)
+#define CURSOR_DOWN(POS) printf("\x1b[%dB", POS)
+#define CURSOR_HORIZONTAL_ABSOLUTE(POS) printf("\x1b[%dG", POS)
+
+void display_path(struct graph *const graph, struct vertex *path)
+{
+	if (graph == NULL || path == NULL)
+		return;
+
+	unsigned int const width = graph->width;
+	unsigned int const height = graph->height;
+
+	while (path != path->parent)
+	{
+		CURSOR_UP(3 * (height - path->id / width - 1) + 2);
+		CURSOR_HORIZONTAL_ABSOLUTE(5 * (path->id % width + 1) - 2);
+		printf(ANSI_COLOR_GOLD"#"ANSI_COLOR_RESET);
+		CURSOR_HORIZONTAL_ABSOLUTE(-5 * (path->id % width + 1) + 2);
+		CURSOR_DOWN(3 * (height - path->id / width - 1) + 2);
+		path = path->parent;
+	}
+	CURSOR_UP(3 * (height - path->id / width - 1) + 2);
+	CURSOR_HORIZONTAL_ABSOLUTE(5 * (path->id % width + 1) - 2);
+	printf(ANSI_COLOR_GOLD"#"ANSI_COLOR_RESET);
+	CURSOR_HORIZONTAL_ABSOLUTE(-5 * (path->id % width + 1) + 2);
+	CURSOR_DOWN(3 * (height - path->id / width - 1) + 2);
+}
+
+int main()
+{
+	struct graph *graph = init_graph(WIDTH, HEIGHT);
+
+	if (graph == NULL)
+	{
+		print_failure("Failed to create 10x10 maze.\n");
+		return EXIT_FAILURE;
+	}
+
+	generate_maze(graph);
+	display_maze(graph);
+
+	struct vertex *path = find_exit(graph, 0);
+	display_path(graph, path);
+
+	free_graph(graph);
+
+	return EXIT_SUCCESS;
+}
\ No newline at end of file
diff --git a/src/test_solve_one_x_n_maze.c b/src/test_solve_one_x_n_maze.c
new file mode 100644
index 0000000000000000000000000000000000000000..203088b130659d338e33e3b9f24fc17cca1777f9
--- /dev/null
+++ b/src/test_solve_one_x_n_maze.c
@@ -0,0 +1,88 @@
+#include "maze.h"
+#include "test.h"
+#include "colors.h"
+
+#define WIDTH 1
+#define HEIGHT 10
+
+void display_maze(struct graph *const graph) {
+    if (graph == NULL || graph->vertices == NULL)
+    	return;
+
+    unsigned int const width = graph->width;
+    unsigned int const height = graph->height;
+
+    for (unsigned int j = 0; j < 3 * height; j++)
+    {
+    	for (unsigned int i = 0; i < width; i++)
+    	{
+    		if (j % 3 == 0)
+    		{
+    			printf("+%s+",
+    				(graph->vertices[i + (j / 3) * width].top == NULL) ? "---" : "   ");
+    		}
+    		else if (j % 3 == 1)
+    		{
+    				printf("%c   %c",
+    					(graph->vertices[i + (j / 3) * width].left == NULL) ? '|' : ' ',
+    					(graph->vertices[i + (j / 3) * width].right == NULL) ? '|' : ' ');
+    		}
+    		else
+    		{
+
+    			printf("+%s+",
+    				(graph->vertices[i + (j / 3) * width].bottom == NULL) ? "---" : "   ");
+    		}
+    	}
+    	printf("\n");
+    }
+}
+
+#define CURSOR_UP(POS) printf("\x1b[%dA", POS)
+#define CURSOR_DOWN(POS) printf("\x1b[%dB", POS)
+#define CURSOR_HORIZONTAL_ABSOLUTE(POS) printf("\x1b[%dG", POS)
+
+void display_path(struct graph *const graph, struct vertex *path)
+{
+	if (graph == NULL || path == NULL)
+		return;
+
+	unsigned int const width = graph->width;
+	unsigned int const height = graph->height;
+
+	while (path != path->parent)
+	{
+		CURSOR_UP(3 * (height - path->id / width - 1) + 2);
+		CURSOR_HORIZONTAL_ABSOLUTE(5 * (path->id % width + 1) - 2);
+		printf(ANSI_COLOR_GOLD"#"ANSI_COLOR_RESET);
+		CURSOR_HORIZONTAL_ABSOLUTE(-5 * (path->id % width + 1) + 2);
+		CURSOR_DOWN(3 * (height - path->id / width - 1) + 2);
+		path = path->parent;
+	}
+	CURSOR_UP(3 * (height - path->id / width - 1) + 2);
+	CURSOR_HORIZONTAL_ABSOLUTE(5 * (path->id % width + 1) - 2);
+	printf(ANSI_COLOR_GOLD"#"ANSI_COLOR_RESET);
+	CURSOR_HORIZONTAL_ABSOLUTE(-5 * (path->id % width + 1) + 2);
+	CURSOR_DOWN(3 * (height - path->id / width - 1) + 2);
+}
+
+int main()
+{
+	struct graph *graph = init_graph(WIDTH, HEIGHT);
+
+	if (graph == NULL)
+	{
+		print_failure("Failed to create 10x10 maze.\n");
+		return EXIT_FAILURE;
+	}
+
+	generate_maze(graph);
+	display_maze(graph);
+
+	struct vertex *path = find_exit(graph, 0);
+	display_path(graph, path);
+
+	free_graph(graph);
+
+	return EXIT_SUCCESS;
+}
\ No newline at end of file
diff --git a/src/test_solve_one_x_one_maze.c b/src/test_solve_one_x_one_maze.c
new file mode 100644
index 0000000000000000000000000000000000000000..76bee4055327f33cb61a595892af8be844f90db2
--- /dev/null
+++ b/src/test_solve_one_x_one_maze.c
@@ -0,0 +1,88 @@
+#include "maze.h"
+#include "test.h"
+#include "colors.h"
+
+#define WIDTH 1
+#define HEIGHT 1
+
+void display_maze(struct graph *const graph) {
+    if (graph == NULL || graph->vertices == NULL)
+    	return;
+
+    unsigned int const width = graph->width;
+    unsigned int const height = graph->height;
+
+    for (unsigned int j = 0; j < 3 * height; j++)
+    {
+    	for (unsigned int i = 0; i < width; i++)
+    	{
+    		if (j % 3 == 0)
+    		{
+    			printf("+%s+",
+    				(graph->vertices[i + (j / 3) * width].top == NULL) ? "---" : "   ");
+    		}
+    		else if (j % 3 == 1)
+    		{
+    				printf("%c   %c",
+    					(graph->vertices[i + (j / 3) * width].left == NULL) ? '|' : ' ',
+    					(graph->vertices[i + (j / 3) * width].right == NULL) ? '|' : ' ');
+    		}
+    		else
+    		{
+
+    			printf("+%s+",
+    				(graph->vertices[i + (j / 3) * width].bottom == NULL) ? "---" : "   ");
+    		}
+    	}
+    	printf("\n");
+    }
+}
+
+#define CURSOR_UP(POS) printf("\x1b[%dA", POS)
+#define CURSOR_DOWN(POS) printf("\x1b[%dB", POS)
+#define CURSOR_HORIZONTAL_ABSOLUTE(POS) printf("\x1b[%dG", POS)
+
+void display_path(struct graph *const graph, struct vertex *path)
+{
+	if (graph == NULL || path == NULL)
+		return;
+
+	unsigned int const width = graph->width;
+	unsigned int const height = graph->height;
+
+	while (path != path->parent)
+	{
+		CURSOR_UP(3 * (height - path->id / width - 1) + 2);
+		CURSOR_HORIZONTAL_ABSOLUTE(5 * (path->id % width + 1) - 2);
+		printf(ANSI_COLOR_GOLD"#"ANSI_COLOR_RESET);
+		CURSOR_HORIZONTAL_ABSOLUTE(-5 * (path->id % width + 1) + 2);
+		CURSOR_DOWN(3 * (height - path->id / width - 1) + 2);
+		path = path->parent;
+	}
+	CURSOR_UP(3 * (height - path->id / width - 1) + 2);
+	CURSOR_HORIZONTAL_ABSOLUTE(5 * (path->id % width + 1) - 2);
+	printf(ANSI_COLOR_GOLD"#"ANSI_COLOR_RESET);
+	CURSOR_HORIZONTAL_ABSOLUTE(-5 * (path->id % width + 1) + 2);
+	CURSOR_DOWN(3 * (height - path->id / width - 1) + 2);
+}
+
+int main()
+{
+	struct graph *graph = init_graph(WIDTH, HEIGHT);
+
+	if (graph == NULL)
+	{
+		print_failure("Failed to create 10x10 maze.\n");
+		return EXIT_FAILURE;
+	}
+
+	generate_maze(graph);
+	display_maze(graph);
+
+	struct vertex *path = find_exit(graph, 0);
+	display_path(graph, path);
+
+	free_graph(graph);
+
+	return EXIT_SUCCESS;
+}
\ No newline at end of file
diff --git a/src/test_valeurs_incorrect.c b/src/test_valeurs_incorrect.c
new file mode 100644
index 0000000000000000000000000000000000000000..3b7bf8a3b11e17377e52747a86f0c5fb50caf897
--- /dev/null
+++ b/src/test_valeurs_incorrect.c
@@ -0,0 +1,50 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <maze.h>
+#include <test.h>
+#define TYPE_TEST(x) _Generic((x), \
+    int *: "int *", \
+    void *: "void *")
+
+
+void test_valeurs_negative() {
+    struct vertex *graph = init_graph(-2, 10, 0);
+    assert(graph == NULL); // the graph must be NULL if the width is negative
+
+    if (graph == NULL) {
+        print_success("Success : The graph is NULL for a width negative.\n");
+    } else {
+        print_failure("Failure : The graph is not NULL for a width negative.\n");
+    }
+
+    graph = init_graph(10, -2, 0);
+    assert(graph == NULL);  // the graph must be NULL if the height is negative
+
+    if (graph == NULL) {
+        print_success("Success : The graph is NULL for a height negative.\n");
+    } else {
+        print_failure("Failure : The graph is not NULL for a height negative.\n");
+    }
+
+}
+
+void test_types_valeurs(void *width, void *height) {
+    if (strcmp(TYPE_TEST(width) ,"int *") == 0) {
+        print_success("Success : The width is an integer.\n");
+    } else {
+        print_failure("Failure : The width is not an integer.\n");
+    }
+    if (strcmp(TYPE_TEST(height) ,"int *") == 0) {
+        print_success("Success : The height is an integer.\n");
+    } else {
+        print_failure("Failure : The height is not an integer.\n");
+    }
+}
+
+int main(int argc, char const *argv[]) {
+    test_valeurs_negative();
+    test_types_valeurs(&argv[1],&argv[2]);
+    return 0;
+}
\ No newline at end of file
diff --git a/src/test_valeurs_limites.c b/src/test_valeurs_limites.c
new file mode 100644
index 0000000000000000000000000000000000000000..0512b6cc889747569310a02eeea142b428a4a28f
--- /dev/null
+++ b/src/test_valeurs_limites.c
@@ -0,0 +1,249 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <assert.h>
+
+
+struct vertex {
+    int id;
+    int is_start;
+    int is_end;
+    struct vertex *top;
+    struct vertex *bottom;
+    struct vertex *left;
+    struct vertex *right;
+};
+
+int random_int(int min, int max, int const step)
+{
+	if (min > max)
+	{
+		int tmp = min;
+		min = max;
+		max = tmp;
+	}
+
+	int k = (max - min) / step;
+
+	return min + step * (rand() % (k+1));
+}
+
+struct vertex *init_graph(int const width, int const height, int id_start)
+{
+	int const size = width * height;
+
+	if (width < 1 || height < 1 || id_start < 0 || id_start >= size)
+		return NULL;
+
+	struct vertex *graph = (struct vertex *) calloc(size, sizeof(struct vertex));
+
+	if (graph == NULL)
+		return NULL;
+
+	for (int i = 0; i < size; i++)
+	{
+		graph[i].id = i;
+		graph[i].is_start = (i == id_start) ? 1 : 0;
+		graph[i].is_end = (i == size-1) ? 1 : 0;
+
+		if (i < width) // If it is a top cell of the maze
+		{
+			graph[i].top = NULL;
+			graph[i].bottom = &graph[i+width];
+			graph[i].left = (i == 0) ? NULL : &graph[i-1];
+			graph[i].right = (i == width-1) ? NULL : &graph[i+1];
+		}
+		else if (i % width == 0) // Else if it is a left cell of the maze
+		{
+			graph[i].top = &graph[i-width];
+			graph[i].bottom = (i == size - width) ? NULL : &graph[i+width];
+			graph[i].left = NULL;
+			graph[i].right = &graph[i+1];
+		}
+		else if (i % width == width-1) // Else if it is a right cell of the maze
+		{
+			graph[i].top = &graph[i-width];
+			graph[i].bottom = (i == size - 1) ? NULL : &graph[i+width];
+			graph[i].left = &graph[i-1];
+			graph[i].right = NULL;
+		}
+		else if (i >= size - width) // Else if it is a bottom cell of the maze
+		{
+			graph[i].top = &graph[i-width];
+			graph[i].bottom = NULL;
+			graph[i].left = &graph[i-1];
+			graph[i].right = &graph[i+1];
+		}
+		else // Else it is a cell inside of the maze (not an edge)
+		{
+			graph[i].top = &graph[i-width];
+			graph[i].bottom = &graph[i+width];
+			graph[i].left = &graph[i-1];
+			graph[i].right = &graph[i+1];
+		}
+	}
+
+	return graph;
+}
+
+void add_wall(struct vertex *const graph, int const i, int const j,
+	int const width, int const size)
+{
+	if (graph == NULL || i < 0 || j < 0 || i >= size || j >= size)
+		return;
+
+	// If graph[j] is at the right of graph[i]
+	// and graph[i] is not a right border cell
+	if (i + 1 == j && i % width != width-1)
+	{
+		graph[i].right = NULL;
+		graph[j].left = NULL;
+	}
+	// Else if graph[j] is at the bottom of graph[i]
+	else if (i + width == j)
+	{
+		graph[i].bottom = NULL;
+		graph[j].top = NULL;
+	}
+	// Else if graph[j] is at the left of graph[i]
+	// and graph[i] is not a left border cell
+	else if (i - 1 == j && i % width != 0)
+	{
+		graph[i].left = NULL;
+		graph[j].right = NULL;
+	}
+	// Else if graph[j] is at the top of graph[i]
+	else if (i - width == j)
+	{
+		graph[i].top = NULL;
+		graph[j].bottom = NULL;
+	}
+
+	// Else graph[i] and graph[j] are not connected,
+	// so no wall can separate them.
+}
+
+void generate_maze_aux(struct vertex *const graph, int const width, int const height,
+	int const first_vertex_id, int const cur_width, int const cur_height)
+{
+	if (cur_width == 1 || cur_height == 1)
+		return;
+
+	int const size = width * height;
+
+	if (cur_width >= cur_height)
+	{
+		int const r_vertex_id = random_int(first_vertex_id, first_vertex_id + cur_width - 2, 1);
+		int const r_door_id = random_int(r_vertex_id, r_vertex_id + width * (cur_height - 1), width);
+		int vertex_i;
+
+		for (int i = 0; i < cur_height; i++)
+		{
+			vertex_i = r_vertex_id + width * i;
+
+			if (vertex_i != r_door_id)
+				add_wall(graph, vertex_i, vertex_i + 1, width, size);
+		}
+
+		int const left_width = r_vertex_id - first_vertex_id + 1;
+		generate_maze_aux(graph, width, height, first_vertex_id, left_width, cur_height);
+		generate_maze_aux(graph, width, height, r_vertex_id + 1, cur_width - left_width, cur_height);
+	}
+	else
+	{
+		int const r_vertex_id = random_int(first_vertex_id,
+									width * (cur_height - 1 + first_vertex_id / width) - 1, width);
+		int const r_door_id = random_int(r_vertex_id, r_vertex_id + cur_width - 1, 1);
+		int vertex_i;
+
+		for (int i = 0; i < cur_width; i++)
+		{
+			vertex_i = r_vertex_id + i;
+
+			if (vertex_i != r_door_id)
+				add_wall(graph, vertex_i, vertex_i + width, width, size);
+		}
+
+		int const top_height = (r_vertex_id - first_vertex_id) / width + 1;
+		generate_maze_aux(graph, width, height, first_vertex_id, cur_width, top_height);
+		generate_maze_aux(graph, width, height, r_vertex_id + width,
+			cur_width, cur_height - top_height);
+	}
+}
+
+void generate_maze(struct vertex *const graph, int const width, int const height)
+{
+	generate_maze_aux(graph, width, height, 0, width, height);
+}
+
+void free_graph(struct vertex *graph)
+{
+	if (graph != NULL)
+		free(graph);
+}
+
+
+//-------------------Tests---------------------------------------------//
+
+
+
+void test_graph_with_zero_size() {
+    struct vertex *graph = init_graph(0, 0, 0);
+    assert(graph == NULL);  // Le graphe doit être NULL si la largeur ou la hauteur est 0
+
+    if (graph == NULL) {
+        printf("Test réussi : le graphe est vide pour une taille de 0x0.\n");
+    } else {
+        printf("Test échoué : le graphe n'est pas vide pour une taille de 0x0.\n");
+    }
+}
+
+
+
+
+
+
+
+void test_large_graph_performance() {
+    int width = 10000;  // Largeur du labyrinthe
+    int height = 10000; // Hauteur du labyrinthe
+    printf("Test avec un labyrinthe de %dx%d\n", width, height);
+
+    // Mesurer le temps de démarrage
+    clock_t start_time = clock();
+
+    // Initialiser le graphe
+    struct vertex *graph = init_graph(width, height, 0);
+    assert(graph != NULL);  // Vérifier que le graphe a bien été créé
+
+    // Générer le labyrinthe
+    generate_maze(graph, width, height);
+    printf("Labyrinthe généré avec succès\n");
+
+    // Mesurer le temps de fin
+    clock_t end_time = clock();
+
+    // Calculer la durée en secondes
+    double time_spent = (double)(end_time - start_time) / CLOCKS_PER_SEC;
+
+    // Libérer la mémoire du graphe
+    free_graph(graph);
+
+    // Afficher le temps d'exécution
+    printf("Test de performance réussi pour un labyrinthe de %dx%d.\n", width, height);
+    printf("Temps d'exécution : %f secondes\n", time_spent);
+}
+
+
+
+
+
+int main() {
+    // Exécuter le test pour le graphe vide 
+   // test_graph_with_zero_size();
+   
+
+     // Exécuter le test de performance
+     //test_large_graph_performance();
+    return 0;
+}
diff --git a/src/test_voisin.c b/src/test_voisin.c
new file mode 100644
index 0000000000000000000000000000000000000000..bafaaefae839f32dd34d83839b4c1dbd2a6c40ec
--- /dev/null
+++ b/src/test_voisin.c
@@ -0,0 +1,300 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+
+struct vertex {
+    int id;
+    int is_start;
+    int is_end;
+    struct vertex *top;
+    struct vertex *bottom;
+    struct vertex *left;
+    struct vertex *right;
+};
+
+int random_int(int min, int max, int const step)
+{
+	if (min > max)
+	{
+		int tmp = min;
+		min = max;
+		max = tmp;
+	}
+
+	int k = (max - min) / step;
+
+	return min + step * (rand() % (k+1));
+}
+
+struct vertex *init_graph(int const width, int const height, int id_start)
+{
+	int const size = width * height;
+
+	if (width < 1 || height < 1 || id_start < 0 || id_start >= size)
+		return NULL;
+
+	struct vertex *graph = (struct vertex *) calloc(size, sizeof(struct vertex));
+
+	if (graph == NULL)
+		return NULL;
+
+	for (int i = 0; i < size; i++)
+	{
+		graph[i].id = i;
+		graph[i].is_start = (i == id_start) ? 1 : 0;
+		graph[i].is_end = (i == size-1) ? 1 : 0;
+
+		if (i < width) // If it is a top cell of the maze
+		{
+			graph[i].top = NULL;
+			graph[i].bottom = &graph[i+width];
+			graph[i].left = (i == 0) ? NULL : &graph[i-1];
+			graph[i].right = (i == width-1) ? NULL : &graph[i+1];
+		}
+		else if (i % width == 0) // Else if it is a left cell of the maze
+		{
+			graph[i].top = &graph[i-width];
+			graph[i].bottom = (i == size - width) ? NULL : &graph[i+width];
+			graph[i].left = NULL;
+			graph[i].right = &graph[i+1];
+		}
+		else if (i % width == width-1) // Else if it is a right cell of the maze
+		{
+			graph[i].top = &graph[i-width];
+			graph[i].bottom = (i == size - 1) ? NULL : &graph[i+width];
+			graph[i].left = &graph[i-1];
+			graph[i].right = NULL;
+		}
+		else if (i >= size - width) // Else if it is a bottom cell of the maze
+		{
+			graph[i].top = &graph[i-width];
+			graph[i].bottom = NULL;
+			graph[i].left = &graph[i-1];
+			graph[i].right = &graph[i+1];
+		}
+		else // Else it is a cell inside of the maze (not an edge)
+		{
+			graph[i].top = &graph[i-width];
+			graph[i].bottom = &graph[i+width];
+			graph[i].left = &graph[i-1];
+			graph[i].right = &graph[i+1];
+		}
+	}
+
+	return graph;
+}
+
+void add_wall(struct vertex *const graph, int const i, int const j,
+	int const width, int const size)
+{
+	if (graph == NULL || i < 0 || j < 0 || i >= size || j >= size)
+		return;
+
+	// If graph[j] is at the right of graph[i]
+	// and graph[i] is not a right border cell
+	if (i + 1 == j && i % width != width-1)
+	{
+		graph[i].right = NULL;
+		graph[j].left = NULL;
+	}
+	// Else if graph[j] is at the bottom of graph[i]
+	else if (i + width == j)
+	{
+		graph[i].bottom = NULL;
+		graph[j].top = NULL;
+	}
+	// Else if graph[j] is at the left of graph[i]
+	// and graph[i] is not a left border cell
+	else if (i - 1 == j && i % width != 0)
+	{
+		graph[i].left = NULL;
+		graph[j].right = NULL;
+	}
+	// Else if graph[j] is at the top of graph[i]
+	else if (i - width == j)
+	{
+		graph[i].top = NULL;
+		graph[j].bottom = NULL;
+	}
+
+	// Else graph[i] and graph[j] are not connected,
+	// so no wall can separate them.
+}
+
+void generate_maze_aux(struct vertex *const graph, int const width, int const height,
+	int const first_vertex_id, int const cur_width, int const cur_height)
+{
+	if (cur_width == 1 || cur_height == 1)
+		return;
+
+	int const size = width * height;
+
+	if (cur_width >= cur_height)
+	{
+		int const r_vertex_id = random_int(first_vertex_id, first_vertex_id + cur_width - 2, 1);
+		int const r_door_id = random_int(r_vertex_id, r_vertex_id + width * (cur_height - 1), width);
+		int vertex_i;
+
+		for (int i = 0; i < cur_height; i++)
+		{
+			vertex_i = r_vertex_id + width * i;
+
+			if (vertex_i != r_door_id)
+				add_wall(graph, vertex_i, vertex_i + 1, width, size);
+		}
+
+		int const left_width = r_vertex_id - first_vertex_id + 1;
+		generate_maze_aux(graph, width, height, first_vertex_id, left_width, cur_height);
+		generate_maze_aux(graph, width, height, r_vertex_id + 1, cur_width - left_width, cur_height);
+	}
+	else
+	{
+		int const r_vertex_id = random_int(first_vertex_id,
+									width * (cur_height - 1 + first_vertex_id / width) - 1, width);
+		int const r_door_id = random_int(r_vertex_id, r_vertex_id + cur_width - 1, 1);
+		int vertex_i;
+
+		for (int i = 0; i < cur_width; i++)
+		{
+			vertex_i = r_vertex_id + i;
+
+			if (vertex_i != r_door_id)
+				add_wall(graph, vertex_i, vertex_i + width, width, size);
+		}
+
+		int const top_height = (r_vertex_id - first_vertex_id) / width + 1;
+		generate_maze_aux(graph, width, height, first_vertex_id, cur_width, top_height);
+		generate_maze_aux(graph, width, height, r_vertex_id + width,
+			cur_width, cur_height - top_height);
+	}
+}
+
+void generate_maze(struct vertex *const graph, int const width, int const height)
+{
+	generate_maze_aux(graph, width, height, 0, width, height);
+}
+
+void free_graph(struct vertex *graph)
+{
+	if (graph != NULL)
+		free(graph);
+}
+
+//----------------------- Test ------------------------------ */
+int test_graph_connections(struct vertex *const graph, int const width, int const height)
+{
+    if (graph == NULL)
+    {
+        printf("Graph est nul\n");
+        return 0;
+    }
+
+    int const size = width * height;
+
+    for (int i = 0; i < size; i++)
+    {
+        struct vertex *v = &graph[i];
+
+        // Vérification des voisins gauche/droite
+        if (v->right)
+        {
+            if (v->right->left != v)
+            {
+                printf("Error: Vertex %d's right neighbor does not point back.\n", v->id);
+                return 0;
+            }
+        }
+        if (v->left)
+        {
+            if (v->left->right != v)
+            {
+                printf("Error: Vertex %d's left neighbor does not point back.\n", v->id);
+                return 0;
+            }
+        }
+
+        // Vérification des voisins haut/bas
+        if (v->top)
+        {
+            if (v->top->bottom != v)
+            {
+                printf("Error: Vertex %d's top neighbor does not point back.\n", v->id);
+                return 0;
+            }
+        }
+        if (v->bottom)
+        {
+            if (v->bottom->top != v)
+            {
+                printf("Error: Vertex %d's bottom neighbor does not point back.\n", v->id);
+                return 0;
+            }
+        }
+    }
+
+    // Si tout est correct, afficher les connexions de chaque vertex
+    printf("Il n'y a pas d'erreur au niveaux de la connexions des voisin de chaque case voila\n");
+    
+    for (int i = 0; i < size; i++)
+    {
+        struct vertex *v = &graph[i];
+        printf("\nVertex %d: \n", v->id+1);
+
+        if (v->top)
+            printf("Top: %d, \n", v->top->id+1);
+        else
+            printf("Top: NULL, \n");
+
+        if (v->bottom)
+            printf("Bottom: %d, \n", v->bottom->id+1);
+        else
+            printf("Bottom: NULL, \n");
+
+        if (v->left)
+            printf("Left: %d, \n", v->left->id+1);
+        else
+            printf("Left: NULL, \n");
+
+        if (v->right)
+            printf("Right: %d\n", v->right->id+1);
+        else
+            printf("Right: NULL\n");
+    }
+
+    return 1; // Succès
+}
+
+
+int main()
+{
+    // Dimensions du labyrinthe
+    int width = 5;
+    int height = 4;
+
+    // Initialiser le générateur de nombres aléatoires
+    srand(time(NULL));
+
+    // Générer le graphe
+    struct vertex *graph = init_graph(width, height, 0);
+
+    if (graph == NULL)
+    {
+        printf("Erreur generation du graphe\n");
+        return EXIT_FAILURE;
+    }
+
+    // Tester les connexions avant la génération du labyrinthe (sans murs)
+    printf("Teste de la connexion des graphe avant le placement des murs\n");
+    test_graph_connections(graph, width, height);
+
+    // Générer le labyrinthe (ce qui place les murs)
+    generate_maze(graph, width, height);
+
+    printf("\nTest de la connexion des graphe après le placement des murs\n");
+    test_graph_connections(graph, width, height);
+
+    // Libérer la mémoire allouée au graphe
+    free_graph(graph);
+
+    return EXIT_SUCCESS;
+}
\ No newline at end of file
diff --git a/src/test_walls_have_a_door.c b/src/test_walls_have_a_door.c
new file mode 100644
index 0000000000000000000000000000000000000000..2968d3fe918f7b9885a3b22b84d0ef99d71f3bab
--- /dev/null
+++ b/src/test_walls_have_a_door.c
@@ -0,0 +1,105 @@
+#define generate_maze_aux(graph, first_vertex_id, cur_width, cur_height) \
+		test_generate_maze_aux(graph, first_vertex_id, cur_width, cur_height)
+#include "maze.h"
+#undef generate_maze_aux
+
+#include "test.h"
+
+#define WIDTH 1000
+#define HEIGHT 1000
+
+unsigned long int nb_walls = 0;
+unsigned long int nb_doors = 0;
+
+/*
+ * Postconditions: - nb_walls is incremented by one each time a full wall has been created.
+ *                 - nb_doors is incremented by one each time a door is left in a full wall.
+ */
+void test_generate_maze_aux(struct graph *const graph, int const first_vertex_id,
+	int const cur_width, int const cur_height)
+{
+	if (cur_width == 1 || cur_height == 1)
+		return;
+
+	unsigned int const width = graph->width;
+
+	if (cur_width >= cur_height)
+	{
+		int const r_vertex_id = random_int(first_vertex_id, first_vertex_id + cur_width - 2, 1);
+		int const r_door_id = random_int(r_vertex_id, r_vertex_id + width * (cur_height - 1), width);
+		int vertex_i;
+
+		for (int i = 0; i < cur_height; i++)
+		{
+			vertex_i = r_vertex_id + width * i;
+
+			if (vertex_i != r_door_id)
+				add_wall(graph, vertex_i, vertex_i + 1);
+			else
+				nb_doors++;
+		}
+		nb_walls++;
+
+		int const left_width = r_vertex_id - first_vertex_id + 1;
+		test_generate_maze_aux(graph, first_vertex_id, left_width, cur_height);
+		test_generate_maze_aux(graph, r_vertex_id + 1, cur_width - left_width, cur_height);
+	}
+	else
+	{
+		int const r_vertex_id = random_int(first_vertex_id,
+									width * (cur_height - 1 + first_vertex_id / width) - 1, width);
+		int const r_door_id = random_int(r_vertex_id, r_vertex_id + cur_width - 1, 1);
+		int vertex_i;
+
+		for (int i = 0; i < cur_width; i++)
+		{
+			vertex_i = r_vertex_id + i;
+
+			if (vertex_i != r_door_id)
+				add_wall(graph, vertex_i, vertex_i + width);
+			else
+				nb_doors++;
+		}
+		nb_walls++;
+
+		int const top_height = (r_vertex_id - first_vertex_id) / width + 1;
+		test_generate_maze_aux(graph, first_vertex_id, cur_width, top_height);
+		test_generate_maze_aux(graph, r_vertex_id + width, cur_width, cur_height - top_height);
+	}
+}
+
+/*
+ * Preconditions: None.
+ * Postconditions: graph represents a maze randomly generated, or NULL.
+ *
+ * Returns 1 if each wall has a door. Otherwise, it returns 0.
+ */
+int test_walls_have_a_door(struct graph *const graph)
+{
+	generate_maze(graph);
+
+	return nb_walls == nb_doors;
+}
+
+int main()
+{
+	struct graph *graph = init_graph(WIDTH, HEIGHT);
+
+	if (graph == NULL)
+	{
+		print_failure("Failed to create a 1000x1000 maze.\n");
+		return EXIT_FAILURE;
+	}
+
+	if (!test_walls_have_a_door(graph))
+	{
+		print_failure("Not all walls have a door. The maze may not be connected.\n");
+		return EXIT_FAILURE;
+	}
+
+	print_success("All walls have a door. The maze is connected.\n");
+
+	free_graph(graph);
+
+	return 0;
+}
\ No newline at end of file
diff --git a/test.txt b/test.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b2ae05ca001c2bc9e563a75b86e2ca1552814de2
--- /dev/null
+++ b/test.txt
@@ -0,0 +1,5706 @@
+SIZE;TIME
+1;0.000057
+4;0.000261
+9;0.000723
+16;0.000705
+25;0.001140
+36;0.000701
+49;0.004642
+64;0.004831
+81;0.008747
+100;0.004094
+121;0.007021
+144;0.007966
+169;0.009001
+196;0.017224
+225;0.008837
+256;0.009724
+289;0.013432
+324;0.015471
+361;0.014910
+400;0.014420
+441;0.021377
+484;0.042799
+529;0.023462
+576;0.025437
+625;0.033229
+676;0.037423
+729;0.039682
+784;0.024160
+841;0.041768
+900;0.043975
+961;0.035832
+1024;0.058825
+1089;0.029051
+1156;0.052121
+1225;0.058685
+1296;0.069786
+1369;0.075058
+1444;0.086888
+1521;0.069448
+1600;0.075705
+1681;0.079035
+1764;0.098644
+1849;0.030043
+1936;0.062580
+2025;0.080969
+2116;0.156658
+2209;0.096887
+2304;0.135420
+2401;0.087220
+2500;0.029821
+2601;0.121319
+2704;0.111468
+2809;0.193552
+2916;0.140521
+3025;0.114913
+3136;0.139745
+3249;0.171579
+3364;0.197016
+3481;0.171275
+3600;0.214059
+3721;0.130810
+3844;0.283666
+3969;0.211043
+4096;0.162975
+4225;0.185567
+4356;0.229315
+4489;0.204922
+4624;0.183213
+4761;0.289181
+4900;0.136053
+5041;0.268178
+5184;0.239546
+5329;0.034182
+5476;0.227969
+5625;0.366518
+5776;0.247030
+5929;0.224528
+6084;0.238982
+6241;0.313774
+6400;0.295075
+6561;0.401986
+6724;0.244695
+6889;0.279886
+7056;0.166790
+7225;0.367972
+7396;0.346829
+7569;0.258398
+7744;0.371802
+7921;0.444993
+8100;0.479054
+8281;0.280693
+8464;0.638906
+8649;0.442974
+8836;0.219680
+9025;0.502828
+9216;0.489343
+9409;0.274262
+9604;0.422267
+9801;0.473968
+10000;0.334681
+10201;67.306688
+10404;0.519575
+10609;0.525995
+10816;0.576911
+11025;0.527416
+11236;0.670669
+11449;0.557768
+11664;0.598082
+11881;0.574549
+12100;0.770830
+12321;0.595117
+12544;0.654481
+12769;1.023286
+12996;0.541804
+13225;0.519711
+13456;0.593851
+13689;0.635436
+13924;0.510996
+14161;0.728440
+14400;0.612412
+14641;0.810230
+14884;0.818363
+15129;0.684907
+15376;0.896676
+15625;0.730243
+15876;0.454911
+16129;0.682805
+16384;1.044317
+16641;1.094069
+16900;0.840078
+17161;0.629771
+17424;0.534779
+17689;0.957901
+17956;0.770906
+18225;1.014454
+18496;0.964952
+18769;0.984576
+19044;0.801946
+19321;67.514571
+19600;1.328033
+19881;0.764945
+20164;1.144320
+20449;1.014444
+20736;0.979181
+21025;1.007327
+21316;0.966778
+21609;0.865373
+21904;1.243044
+22201;1.437374
+22500;1.469777
+22801;1.388748
+23104;1.258226
+23409;1.338397
+23716;1.073979
+24025;1.242464
+24336;1.178061
+24649;1.539004
+24964;1.307997
+25281;1.240312
+25600;1.561069
+25921;0.855145
+26244;1.215148
+26569;1.513106
+26896;1.160261
+27225;1.275680
+27556;1.583214
+27889;1.278441
+28224;1.685615
+28561;0.997573
+28900;1.330882
+29241;1.414483
+29584;1.691452
+29929;1.564674
+30276;1.682451
+30625;1.170080
+30976;1.618014
+31329;1.859370
+31684;1.858346
+32041;1.422655
+32400;2.045256
+32761;67.191450
+33124;1.948202
+33489;2.110512
+33856;1.800800
+34225;2.367563
+34596;0.996536
+34969;1.349956
+35344;2.350055
+35721;2.043370
+36100;1.837787
+36481;1.988224
+36864;1.428888
+37249;1.962129
+37636;2.139620
+38025;1.129479
+38416;0.900894
+38809;68.324260
+39204;1.900278
+39601;2.416700
+40000;2.779766
+40401;1.796051
+40804;1.712548
+41209;1.801494
+41616;2.735251
+42025;2.037084
+42436;2.059419
+42849;1.368458
+43264;2.864318
+43681;2.188942
+44100;1.374595
+44521;2.211705
+44944;2.457371
+45369;2.632993
+45796;2.856152
+46225;2.532354
+46656;2.857300
+47089;2.349091
+47524;2.379809
+47961;3.170046
+48400;2.130516
+48841;69.405396
+49284;2.221665
+49729;2.290586
+50176;1.348991
+50625;2.835311
+51076;1.987031
+51529;1.666817
+51984;3.281310
+52441;1.860517
+52900;2.915166
+53361;3.524913
+53824;2.787266
+54289;70.062504
+54756;1.991756
+55225;2.333709
+55696;2.929037
+56169;3.259588
+56644;3.379935
+57121;3.611682
+57600;2.741419
+58081;3.257972
+58564;69.395659
+59049;4.069730
+59536;2.835127
+60025;4.063061
+60516;2.695411
+61009;4.126020
+61504;4.009487
+62001;4.464455
+62500;68.421049
+63001;4.449028
+63504;4.420913
+64009;3.451257
+64516;3.791789
+65025;4.310952
+65536;4.909057
+66049;71.331283
+66564;4.494273
+67081;5.028849
+67600;4.686780
+68121;4.284996
+68644;2.810721
+69169;3.748441
+69696;4.745972
+70225;4.736814
+70756;3.073643
+71289;5.531241
+71824;5.410865
+72361;71.885924
+72900;5.726869
+73441;2.754379
+73984;2.552549
+74529;4.710378
+75076;2.400763
+75625;5.724390
+76176;71.103655
+76729;5.970202
+77284;6.715813
+77841;2.705770
+78400;4.112519
+78961;2.021328
+79524;70.729291
+80089;6.525460
+80656;6.858063
+81225;5.044120
+81796;5.201336
+82369;73.037266
+82944;3.652560
+83521;4.782309
+84100;6.287157
+84681;2.797526
+85264;5.673158
+85849;7.177051
+86436;5.459106
+87025;4.697691
+87616;5.133518
+88209;3.431652
+88804;72.960912
+89401;5.555459
+90000;8.142196
+90601;4.824280
+91204;6.613004
+91809;7.615597
+92416;7.430477
+93025;6.402757
+93636;4.384784
+94249;69.416078
+94864;7.438224
+95481;7.980279
+96100;2.573534
+96721;74.745027
+97344;6.183827
+97969;8.418548
+98596;8.584914
+99225;74.469401
+99856;5.176895
+100489;5.133441
+101124;4.281680
+101761;75.267703
+102400;8.459609
+103041;8.316761
+103684;6.959342
+104329;8.080148
+104976;7.138672
+105625;5.612758
+106276;9.523723
+106929;75.494862
+107584;9.745065
+108241;8.618391
+108900;75.436796
+109561;8.135679
+110224;9.724437
+110889;70.237524
+111556;9.168495
+112225;9.530563
+112896;76.345177
+113569;9.544727
+114244;2.202387
+114921;9.141755
+115600;75.673529
+116281;8.578132
+116964;8.001138
+117649;75.323152
+118336;7.371838
+119025;85.037209
+119716;7.372377
+120409;99.158735
+121104;168.738650
+121801;97.108067
+122500;41.651070
+123201;174.990087
+123904;88.958486
+124609;11.854342
+125316;79.407471
+126025;12.151547
+126736;78.906554
+127449;12.134187
+128164;8.678655
+128881;79.529849
+129600;13.398374
+130321;76.407437
+131044;12.287401
+131769;76.937602
+132496;9.413124
+133225;11.122756
+133956;73.137058
+134689;12.309205
+135424;15.072774
+136161;76.955131
+136900;13.427615
+137641;78.669478
+138384;15.256903
+139129;79.908081
+139876;9.683805
+140625;79.598452
+141376;13.075395
+142129;9.351664
+142884;79.020382
+143641;11.054403
+144400;79.409844
+145161;6.076178
+145924;11.827173
+146689;77.069263
+147456;10.981647
+148225;13.767688
+148996;15.117909
+149769;72.730123
+150544;8.159003
+151321;9.134320
+152100;74.511609
+152881;6.785153
+153664;7.588622
+154449;7.635791
+155236;82.020716
+156025;14.911090
+156816;82.218548
+157609;11.161997
+158404;82.104682
+159201;13.066008
+160000;11.809519
+160801;82.889271
+161604;12.985583
+162409;6.560271
+163216;82.805520
+164025;13.141521
+164836;81.203651
+165649;84.398188
+166464;19.358819
+167281;80.138950
+168100;10.871665
+168921;85.707422
+169744;19.257440
+170569;19.371124
+171396;85.336221
+172225;16.604783
+173056;78.381494
+173889;84.312028
+174724;12.858988
+175561;84.583996
+176400;15.874853
+177241;83.494211
+178084;10.167987
+178929;82.010581
+179776;14.213815
+180625;82.027106
+181476;85.162737
+182329;11.266054
+183184;86.090448
+184041;19.136485
+184900;84.286377
+185761;84.989217
+186624;20.326400
+187489;79.077274
+188356;15.374235
+189225;85.197579
+190096;84.423243
+190969;12.643609
+191844;18.290633
+192721;12.544763
+193600;80.378401
+194481;16.713472
+195364;11.046693
+196249;12.827099
+197136;80.059927
+198025;13.161593
+198916;81.585919
+199809;7.874829
+200704;76.371347
+201601;14.045912
+202500;79.496864
+203401;10.370628
+204304;77.922418
+205209;18.307761
+206116;83.970217
+207025;18.966335
+207936;10.629783
+208849;83.837282
+209764;18.846764
+210681;85.338100
+211600;11.334073
+212521;80.661073
+213444;19.166589
+214369;19.143860
+215296;74.750756
+216225;20.247673
+217156;85.454451
+218089;83.269981
+219024;15.071941
+219961;85.197055
+220900;85.914550
+221841;13.260164
+222784;88.437507
+223729;86.938260
+224676;11.648629
+225625;83.921692
+226576;88.402731
+227529;17.478897
+228484;90.527172
+229441;90.230490
+230400;88.797778
+231361;89.710461
+232324;17.717315
+233289;78.970751
+234256;90.573586
+235225;213.831801
+236196;97.612452
+237169;167.436713
+238144;111.670860
+239121;201.868991
+240100;22.607945
+241081;93.686389
+242064;92.736570
+243049;101.733405
+244036;92.226057
+245025;86.592940
+246016;91.986480
+247009;80.957522
+248004;13.594799
+249001;90.108458
+250000;90.868097
+251001;18.695330
+252004;23.032162
+253009;87.740256
+254016;84.579955
+255025;91.982080
+256036;98.974426
+257049;88.740938
+258064;19.343470
+259081;25.785029
+260100;93.840571
+261121;87.752407
+262144;95.371109
+263169;90.870024
+264196;92.638729
+265225;89.776432
+266256;92.261817
+267289;90.655475
+268324;89.901635
+269361;29.117887
+270400;93.450678
+271441;19.355643
+272484;28.205572
+273529;85.713791
+274576;94.093443
+275625;94.026242
+276676;79.840060
+277729;19.939325
+278784;85.918433
+279841;81.703455
+280900;88.539413
+281961;21.451826
+283024;20.296899
+284089;90.942903
+285156;87.604644
+286225;83.180786
+287296;94.632080
+288369;21.568299
+289444;90.880983
+290521;95.819990
+291600;19.351996
+292681;18.576604
+293764;15.487973
+294849;88.357057
+295936;90.036239
+297025;18.135548
+298116;88.660356
+299209;21.198162
+300304;92.803908
+301401;95.221287
+302500;83.620598
+303601;88.398426
+304704;23.925918
+305809;94.883331
+306916;95.613062
+308025;84.353826
+309136;29.611715
+310249;97.656105
+311364;97.555380
+312481;91.194806
+313600;96.302424
+314721;93.067263
+315844;91.102484
+316969;92.185956
+318096;89.300969
+319225;93.384255
+320356;92.338969
+321489;20.109821
+322624;27.970719
+323761;23.441971
+324900;85.596816
+326041;98.192962
+327184;87.880767
+328329;82.368693
+329476;22.935845
+330625;159.511478
+331776;97.119302
+332929;98.714368
+334084;95.044089
+335241;97.331099
+336400;95.217392
+337561;97.695196
+338724;92.344481
+339889;29.364457
+341056;96.852750
+342225;30.032578
+343396;93.948963
+344569;98.943448
+345744;20.988593
+346921;30.029209
+348100;23.135987
+349281;92.055640
+350464;166.273406
+351649;97.050673
+352836;98.597148
+354025;101.454823
+355216;95.302514
+356409;164.073246
+357604;97.234539
+358801;93.693397
+360000;98.718343
+361201;95.282961
+362404;99.636566
+363609;87.679539
+364816;91.208718
+366025;94.431185
+367236;104.387741
+368449;98.961309
+369664;92.532396
+370881;18.392224
+372100;22.979572
+373321;165.379709
+374544;94.752841
+375769;98.942470
+376996;86.530789
+378225;100.435128
+379456;85.648887
+380689;100.550398
+381924;93.658019
+383161;30.927295
+384400;96.718167
+385641;87.248157
+386884;34.570295
+388129;97.494962
+389376;166.361672
+390625;100.682192
+391876;101.443997
+393129;88.334308
+394384;168.993798
+395641;103.504186
+396900;97.736085
+398161;96.531791
+399424;39.074747
+400689;91.817297
+401956;99.611839
+403225;29.073310
+404496;85.516309
+405769;100.650743
+407044;100.841459
+408321;99.994101
+409600;98.395559
+410881;91.391585
+412164;90.063019
+413449;35.999705
+414736;87.717711
+416025;103.464805
+417316;93.970993
+418609;28.235924
+419904;98.056875
+421201;87.963576
+422500;27.119989
+423801;172.003908
+425104;98.024634
+426409;30.200361
+427716;171.682335
+429025;107.030596
+430336;86.562618
+431649;99.508791
+432964;27.478591
+434281;25.158294
+435600;86.209333
+436921;100.627748
+438244;82.877023
+439569;102.998899
+440896;165.740777
+442225;28.743930
+443556;108.046641
+444889;173.576832
+446224;107.350489
+447561;170.292448
+448900;100.326786
+450241;174.682712
+451584;107.716125
+452929;96.154100
+454276;169.949239
+455625;92.604851
+456976;98.398771
+458329;93.310051
+459684;166.253284
+461041;112.234651
+462400;173.296885
+463761;112.554279
+465124;101.580366
+466489;104.665786
+467856;97.959160
+469225;97.854480
+470596;34.823391
+471969;106.180151
+473344;112.289846
+474721;172.895088
+476100;108.737568
+477481;93.470988
+478864;169.336417
+480249;35.594059
+481636;98.937904
+483025;162.026640
+484416;103.025776
+485809;36.132280
+487204;176.699698
+488601;111.932176
+490000;112.475276
+491401;174.639567
+492804;173.274927
+494209;103.619583
+495616;100.479835
+497025;113.476755
+498436;111.904396
+499849;179.010373
+501264;110.466244
+502681;97.462332
+504100;169.972203
+505521;101.133121
+506944;168.047130
+508369;117.330295
+509796;112.951217
+511225;170.752213
+512656;98.322712
+514089;26.160028
+515524;104.128798
+516961;171.374508
+518400;180.606991
+519841;96.306055
+521284;181.334693
+522729;105.848420
+524176;168.198124
+525625;174.882227
+527076;118.952430
+528529;105.855662
+529984;178.183321
+531441;48.243088
+532900;91.936703
+534361;111.296107
+535824;169.978537
+537289;109.912947
+538756;168.166171
+540225;102.604977
+541696;177.840626
+543169;182.322163
+544644;45.282464
+546121;32.318019
+547600;88.165786
+549081;103.664600
+550564;184.130589
+552049;173.730323
+553536;183.822110
+555025;113.027388
+556516;117.334993
+558009;121.148223
+559504;109.130709
+561001;104.368268
+562500;110.265194
+564001;180.452631
+565504;172.828819
+567009;113.355364
+568516;182.213741
+570025;105.503067
+571536;111.805355
+573049;50.541787
+574564;183.660586
+576081;175.954550
+577600;176.928683
+579121;101.311617
+580644;173.641923
+582169;181.456951
+583696;119.744717
+585225;123.750080
+586756;183.317528
+588289;180.207425
+589824;180.892275
+591361;106.065730
+592900;176.910393
+594441;178.113245
+595984;112.875820
+597529;108.080067
+599076;168.750043
+600625;187.634462
+602176;184.962609
+603729;189.829857
+605284;171.470444
+606841;111.216704
+608400;115.973131
+609961;174.107296
+611524;180.073663
+613089;171.443984
+614656;125.997671
+616225;103.843590
+617796;116.165854
+619369;99.594420
+620944;178.942441
+622521;106.989388
+624100;187.610602
+625681;189.160007
+627264;188.524816
+628849;182.962031
+630436;183.321593
+632025;251.544146
+633616;45.054327
+635209;102.271517
+636804;26.997432
+638401;178.119980
+640000;191.627858
+641601;115.321181
+643204;105.383625
+644809;116.997875
+646416;186.275835
+648025;251.109948
+649636;122.819667
+651249;41.751810
+652864;184.159558
+654481;24.105879
+656100;252.609675
+657721;124.917320
+659344;110.625851
+660969;170.014428
+662596;186.037019
+664225;181.150934
+665856;183.423617
+667489;194.309833
+669124;115.032396
+670761;421.127341
+672400;177.814282
+674041;133.004169
+675684;135.496985
+677329;118.602004
+678976;189.999725
+680625;196.798298
+682276;174.765623
+683929;183.043679
+685584;195.739023
+687241;189.370041
+688900;178.329307
+690561;104.459247
+692224;166.286517
+693889;191.570296
+695556;190.779016
+697225;256.663769
+698896;182.844362
+700569;118.284360
+702244;181.405774
+703921;181.299956
+705600;189.122194
+707281;181.969092
+708964;178.774842
+710649;126.112255
+712336;181.688445
+714025;192.579764
+715716;254.357778
+717409;193.185517
+719104;191.863134
+720801;180.501653
+722500;259.222164
+724201;191.845920
+725904;40.509788
+727609;189.396012
+729316;259.309539
+731025;199.794946
+732736;200.652046
+734449;172.511595
+736164;187.522141
+737881;175.236863
+739600;194.803149
+741321;118.120085
+743044;135.631653
+744769;191.762887
+746496;189.069849
+748225;189.903320
+749956;100.491648
+751689;135.392697
+753424;256.546039
+755161;189.807028
+756900;176.076805
+758641;185.015692
+760384;178.134023
+762129;187.797688
+763876;110.898439
+765625;178.401088
+767376;187.269466
+769129;184.181211
+770884;175.070817
+772641;259.588354
+774400;104.218538
+776161;190.476675
+777924;185.667801
+779689;191.666784
+781456;179.561488
+783225;101.663965
+784996;189.988617
+786769;265.935350
+788544;188.386509
+790321;203.209649
+792100;191.375511
+793881;259.488555
+795664;206.549630
+797449;100.938521
+799236;262.536089
+801025;125.086770
+802816;195.198033
+804609;116.960669
+806404;201.998058
+808201;190.448453
+810000;257.101605
+811801;99.887417
+813604;111.899572
+815409;202.094962
+817216;183.997112
+819025;201.796615
+820836;187.821164
+822649;266.728977
+824464;189.157010
+826281;258.622710
+828100;140.458048
+829921;201.279417
+831744;262.151561
+833569;189.898394
+835396;126.638345
+837225;193.539590
+839056;267.052868
+840889;198.971858
+842724;105.653604
+844561;256.667405
+846400;269.252241
+848241;133.840203
+850084;266.431011
+851929;265.100472
+853776;266.288936
+855625;190.761252
+857476;200.719271
+859329;137.376543
+861184;104.998639
+863041;189.891400
+864900;192.657027
+866761;265.968940
+868624;193.264307
+870489;270.212722
+872356;188.169646
+874225;147.703301
+876096;145.778612
+877969;337.215132
+879844;272.109161
+881721;270.169750
+883600;207.734975
+885481;332.259117
+887364;271.950155
+889249;205.302769
+891136;267.240131
+893025;271.510907
+894916;258.674469
+896809;271.164517
+898704;177.594527
+900601;199.410193
+902500;272.291924
+904401;195.083368
+906304;200.070368
+908209;260.334678
+910116;275.545584
+912025;264.045925
+913936;171.461575
+915849;268.379815
+917764;195.926439
+919681;180.541753
+921600;265.205093
+923521;186.989218
+925444;187.959544
+927369;195.266834
+929296;59.510472
+931225;278.023569
+933156;107.610425
+935089;110.725138
+937024;251.103051
+938961;186.805451
+940900;194.894795
+942841;257.304529
+944784;199.041594
+946729;273.553399
+948676;263.708558
+950625;178.595535
+952576;272.611463
+954529;212.667780
+956484;189.576416
+958441;257.929145
+960400;270.487676
+962361;260.647646
+964324;268.589818
+966289;114.045040
+968256;280.880766
+970225;212.707423
+972196;261.287119
+974169;127.503107
+976144;335.801132
+978121;213.181236
+980100;192.217086
+982081;197.007282
+984064;274.780586
+986049;186.486559
+988036;280.993100
+990025;117.016984
+992016;281.464580
+994009;272.826776
+996004;198.046046
+998001;201.032408
+1000000;205.352457
+1002001;119.214194
+1004004;176.029607
+1006009;201.571478
+1008016;263.077025
+1010025;358.162834
+1012036;220.754012
+1014049;345.640087
+1016064;269.912754
+1018081;268.519837
+1020100;265.661842
+1022121;260.835483
+1024144;182.949175
+1026169;382.320350
+1028196;350.612989
+1030225;186.679273
+1032256;229.925618
+1034289;346.114264
+1036324;209.633699
+1038361;343.049087
+1040400;222.753185
+1042441;336.105852
+1044484;224.288670
+1046529;206.094783
+1048576;192.980945
+1050625;277.240234
+1052676;191.960736
+1054729;286.223165
+1056784;179.969133
+1058841;283.160894
+1060900;113.402423
+1062961;340.313524
+1065024;282.471757
+1067089;417.984467
+1069156;190.859337
+1071225;413.926048
+1073296;349.124014
+1075369;215.553911
+1077444;117.325606
+1079521;361.715335
+1081600;362.073531
+1083681;352.629469
+1085764;343.986073
+1087849;286.479248
+1089936;703.586335
+1092025;486.926632
+1094116;436.120905
+1096209;287.669346
+1098304;509.409332
+1100401;169.657533
+1102500;349.236455
+1104601;267.880948
+1106704;503.474733
+1108809;292.138349
+1110916;299.236069
+1113025;364.517360
+1115136;355.106685
+1117249;419.614984
+1119364;346.759614
+1121481;146.212635
+1123600;280.721726
+1125721;369.140699
+1127844;424.672121
+1129969;346.827814
+1132096;265.215085
+1134225;225.414367
+1136356;226.812218
+1138489;278.915736
+1140624;402.329761
+1142761;183.892331
+1144900;348.229293
+1147041;361.531461
+1149184;429.650687
+1151329;366.857734
+1153476;277.317131
+1155625;429.474211
+1157776;262.832451
+1159929;288.805747
+1162084;213.264102
+1164241;224.732488
+1166400;379.276518
+1168561;269.169282
+1170724;256.794090
+1172889;205.167564
+1175056;208.833572
+1177225;356.549776
+1179396;270.784384
+1181569;244.775805
+1183744;277.215998
+1185921;352.802891
+1188100;354.989740
+1190281;272.361928
+1192464;299.700633
+1194649;435.773740
+1196836;363.176171
+1199025;267.795159
+1201216;298.518493
+1203409;281.568454
+1205604;264.655563
+1207801;277.766570
+1210000;358.596790
+1212201;206.839594
+1214404;431.352833
+1216609;174.212283
+1218816;218.985024
+1221025;346.820162
+1223236;343.665670
+1225449;426.088513
+1227664;263.582190
+1229881;357.418034
+1232100;270.184936
+1234321;424.905309
+1236544;365.414796
+1238769;421.862991
+1240996;170.139269
+1243225;362.708591
+1245456;269.779756
+1247689;295.788947
+1249924;369.518525
+1252161;272.376679
+1254400;280.728893
+1256641;278.193798
+1258884;348.485877
+1261129;348.646726
+1263376;436.791242
+1265625;371.397652
+1267876;287.168837
+1270129;347.278432
+1272384;358.681896
+1274641;421.894503
+1276900;195.238605
+1279161;366.233634
+1281424;433.654238
+1283689;340.420735
+1285956;444.748958
+1288225;274.039775
+1290496;349.117551
+1292769;420.747518
+1295044;227.838360
+1297321;309.323118
+1299600;356.138599
+1301881;270.192034
+1304164;207.054682
+1306449;300.880323
+1308736;279.130632
+1311025;345.103409
+1313316;363.503898
+1315609;267.318628
+1317904;264.590374
+1320201;282.348486
+1322500;348.470294
+1324801;493.860101
+1327104;220.627043
+1329409;257.468725
+1331716;284.798565
+1334025;300.164258
+1336336;419.251005
+1338649;274.799112
+1340964;417.878794
+1343281;285.809657
+1345600;230.290377
+1347921;284.324525
+1350244;282.102293
+1352569;290.610095
+1354896;352.352240
+1357225;370.336150
+1359556;200.264550
+1361889;273.765455
+1364224;421.949140
+1366561;350.143328
+1368900;243.499974
+1371241;358.948345
+1373584;209.927399
+1375929;278.028176
+1378276;296.618780
+1380625;270.693655
+1382976;429.903077
+1385329;504.151023
+1387684;422.986841
+1390041;278.760077
+1392400;369.505386
+1394761;276.876587
+1397124;354.588761
+1399489;272.608231
+1401856;348.633305
+1404225;431.634793
+1406596;435.038051
+1408969;288.178147
+1411344;364.903744
+1413721;360.577437
+1416100;433.371798
+1418481;344.689699
+1420864;239.260912
+1423249;432.938638
+1425636;207.350032
+1428025;133.862985
+1430416;299.637857
+1432809;367.738454
+1435204;296.720589
+1437601;101.833112
+1440000;310.755013
+1442401;338.385734
+1444804;345.550517
+1447209;425.787864
+1449616;221.379514
+1452025;199.922612
+1454436;358.627065
+1456849;387.530485
+1459264;278.854501
+1461681;383.741890
+1464100;494.899572
+1466521;434.406001
+1468944;487.981315
+1471369;364.767041
+1473796;426.705824
+1476225;416.792547
+1478656;292.456699
+1481089;359.149104
+1483524;492.178862
+1485961;368.494644
+1488400;298.240957
+1490841;426.410948
+1493284;433.295311
+1495729;369.970391
+1498176;362.567506
+1500625;372.219487
+1503076;362.417166
+1505529;435.636796
+1507984;369.130406
+1510441;432.037360
+1512900;433.769577
+1515361;223.656007
+1517824;296.281835
+1520289;361.655419
+1522756;430.382491
+1525225;250.145860
+1527696;374.251381
+1530169;349.168191
+1532644;423.948097
+1535121;305.687041
+1537600;202.327440
+1540081;430.001778
+1542564;198.955548
+1545049;208.953472
+1547536;437.328501
+1550025;445.419660
+1552516;715.551674
+1555009;411.867914
+1557504;355.111335
+1560001;432.009398
+1562500;205.579651
+1565001;431.741721
+1567504;462.681849
+1570009;670.629306
+1572516;579.627644
+1575025;458.113326
+1577536;467.383921
+1580049;432.502085
+1582564;582.773566
+1585081;524.044840
+1587600;460.640080
+1590121;411.763609
+1592644;390.444204
+1595169;571.575297
+1597696;583.865924
+1600225;447.202935
+1602756;577.627265
+1605289;566.194937
+1607824;429.873313
+1610361;629.963025
+1612900;461.899160
+1615441;389.977101
+1617984;386.052549
+1620529;591.498102
+1623076;338.947181
+1625625;577.128164
+1628176;585.657148
+1630729;505.563622
+1633284;343.057592
+1635841;347.649649
+1638400;494.179135
+1640961;584.559096
+1643524;567.113910
+1646089;529.072162
+1648656;526.818108
+1651225;574.883123
+1653796;633.681717
+1656369;516.404727
+1658944;75.155441
+1661521;504.537469
+1664100;575.123663
+1666681;483.031339
+1669264;638.422109
+1671849;586.237733
+1674436;528.739857
+1677025;638.428899
+1679616;642.353711
+1682209;632.833111
+1684804;594.358692
+1687401;191.336410
+1690000;531.062545
+1692601;578.885307
+1695204;521.081028
+1697809;237.046164
+1700416;506.065035
+1703025;496.510709
+1705636;528.056680
+1708249;511.463363
+1710864;588.325326
+1713481;697.103461
+1716100;515.710833
+1718721;541.931518
+1721344;441.497764
+1723969;643.136756
+1726596;586.783192
+1729225;538.192456
+1731856;455.589858
+1734489;309.791280
+1737124;338.334752
+1739761;510.227501
+1742400;465.583126
+1745041;589.254869
+1747684;435.327816
+1750329;535.605550
+1752976;423.842290
+1755625;639.613678
+1758276;515.066242
+1760929;481.669287
+1763584;435.198129
+1766241;543.006425
+1768900;432.978807
+1771561;588.868957
+1774224;357.704648
+1776889;478.028895
+1779556;509.844078
+1782225;458.703861
+1784896;647.845394
+1787569;499.941016
+1790244;642.221465
+1792921;589.751555
+1795600;523.171573
+1798281;531.338655
+1800964;450.817774
+1803649;528.161511
+1806336;581.998298
+1809025;541.825200
+1811716;591.476931
+1814409;600.765747
+1817104;210.579683
+1819801;462.266983
+1822500;578.099388
+1825201;456.644828
+1827904;595.320045
+1830609;420.344514
+1833316;570.502787
+1836025;289.264640
+1838736;364.869897
+1841449;596.399886
+1844164;642.552405
+1846881;430.290178
+1849600;603.103273
+1852321;706.924405
+1855044;647.150118
+1857769;456.131259
+1860496;530.393358
+1863225;596.651383
+1865956;636.092048
+1868689;591.799505
+1871424;588.969401
+1874161;451.396834
+1876900;576.207665
+1879641;562.825589
+1882384;468.064752
+1885129;441.529420
+1887876;415.131943
+1890625;654.134393
+1893376;594.278615
+1896129;585.510613
+1898884;603.489571
+1901641;636.672400
+1904400;505.910374
+1907161;541.445416
+1909924;476.121290
+1912689;577.906415
+1915456;452.951823
+1918225;651.720932
+1920996;598.348465
+1923769;579.750593
+1926544;483.058080
+1929321;424.511541
+1932100;529.427191
+1934881;638.045389
+1937664;709.687338
+1940449;578.155054
+1943236;578.694119
+1946025;517.201340
+1948816;431.339661
+1951609;698.336190
+1954404;660.118991
+1957201;645.002355
+1960000;414.145995
+1962801;587.653528
+1965604;583.497967
+1968409;643.097359
+1971216;521.231696
+1974025;702.506517
+1976836;572.586328
+1979649;590.351863
+1982464;706.290221
+1985281;436.469884
+1988100;590.610889
+1990921;426.847310
+1993744;655.051130
+1996569;569.612276
+1999396;651.012194
+2002225;707.962798
+2005056;641.274506
+2007889;510.225531
+2010724;564.999816
+2013561;395.504004
+2016400;655.915723
+2019241;515.156476
+2022084;451.827966
+2024929;708.139340
+2027776;382.317447
+2030625;586.985233
+2033476;546.391861
+2036329;662.544216
+2039184;521.108640
+2042041;653.335713
+2044900;544.297920
+2047761;456.779422
+2050624;508.330352
+2053489;549.058614
+2056356;589.223985
+2059225;649.256949
+2062096;703.496148
+2064969;457.888392
+2067844;420.621738
+2070721;504.496443
+2073600;373.034074
+2076481;667.630609
+2079364;654.815231
+2082249;635.200394
+2085136;595.043549
+2088025;702.213708
+2090916;717.578322
+2093809;552.633200
+2096704;654.854194
+2099601;505.085801
+2102500;455.373986
+2105401;706.794205
+2108304;456.448574
+2111209;650.680488
+2114116;542.075368
+2117025;516.405469
+2119936;607.945510
+2122849;464.378738
+2125764;541.743424
+2128681;370.080317
+2131600;716.929634
+2134521;580.871927
+2137444;371.549372
+2140369;700.804891
+2143296;714.458867
+2146225;514.083043
+2149156;492.057228
+2152089;769.072957
+2155024;711.764541
+2157961;708.671457
+2160900;596.345401
+2163841;583.160234
+2166784;629.051609
+2169729;570.317376
+2172676;713.180520
+2175625;512.551400
+2178576;524.673202
+2181529;606.904481
+2184484;578.144450
+2187441;714.034809
+2190400;615.056825
+2193361;635.080204
+2196324;661.850593
+2199289;766.103648
+2202256;589.613070
+2205225;705.923383
+2208196;479.919670
+2211169;591.477760
+2214144;526.633953
+2217121;733.954811
+2220100;763.353153
+2223081;612.079627
+2226064;761.032286
+2229049;704.344808
+2232036;701.184017
+2235025;582.082712
+2238016;654.679286
+2241009;640.305039
+2244004;697.291683
+2247001;481.140065
+2250000;658.508404
+2253001;187.664590
+2256004;662.075046
+2259009;517.208704
+2262016;379.574807
+2265025;581.303523
+2268036;668.868300
+2271049;645.778484
+2274064;816.994224
+2277081;538.818190
+2280100;723.714789
+2283121;671.577332
+2286144;765.990283
+2289169;654.485332
+2292196;387.301128
+2295225;308.130848
+2298256;590.209585
+2301289;765.259715
+2304324;609.862055
+2307361;769.558774
+2310400;654.460978
+2313441;725.894777
+2316484;769.152534
+2319529;550.608372
+2322576;544.863700
+2325625;561.579263
+2328676;373.167905
+2331729;655.752087
+2334784;765.431642
+2337841;281.722312
+2340900;739.150724
+2343961;667.429066
+2347024;522.661256
+2350089;514.857109
+2353156;510.460688
+2356225;608.164696
+2359296;576.888676
+2362369;715.131880
+2365444;536.909927
+2368521;373.859899
+2371600;763.448138
+2374681;770.122489
+2377764;593.354509
+2380849;655.162412
+2383936;766.227384
+2387025;614.936630
+2390116;522.884263
+2393209;467.067048
+2396304;816.101606
+2399401;453.845102
+2402500;652.355170
+2405601;777.792382
+2408704;590.385493
+2411809;641.857570
+2414916;581.720045
+2418025;661.245985
+2421136;759.776969
+2424249;612.049622
+2427364;642.475250
+2430481;578.631507
+2433600;668.341504
+2436721;771.804136
+2439844;772.034230
+2442969;594.540979
+2446096;522.345884
+2449225;599.846312
+2452356;650.624724
+2455489;821.450448
+2458624;601.977233
+2461761;588.508930
+2464900;451.881485
+2468041;731.316374
+2471184;765.922444
+2474329;728.393594
+2477476;774.952689
+2480625;737.720702
+2483776;733.423183
+2486929;395.381977
+2490084;663.793563
+2493241;732.576558
+2496400;772.601826
+2499561;651.040189
+2502724;662.211899
+2505889;594.753163
+2509056;659.950124
+2512225;818.376535
+2515396;774.834161
+2518569;758.169324
+2521744;650.547233
+2524921;590.513061
+2528100;669.508818
+2531281;823.021699
+2534464;824.376898
+2537649;775.396657
+2540836;658.152343
+2544025;756.195755
+2547216;731.511709
+2550409;691.866602
+2553604;499.419324
+2556801;700.776271
+2560000;779.738869
+2563201;726.051302
+2566404;775.752428
+2569609;655.795257
+2572816;708.465124
+2576025;599.053533
+2579236;779.143172
+2582449;710.229994
+2585664;727.338875
+2588881;738.454011
+2592100;710.212305
+2595321;590.400910
+2598544;598.489967
+2601769;727.988445
+2604996;739.166095
+2608225;731.868502
+2611456;872.344156
+2614689;665.510286
+2617924;724.595414
+2621161;493.926690
+2624400;828.871059
+2627641;830.205455
+2630884;591.175038
+2634129;720.812303
+2637376;726.622708
+2640625;531.218641
+2643876;821.912742
+2647129;498.149019
+2650384;712.466537
+2653641;774.646742
+2656900;687.160059
+2660161;725.941402
+2663424;824.026743
+2666689;774.232689
+2669956;583.027238
+2673225;773.351791
+2676496;871.260544
+2679769;827.946757
+2683044;582.505580
+2686321;769.428708
+2689600;680.076766
+2692881;777.570633
+2696164;919.468604
+2699449;767.176509
+2702736;659.108233
+2706025;775.498813
+2709316;874.797597
+2712609;607.148403
+2715904;742.236319
+2719201;776.586055
+2722500;472.333473
+2725801;786.430018
+2729104;784.555908
+2732409;614.738763
+2735716;821.635907
+2739025;769.836333
+2742336;870.790850
+2745649;578.915414
+2748964;790.908004
+2752281;587.400849
+2755600;771.502696
+2758921;787.651011
+2762244;739.044488
+2765569;731.204758
+2768896;722.532394
+2772225;725.518740
+2775556;674.416513
+2778889;652.549269
+2782224;867.310563
+2785561;729.694897
+2788900;653.461946
+2792241;657.053203
+2795584;830.572052
+2798929;770.904527
+2802276;777.549949
+2805625;763.138548
+2808976;725.881418
+2812329;778.003998
+2815684;742.616869
+2819041;871.716128
+2822400;833.664377
+2825761;822.862459
+2829124;788.037940
+2832489;824.389919
+2835856;713.792533
+2839225;875.825350
+2842596;651.999222
+2845969;783.911442
+2849344;739.280082
+2852721;645.386051
+2856100;877.354086
+2859481;817.673868
+2862864;872.962967
+2866249;723.528805
+2869636;868.612518
+2873025;618.339480
+2876416;785.993541
+2879809;650.712759
+2883204;730.506939
+2886601;775.673477
+2890000;873.048367
+2893401;875.220292
+2896804;654.839937
+2900209;813.397791
+2903616;831.177159
+2907025;795.675550
+2910436;611.079922
+2913849;765.619466
+2917264;761.652071
+2920681;646.273679
+2924100;922.374446
+2927521;573.559740
+2930944;719.111536
+2934369;880.523259
+2937796;722.130358
+2941225;791.700449
+2944656;834.286347
+2948089;761.483082
+2951524;519.095253
+2954961;825.285517
+2958400;778.889454
+2961841;830.261987
+2965284;587.989988
+2968729;954.784267
+2972176;822.674723
+2975625;763.401043
+2979076;878.232961
+2982529;793.876107
+2985984;819.465661
+2989441;789.339964
+2992900;835.537576
+2996361;875.936177
+2999824;819.840676
+3003289;758.791717
+3006756;786.702412
+3010225;782.410047
+3013696;575.167051
+3017169;877.454376
+3020644;875.656992
+3024121;647.299023
+3027600;480.949946
+3031081;675.538488
+3034564;660.384994
+3038049;452.248846
+3041536;834.939863
+3045025;877.800059
+3048516;493.540352
+3052009;660.449751
+3055504;608.303606
+3059001;706.480114
+3062500;714.218232
+3066001;827.537338
+3069504;728.605366
+3073009;781.434127
+3076516;882.732925
+3080025;712.726446
+3083536;918.149792
+3087049;841.350772
+3090564;874.056130
+3094081;792.125661
+3097600;726.687520
+3101121;821.309945
+3104644;839.321034
+3108169;881.073863
+3111696;871.013555
+3115225;916.405603
+3118756;725.834128
+3122289;922.740808
+3125824;824.329012
+3129361;876.514287
+3132900;882.375860
+3136441;877.336097
+3139984;712.188184
+3143529;436.596533
+3147076;726.141298
+3150625;526.668221
+3154176;887.667844
+3157729;659.120008
+3161284;593.142972
+3164841;866.867685
+3168400;552.480144
+3171961;841.759682
+3175524;768.352736
+3179089;871.131300
+3182656;774.542673
+3186225;726.242527
+3189796;342.331061
+3193369;578.509561
+3196944;778.871692
+3200521;864.136244
+3204100;838.407722
+3207681;840.922826
+3211264;762.307537
+3214849;821.652746
+3218436;669.330888
+3222025;533.009246
+3225616;839.542872
+3229209;644.075287
+3232804;763.203867
+3236401;871.036911
+3240000;672.945408
+3243601;722.590800
+3247204;787.942783
+3250809;791.827618
+3254416;924.793641
+3258025;872.157434
+3261636;776.966068
+3265249;917.508871
+3268864;924.135198
+3272481;881.267545
+3276100;826.768791
+3279721;888.920014
+3283344;923.660836
+3286969;1000.957985
+3290596;882.868337
+3294225;826.882103
+3297856;769.939517
+3301489;929.407754
+3305124;537.693471
+3308761;825.044017
+3312400;559.640574
+3316041;726.865815
+3319684;962.782436
+3323329;664.649692
+3326976;881.988894
+3330625;875.102566
+3334276;685.516979
+3337929;880.310213
+3341584;870.987085
+3345241;1737.778421
+3348900;836.120500
+3352561;777.091633
+3356224;707.567274
+3359889;304.411420
+3363556;478.280066
+3367225;575.501499
+3370896;576.310477
+3374569;763.950777
+3378244;532.473331
+3381921;603.251565
+3385600;397.658081
+3389281;635.555140
+3392964;583.135993
+3396649;709.202292
+3400336;613.930598
+3404025;589.866614
+3407716;633.888812
+3411409;445.105084
+3415104;720.315341
+3418801;513.434620
+3422500;555.607743
+3426201;612.138052
+3429904;379.888996
+3433609;583.046873
+3437316;653.912547
+3441025;520.388549
+3444736;504.627433
+3448449;670.910223
+3452164;612.518075
+3455881;649.444825
+3459600;594.557357
+3463321;644.215131
+3467044;632.223827
+3470769;401.173257
+3474496;470.533476
+3478225;644.104659
+3481956;630.379323
+3485689;655.063314
+3489424;849.668835
+3493161;767.727787
+3496900;517.568284
+3500641;639.508987
+3504384;526.220980
+3508129;596.895299
+3511876;695.437811
+3515625;757.280082
+3519376;711.292021
+3523129;564.618918
+3526884;641.321445
+3530641;559.367712
+3534400;518.041311
+3538161;769.823013
+3541924;723.724458
+3545689;501.776550
+3549456;708.728005
+3553225;576.768887
+3556996;723.499869
+3560769;587.743340
+3564544;817.615466
+3568321;628.525211
+3572100;633.673347
+3575881;526.041116
+3579664;581.709834
+3583449;506.749173
+3587236;366.250040
+3591025;715.604555
+3594816;818.520001
+3598609;705.460051
+3602404;648.032805
+3606201;615.542445
+3610000;771.599610
+3613801;722.545107
+3617604;528.422107
+3621409;920.667358
+3625216;533.001265
+3629025;676.697988
+3632836;726.041065
+3636649;831.634142
+3640464;756.638815
+3644281;793.461010
+3648100;760.537184
+3651921;817.915464
+3655744;669.428205
+3659569;705.203964
+3663396;821.450113
+3667225;522.855877
+3671056;586.033104
+3674889;609.644099
+3678724;817.695329
+3682561;768.555882
+3686400;597.762997
+3690241;471.449154
+3694084;766.186778
+3697929;605.846877
+3701776;824.225749
+3705625;563.413117
+3709476;774.607035
+3713329;711.326530
+3717184;762.411598
+3721041;663.910889
+3724900;518.888503
+3728761;715.771496
+3732624;470.607086
+3736489;780.535430
+3740356;779.279307
+3744225;576.448870
+3748096;519.101271
+3751969;823.009451
+3755844;767.786457
+3759721;774.387985
+3763600;774.463483
+3767481;1043.472707
+3771364;863.810543
+3775249;600.400252
+3779136;701.133461
+3783025;769.606355
+3786916;913.657927
+3790809;491.732082
+3794704;637.771275
+3798601;820.433286
+3802500;519.769554
+3806401;825.542788
+3810304;781.600183
+3814209;762.681466
+3818116;1086.235025
+3822025;913.174974
+3825936;644.927068
+3829849;755.658282
+3833764;689.437696
+3837681;644.640822
+3841600;760.190820
+3845521;738.976030
+3849444;932.663307
+3853369;535.142993
+3857296;870.937036
+3861225;814.013044
+3865156;728.995521
+3869089;785.729810
+3873024;852.692798
+3876961;917.907516
+3880900;957.188692
+3884841;905.861746
+3888784;651.776070
+3892729;823.548615
+3896676;711.620848
+3900625;913.333875
+3904576;708.302237
+3908529;646.923820
+3912484;771.765637
+3916441;768.314045
+3920400;880.412642
+3924361;930.760792
+3928324;833.279113
+3932289;653.808961
+3936256;721.484561
+3940225;999.333333
+3944196;783.468919
+3948169;758.126060
+3952144;954.043877
+3956121;797.428090
+3960100;714.946979
+3964081;710.626228
+3968064;829.686156
+3972049;766.388960
+3976036;528.026202
+3980025;780.881566
+3984016;611.496816
+3988009;789.015781
+3992004;533.100986
+3996001;746.596179
+4000000;717.818417
+4004001;656.951819
+4008004;732.223307
+4012009;761.431851
+4016016;712.857165
+4020025;464.698216
+4024036;645.848671
+4028049;780.836343
+4032064;874.002045
+4036081;726.335542
+4040100;831.718644
+4044121;876.392628
+4048144;869.595480
+4052169;863.509929
+4056196;608.717914
+4060225;416.152783
+4064256;589.809865
+4068289;835.388051
+4072324;493.451554
+4076361;831.012185
+4080400;740.699061
+4084441;459.717972
+4088484;581.054629
+4092529;827.304369
+4096576;765.308222
+4100625;824.776601
+4104676;916.070573
+4108729;495.724450
+4112784;447.120348
+4116841;830.821590
+4120900;875.446865
+4124961;788.509712
+4129024;825.831948
+4133089;592.045201
+4137156;763.404874
+4141225;838.317383
+4145296;708.762137
+4149369;775.253731
+4153444;866.119561
+4157521;519.548287
+4161600;784.944308
+4165681;453.589072
+4169764;644.021035
+4173849;785.661426
+4177936;873.010258
+4182025;593.995931
+4186116;831.598448
+4190209;874.776889
+4194304;838.809068
+4198401;712.150668
+4202500;970.959518
+4206601;1004.779879
+4210704;833.414752
+4214809;741.888969
+4218916;943.574809
+4223025;524.179875
+4227136;1002.241738
+4231249;962.536171
+4235364;924.554497
+4239481;833.959992
+4243600;752.860094
+4247721;878.478577
+4251844;879.425518
+4255969;451.844482
+4260096;792.781461
+4264225;720.132678
+4268356;748.420036
+4272489;877.994090
+4276624;876.054708
+4280761;764.399919
+4284900;709.871673
+4289041;1015.412329
+4293184;874.696819
+4297329;839.972131
+4301476;923.612471
+4305625;956.429620
+4309776;769.754193
+4313929;921.287201
+4318084;652.188754
+4322241;763.341761
+4326400;928.514867
+4330561;363.897273
+4334724;729.260628
+4338889;880.894615
+4343056;887.570983
+4347225;834.685402
+4351396;877.120279
+4355569;614.762975
+4359744;919.475485
+4363921;836.472183
+4368100;735.180988
+4372281;749.952386
+4376464;823.571335
+4380649;499.223564
+4384836;745.274598
+4389025;833.634436
+4393216;889.630400
+4397409;967.627327
+4401604;1094.564841
+4405801;982.853340
+4410000;1073.337278
+4414201;985.066042
+4418404;867.574760
+4422609;866.371140
+4426816;407.542471
+4431025;986.531566
+4435236;959.344253
+4439449;774.297709
+4443664;803.255204
+4447881;925.022978
+4452100;766.272801
+4456321;831.346601
+4460544;844.776268
+4464769;678.184833
+4468996;992.866937
+4473225;620.178959
+4477456;801.798766
+4481689;853.870606
+4485924;999.672557
+4490161;845.914301
+4494400;560.903312
+4498641;883.168800
+4502884;971.111783
+4507129;1001.036598
+4511376;934.523358
+4515625;1030.061489
+4519876;859.605356
+4524129;1004.153904
+4528384;934.378743
+4532641;804.920125
+4536900;1021.478561
+4541161;975.166987
+4545424;1023.442545
+4549689;767.074444
+4553956;938.246053
+4558225;846.669248
+4562496;964.575368
+4566769;1054.995916
+4571044;708.921929
+4575321;1018.953698
+4579600;922.897033
+4583881;835.370518
+4588164;831.343649
+4592449;659.387552
+4596736;904.956238
+4601025;841.765598
+4605316;787.102803
+4609609;839.205716
+4613904;942.324395
+4618201;590.958103
+4622500;712.954817
+4626801;885.588552
+4631104;791.035617
+4635409;1002.775533
+4639716;734.094636
+4644025;828.390065
+4648336;1092.837750
+4652649;719.841994
+4656964;540.782473
+4661281;872.330158
+4665600;774.038906
+4669921;852.973953
+4674244;774.414062
+4678569;883.181707
+4682896;793.994043
+4687225;905.481709
+4691556;694.035195
+4695889;910.083785
+4700224;962.485918
+4704561;952.208499
+4708900;612.574075
+4713241;886.176197
+4717584;972.789796
+4721929;971.818851
+4726276;1196.111823
+4730625;773.485090
+4734976;998.990058
+4739329;972.399384
+4743684;793.556111
+4748041;881.367798
+4752400;584.430721
+4756761;724.901493
+4761124;791.231854
+4765489;833.123282
+4769856;763.750386
+4774225;824.862912
+4778596;848.310858
+4782969;833.542154
+4787344;925.144672
+4791721;878.512313
+4796100;840.620821
+4800481;913.323172
+4804864;1011.272185
+4809249;1006.582494
+4813636;883.489472
+4818025;830.625067
+4822416;765.561457
+4826809;614.542083
+4831204;880.617405
+4835601;1020.065375
+4840000;1006.158688
+4844401;829.254390
+4848804;831.692691
+4853209;961.558917
+4857616;912.401926
+4862025;1006.099997
+4866436;995.609811
+4870849;788.719853
+4875264;921.065537
+4879681;871.760707
+4884100;726.358470
+4888521;598.698118
+4892944;674.592497
+4897369;938.653632
+4901796;743.390558
+4906225;758.542086
+4910656;1032.096568
+4915089;873.485240
+4919524;791.084738
+4923961;967.321727
+4928400;768.783893
+4932841;765.026479
+4937284;969.239443
+4941729;765.068818
+4946176;825.981809
+4950625;927.772346
+4955076;731.466616
+4959529;917.127234
+4963984;888.281607
+4968441;918.557640
+4972900;806.765106
+4977361;836.921055
+4981824;1003.345672
+4986289;920.339137
+4990756;822.689995
+4995225;1004.207812
+4999696;998.800662
+5004169;857.501788
+5008644;837.666316
+5013121;993.097485
+5017600;996.637876
+5022081;776.295544
+5026564;964.561134
+5031049;955.762760
+5035536;731.098672
+5040025;996.200719
+5044516;769.451026
+5049009;522.114697
+5053504;780.809455
+5058001;960.103492
+5062500;966.525044
+5067001;1024.884652
+5071504;1027.975250
+5076009;762.260438
+5080516;871.882802
+5085025;892.170771
+5089536;1112.666861
+5094049;752.079557
+5098564;885.246178
+5103081;876.829877
+5107600;953.418401
+5112121;933.283842
+5116644;986.615187
+5121169;767.605508
+5125696;978.954554
+5130225;1026.379396
+5134756;646.508647
+5139289;992.023707
+5143824;990.268116
+5148361;1048.842024
+5152900;1030.029951
+5157441;590.388261
+5161984;909.402487
+5166529;828.070732
+5171076;901.172163
+5175625;875.193782
+5180176;592.804936
+5184729;914.795594
+5189284;986.862166
+5193841;985.602635
+5198400;787.963496
+5202961;1124.305609
+5207524;980.780784
+5212089;925.334830
+5216656;1027.702977
+5221225;962.391794
+5225796;867.860697
+5230369;948.951236
+5234944;863.827872
+5239521;865.297929
+5244100;1031.710189
+5248681;909.216940
+5253264;836.331821
+5257849;835.242169
+5262436;916.865772
+5267025;865.512014
+5271616;898.818658
+5276209;825.220246
+5280804;835.485614
+5285401;866.819901
+5290000;833.694232
+5294601;963.216694
+5299204;772.368958
+5303809;992.192127
+5308416;1021.088660
+5313025;906.105320
+5317636;1022.423461
+5322249;964.724598
+5326864;948.422316
+5331481;828.176789
+5336100;996.080885
+5340721;964.857514
+5345344;958.841028
+5349969;992.309161
+5354596;724.884386
+5359225;506.879898
+5363856;885.076940
+5368489;960.022694
+5373124;1000.219096
+5377761;989.634809
+5382400;958.553111
+5387041;856.254337
+5391684;951.752825
+5396329;569.152687
+5400976;993.200249
+5405625;989.144522
+5410276;963.708276
+5414929;1020.871043
+5419584;710.363502
+5424241;836.070509
+5428900;1056.370743
+5433561;864.962315
+5438224;909.650452
+5442889;1022.082830
+5447556;993.206820
+5452225;1074.052669
+5456896;996.930079
+5461569;712.965046
+5466244;960.120209
+5470921;993.672989
+5475600;958.869801
+5480281;996.497359
+5484964;960.617086
+5489649;1057.070719
+5494336;527.645355
+5499025;960.561029
+5503716;965.915944
+5508409;955.226422
+5513104;919.938444
+5517801;987.782014
+5522500;1025.047259
+5527201;788.525064
+5531904;1026.660473
+5536609;960.553547
+5541316;1053.792115
+5546025;988.833544
+5550736;792.560823
+5555449;841.346173
+5560164;942.834794
+5564881;965.724048
+5569600;1063.053523
+5574321;766.581703
+5579044;932.566184
+5583769;959.044739
+5588496;1025.801674
+5593225;1000.549959
+5597956;1028.917445
+5602689;1054.065864
+5607424;432.172218
+5612161;964.084494
+5616900;1026.457958
+5621641;906.114615
+5626384;831.758548
+5631129;912.756943
+5635876;1020.156383
+5640625;997.120649
+5645376;1027.350245
+5650129;911.991931
+5654884;1064.361305
+5659641;967.646509
+5664400;959.923454
+5669161;917.705485
+5673924;1038.807889
+5678689;703.297913
+5683456;715.145858
+5688225;1022.843525
+5692996;934.638531
+5697769;683.477021
+5702544;720.462929
+5707321;886.872037
+5712100;940.491625
+5716881;1058.574663
+5721664;791.539507
+5726449;1054.614003
+5731236;683.115513
+5736025;852.565207
+5740816;921.130033
+5745609;1058.858183
+5750404;1055.204487
+5755201;996.079454
+5760000;1002.393189
+5764801;889.802569
+5769604;860.151605
+5774409;984.831198
+5779216;731.768432
+5784025;1041.826459
+5788836;787.587943
+5793649;1053.450810
+5798464;968.505916
+5803281;1031.481502
+5808100;888.578922
+5812921;1003.295062
+5817744;786.905266
+5822569;994.687359
+5827396;879.037750
+5832225;789.934976
+5837056;1035.262510
+5841889;866.461366
+5846724;996.387925
+5851561;932.407914
+5856400;781.202444
+5861241;982.763958
+5866084;1100.129346
+5870929;1113.121224
+5875776;915.635994
+5880625;667.181019
+5885476;725.363119
+5890329;1056.812756
+5895184;880.296277
+5900041;1040.098847
+5904900;812.002021
+5909761;925.658552
+5914624;1005.168957
+5919489;965.013095
+5924356;1087.337472
+5929225;925.689380
+5934096;1069.244619
+5938969;978.971700
+5943844;875.810335
+5948721;1096.431985
+5953600;962.185780
+5958481;687.887909
+5963364;1013.095881
+5968249;917.669521
+5973136;1065.429134
+5978025;1003.161620
+5982916;1044.300876
+5987809;1023.636465
+5992704;733.196489
+5997601;972.389722
+6002500;834.215245
+6007401;879.921362
+6012304;1035.781042
+6017209;967.999673
+6022116;1060.416838
+6027025;969.127570
+6031936;1033.310822
+6036849;963.204031
+6041764;1050.000160
+6046681;1044.067510
+6051600;1003.678936
+6056521;738.890000
+6061444;966.293281
+6066369;828.958202
+6071296;1097.980614
+6076225;926.288005
+6081156;809.543367
+6086089;1062.932366
+6091024;688.442244
+6095961;1009.083126
+6100900;1065.245931
+6105841;882.499515
+6110784;1041.291371
+6115729;817.056423
+6120676;789.876257
+6125625;1019.426065
+6130576;1030.837274
+6135529;1048.388404
+6140484;1098.266783
+6145441;1074.272412
+6150400;1043.674634
+6155361;716.595746
+6160324;1122.037415
+6165289;966.158013
+6170256;846.844948
+6175225;1038.699405
+6180196;733.068765
+6185169;1082.154725
+6190144;824.352831
+6195121;1056.857741
+6200100;971.056763
+6205081;1075.212433
+6210064;1068.398979
+6215049;1072.679997
+6220036;1029.775855
+6225025;784.225693
+6230016;1035.416037
+6235009;961.329366
+6240004;1099.448575
+6245001;1047.625718
+6250000;993.317636
+6255001;916.798747
+6260004;794.924241
+6265009;1028.489786
+6270016;995.609547
+6275025;1040.473683
+6280036;978.343064
+6285049;911.753990
+6290064;864.659262
+6295081;925.330646
+6300100;1055.735721
+6305121;1058.449896
+6310144;779.911354
+6315169;930.443960
+6320196;959.054614
+6325225;1117.497812
+6330256;1079.311700
+6335289;1119.650924
+6340324;1056.553785
+6345361;1046.976821
+6350400;1090.407914
+6355441;687.387343
+6360484;767.636699
+6365529;1095.494626
+6370576;948.670473
+6375625;870.888114
+6380676;1086.253569
+6385729;1030.853407
+6390784;1052.798900
+6395841;1110.788821
+6400900;990.872680
+6405961;920.797813
+6411024;1043.449931
+6416089;788.963205
+6421156;1002.718350
+6426225;776.317136
+6431296;698.887727
+6436369;1042.200708
+6441444;757.442228
+6446521;1137.126688
+6451600;989.530386
+6456681;1011.811793
+6461764;1063.578015
+6466849;1052.679373
+6471936;804.425333
+6477025;1004.320789
+6482116;959.168032
+6487209;963.945077
+6492304;1024.379611
+6497401;887.886833
+6502500;987.518220
+6507601;1099.006536
+6512704;390.372682
+6517809;1029.180043
+6522916;1059.607670
+6528025;1117.172310
+6533136;1100.798137
+6538249;704.254935
+6543364;1064.154520
+6548481;1115.222276
+6553600;1014.503100
+6558721;639.605183
+6563844;1053.459145
+6568969;1120.497761
+6574096;1096.153793
+6579225;966.379783
+6584356;969.642909
+6589489;1076.411520
+6594624;1106.928246
+6599761;821.258500
+6604900;1011.277341
+6610041;1013.158576
+6615184;1095.677297
+6620329;1005.116651
+6625476;1060.437122
+6630625;840.206430
+6635776;1078.107144
+6640929;966.893160
+6646084;1027.240997
+6651241;1126.124462
+6656400;960.320052
+6661561;1110.636642
+6666724;1110.406852
+6671889;1120.492134
+6677056;1032.146559
+6682225;980.769128
+6687396;809.339493
+6692569;1089.320505
+6697744;1142.246370
+6702921;1013.351321
+6708100;1002.465523
+6713281;720.703066
+6718464;881.826815
+6723649;1100.132567
+6728836;1039.341042
+6734025;1093.273066
+6739216;1115.913023
+6744409;1124.771258
+6749604;1103.677815
+6754801;1009.675969
+6760000;1002.038072
+6765201;1032.044035
+6770404;1064.891780
+6775609;1028.940967
+6780816;1008.601167
+6786025;1008.527808
+6791236;1121.268532
+6796449;793.767425
+6801664;1064.037433
+6806881;937.305618
+6812100;1083.980012
+6817321;1072.468984
+6822544;1095.758765
+6827769;1050.792546
+6832996;568.554130
+6838225;1134.793268
+6843456;994.187432
+6848689;1063.376981
+6853924;977.595606
+6859161;975.221973
+6864400;1089.526610
+6869641;1142.827516
+6874884;1094.477417
+6880129;1135.183901
+6885376;968.021519
+6890625;926.703309
+6895876;1013.758037
+6901129;1007.173749
+6906384;1118.037993
+6911641;1128.382728
+6916900;971.147563
+6922161;1039.824611
+6927424;880.171510
+6932689;1051.646577
+6937956;966.245515
+6943225;1035.514897
+6948496;1128.263878
+6953769;1010.366837
+6959044;1097.550481
+6964321;1008.558740
+6969600;1002.593042
+6974881;1083.248148
+6980164;1069.918984
+6985449;1114.400898
+6990736;1104.059650
+6996025;960.996552
+7001316;1104.209506
+7006609;1107.120081
+7011904;1121.877443
+7017201;1098.964176
+7022500;1128.190317
+7027801;1001.965550
+7033104;868.247299
+7038409;997.267836
+7043716;866.763024
+7049025;1103.141213
+7054336;993.045989
+7059649;1117.972497
+7064964;1085.987839
+7070281;1110.676608
+7075600;1037.447308
+7080921;1145.549792
+7086244;1096.783968
+7091569;1042.274524
+7096896;1022.673479
+7102225;1097.494494
+7107556;1087.418174
+7112889;1077.066864
+7118224;1090.721356
+7123561;1069.804718
+7128900;1080.776305
+7134241;1089.658596
+7139584;1017.034335
+7144929;1012.750303
+7150276;949.434780
+7155625;1168.988941
+7160976;1049.179652
+7166329;1071.472366
+7171684;1137.876155
+7177041;1055.349823
+7182400;1096.797081
+7187761;1057.412326
+7193124;1092.542919
+7198489;1076.138147
+7203856;987.061851
+7209225;810.728788
+7214596;1061.907981
+7219969;1080.409517
+7225344;1011.343700
+7230721;1051.163705
+7236100;1040.201560
+7241481;1099.798599
+7246864;1091.863809
+7252249;1133.382311
+7257636;1041.642056
+7263025;1066.767509
+7268416;1101.755580
+7273809;1090.904136
+7279204;1119.008290
+7284601;1098.660103
+7290000;1125.853196
+7295401;1030.784428
+7300804;969.977860
+7306209;1097.330307
+7311616;1091.255853
+7317025;1151.466738
+7322436;1249.254817
+7327849;1047.974030
+7333264;1134.813268
+7338681;982.678787
+7344100;1069.576633
+7349521;1074.921775
+7354944;962.653753
+7360369;810.090472
+7365796;993.779799
+7371225;1067.603329
+7376656;926.229298
+7382089;1121.393600
+7387524;1120.956463
+7392961;1067.818350
+7398400;909.082367
+7403841;1145.362945
+7409284;987.490868
+7414729;1088.518694
+7420176;1138.055415
+7425625;1089.515841
+7431076;1124.690710
+7436529;1072.999462
+7441984;1116.058755
+7447441;1072.377757
+7452900;963.033197
+7458361;1109.020248
+7463824;1062.214390
+7469289;1000.731039
+7474756;1007.930985
+7480225;1101.615150
+7485696;1149.236761
+7491169;1075.773331
+7496644;1097.777400
+7502121;1122.065978
+7507600;1025.493518
+7513081;1079.443305
+7518564;1136.997623
+7524049;577.204767
+7529536;1147.717175
+7535025;1137.810902
+7540516;1087.535586
+7546009;1074.579720
+7551504;1097.865440
+7557001;1120.509207
+7562500;1115.947830
+7568001;1004.030542
+7573504;1088.339345
+7579009;1130.893123
+7584516;1057.132999
+7590025;1123.892483
+7595536;1085.101556
+7601049;1098.526422
+7606564;999.704736
+7612081;750.643948
+7617600;1063.894735
+7623121;1109.488565
+7628644;1102.141273
+7634169;1075.497847
+7639696;1116.731394
+7645225;1095.791947
+7650756;1097.196190
+7656289;1039.401416
+7661824;1083.976320
+7667361;1021.349077
+7672900;1113.137849
+7678441;1151.499422
+7683984;1130.425132
+7689529;1059.714035
+7695076;1165.366618
+7700625;1125.764452
+7706176;1041.734794
+7711729;1014.804597
+7717284;1102.141516
+7722841;1168.487560
+7728400;1051.629052
+7733961;1083.005041
+7739524;1115.928276
+7745089;1095.749999
+7750656;1131.203901
+7756225;1069.305800
+7761796;972.945086
+7767369;1063.462186
+7772944;1113.726406
+7778521;1107.619232
+7784100;1045.890767
+7789681;1079.100902
+7795264;1086.516025
+7800849;1068.365447
+7806436;1050.237031
+7812025;1135.700683
+7817616;1112.473699
+7823209;1097.767968
+7828804;477.604505
+7834401;1119.660751
+7840000;935.345459
+7845601;1109.573602
+7851204;930.337220
+7856809;970.906887
+7862416;846.704159
+7868025;1065.197056
+7873636;1082.539319
+7879249;1110.000148
+7884864;1117.773234
+7890481;1138.633210
+7896100;1021.776914
+7901721;1114.194340
+7907344;1153.645797
+7912969;888.988639
+7918596;1086.882989
+7924225;1141.269421
+7929856;1104.571750
+7935489;1083.447412
+7941124;1037.514623
+7946761;998.966256
+7952400;832.682886
+7958041;1123.648955
+7963684;1078.757829
+7969329;1051.896117
+7974976;1134.244180
+7980625;1104.490617
+7986276;1108.444864
+7991929;1045.016759
+7997584;1074.498059
+8003241;817.605594
+8008900;1114.890448
+8014561;985.548747
+8020224;1002.406211
+8025889;1071.746926
+8031556;1140.391496
+8037225;1134.490432
+8042896;1096.485848
+8048569;1107.127990
+8054244;1038.730143
+8059921;1109.594242
+8065600;1125.220715
+8071281;1106.015527
+8076964;1011.784767
+8082649;1064.117712
+8088336;1103.716065
+8094025;1129.698097
+8099716;1128.670236
+8105409;997.087456
+8111104;1076.277634
+8116801;1084.463382
+8122500;1115.474724
+8128201;873.674847
+8133904;1136.063832
+8139609;1115.336712
+8145316;1106.059913
+8151025;1096.417060
+8156736;1126.264200
+8162449;974.839726
+8168164;1067.775833
+8173881;1140.162874
+8179600;1011.253182
+8185321;1121.289365
+8191044;1131.642080
+8196769;1010.779316
+8202496;1130.474357
+8208225;1133.688788
+8213956;1032.733882
+8219689;1067.975786
+8225424;1100.905442
+8231161;1099.879369
+8236900;1126.490800
+8242641;956.873252
+8248384;1006.128412
+8254129;987.458194
+8259876;1079.043005
+8265625;1150.044350
+8271376;1024.291974
+8277129;1108.711766
+8282884;991.784245
+8288641;1104.998976
+8294400;1150.220372
+8300161;1117.597848
+8305924;1037.992602
+8311689;1069.351771
+8317456;1045.302205
+8323225;990.903531
+8328996;1089.802959
+8334769;1071.683244
+8340544;1123.417991
+8346321;1108.043445
+8352100;985.035616
+8357881;1068.833791
+8363664;1166.441847
+8369449;1155.909850
+8375236;1096.047891
+8381025;1093.798929
+8386816;1081.420783
+8392609;961.523763
+8398404;822.210142
+8404201;1104.781450
+8410000;1115.464623
+8415801;1069.796733
+8421604;1085.272637
+8427409;1109.091496
+8433216;1100.704447
+8439025;1148.325499
+8444836;1109.002176
+8450649;1139.728141
+8456464;903.162067
+8462281;960.032511
+8468100;1107.968118
+8473921;1092.886126
+8479744;1126.818466
+8485569;1049.339556
+8491396;1103.637990
+8497225;1136.852618
+8503056;1075.661872
+8508889;1043.316082
+8514724;793.386489
+8520561;1072.635681
+8526400;1103.296147
+8532241;1089.007488
+8538084;1066.098203
+8543929;1104.140251
+8549776;1086.318160
+8555625;1127.351193
+8561476;1114.244399
+8567329;1152.116983
+8573184;1110.595552
+8579041;1003.343528
+8584900;730.350963
+8590761;1139.580701
+8596624;1075.322895
+8602489;1108.346265
+8608356;1133.618467
+8614225;1145.381644
+8620096;1125.879662
+8625969;1089.929728
+8631844;1128.148131
+8637721;1087.520074
+8643600;1047.713998
+8649481;1077.386658
+8655364;1091.489451
+8661249;1088.470649
+8667136;1110.764199
+8673025;1104.078989
+8678916;1139.188627
+8684809;1158.551080
+8690704;1066.756046
+8696601;1077.173474
+8702500;1113.948811
+8708401;940.523754
+8714304;1119.909483
+8720209;1140.201278
+8726116;1139.293995
+8732025;1112.443030
+8737936;1176.079558
+8743849;1381.073031
+8749764;1176.620948
+8755681;1144.308339
+8761600;974.750897
+8767521;1122.913087
+8773444;1009.171853
+8779369;1094.270096
+8785296;1102.679950
+8791225;726.910492
+8797156;966.654855
+8803089;1124.425454
+8809024;1078.635848
+8814961;1167.194735
+8820900;1135.314567
+8826841;1043.782951
+8832784;1055.377982
+8838729;971.613071
+8844676;1156.492975
+8850625;984.315503
+8856576;1135.238271
+8862529;1132.532226
+8868484;1124.723590
+8874441;1111.192386
+8880400;1067.944737
+8886361;1095.640576
+8892324;1112.680880
+8898289;1081.175884
+8904256;1105.004369
+8910225;1130.189629
+8916196;972.511548
+8922169;1135.127541
+8928144;1098.667695
+8934121;1114.661911
+8940100;1119.289795
+8946081;1173.524195
+8952064;1113.682644
+8958049;1044.468594
+8964036;1035.106373
+8970025;1098.180152
+8976016;1118.059321
+8982009;1087.630806
+8988004;939.210420
+8994001;1107.172605
+9000000;1129.634605
+9006001;1099.182783
+9012004;991.556356
+9018009;1116.762619
+9024016;1029.330176
+9030025;1148.685337
+9036036;1107.771469
+9042049;1148.861572
+9048064;1106.299498
+9054081;1102.962799
+9060100;484.369537
+9066121;1115.790224
+9072144;1125.294580
+9078169;1026.721136
+9084196;1165.946854
+9090225;951.911713
+9096256;1099.384830
+9102289;1106.592465
+9108324;1104.025173
+9114361;1104.874231
+9120400;1058.464833
+9126441;914.633562
+9132484;1113.024630
+9138529;1109.317664
+9144576;1120.136220
+9150625;812.971157
+9156676;1124.678697
+9162729;992.288192
+9168784;988.844097
+9174841;1072.979311
+9180900;1135.213179
+9186961;1115.202847
+9193024;908.754092
+9199089;1124.822548
+9205156;1073.249109
+9211225;1097.697898
+9217296;1096.461708
+9223369;1068.432497
+9229444;1138.092324
+9235521;951.309160
+9241600;1101.904313
+9247681;1126.840678
+9253764;1125.089014
+9259849;1085.257526
+9265936;1081.882926
+9272025;1027.232068
+9278116;1121.906444
+9284209;1007.388122
+9290304;1071.136921
+9296401;1111.581136
+9302500;1092.574829
+9308601;1081.705503
+9314704;1105.467137
+9320809;1206.470469
+9326916;1056.148754
+9333025;1271.323061
+9339136;917.687024
+9345249;982.731068
+9351364;1112.647346
+9357481;1127.763734
+9363600;1148.636237
+9369721;1071.349078
+9375844;1103.732986
+9381969;1012.926101
+9388096;1140.761754
+9394225;1144.031703
+9400356;1101.166923
+9406489;1134.896514
+9412624;1128.024267
+9418761;1103.774071
+9424900;1116.256161
+9431041;1042.861022
+9437184;1106.362412
+9443329;1087.905414
+9449476;1110.516810
+9455625;1153.396851
+9461776;1116.528280
+9467929;1098.836215
+9474084;1123.004710
+9480241;1134.890762
+9486400;900.341508
+9492561;895.646490
+9498724;1128.536719
+9504889;1068.663248
+9511056;818.925858
+9517225;1134.790439
+9523396;1111.336467
+9529569;1071.803000
+9535744;1077.532294
+9541921;1128.664105
+9548100;1121.806545
+9554281;1117.231529
+9560464;1116.846838
+9566649;1146.550413
+9572836;1207.800216
+9579025;1170.539155
+9585216;1034.123316
+9591409;1062.283953
+9597604;970.667610
+9603801;1214.220807
+9610000;1082.884134
+9616201;1202.363843
+9622404;1142.625250
+9628609;1099.332932
+9634816;1132.776188
+9641025;1361.526178
+9647236;1119.558544
+9653449;1004.853946
+9659664;969.972854
+9665881;1057.988250
+9672100;1116.236189
+9678321;1160.091967
+9684544;1111.333187
+9690769;1147.110751
+9696996;1078.010648
+9703225;1149.587307
+9709456;1168.357307
+9715689;1104.688272
+9721924;1143.550446
+9728161;1066.899290
+9734400;977.363558
+9740641;1145.026591
+9746884;1119.756469
+9753129;777.202990
+9759376;965.195484
+9765625;1116.046789
+9771876;1150.568421
+9778129;1078.226494
+9784384;1123.017559
+9790641;1133.263004
+9796900;1109.469688
+9803161;1117.151918
+9809424;1131.733014
+9815689;1115.368606
+9821956;1068.213163
+9828225;1123.759063
+9834496;1082.059873
+9840769;1076.655357
+9847044;1124.267115
+9853321;1094.174477
+9859600;1129.114054
+9865881;1131.364558
+9872164;1125.605983
+9878449;478.849564
+9884736;1056.336295
+9891025;1129.452309
+9897316;1050.983721
+9903609;1063.406079
+9909904;1102.758743
+9916201;1156.437846
+9922500;997.448869
+9928801;1117.739773
+9935104;1144.769421
+9941409;1114.095775
+9947716;1081.683425
+9954025;1092.501099
+9960336;1035.066938
+9966649;1087.665302
+9972964;1146.798558
+9979281;1075.282306
+9985600;1093.376932
+9991921;1093.205479
+9998244;803.636781
+10004569;1078.539693
+10010896;1126.769896
+10017225;1076.907234
+10023556;1101.396446
+10029889;1056.864174
+10036224;1095.953416
+10042561;1114.301829
+10048900;1104.866825
+10055241;1132.824773
+10061584;1069.540664
+10067929;1053.849506
+10074276;1071.263928
+10080625;1078.885918
+10086976;1081.074326
+10093329;1148.531355
+10099684;1119.863691
+10106041;1108.912639
+10112400;1098.676569
+10118761;1131.195651
+10125124;1030.352152
+10131489;1100.484571
+10137856;976.279446
+10144225;1065.081829
+10150596;1070.764553
+10156969;1098.479147
+10163344;1048.274357
+10169721;1124.984498
+10176100;1122.541873
+10182481;1127.149589
+10188864;1046.378115
+10195249;1056.303541
+10201636;1062.838869
+10208025;950.322177
+10214416;1103.365141
+10220809;1083.559135
+10227204;1130.500569
+10233601;1013.406316
+10240000;1097.753477
+10246401;1046.433640
+10252804;1144.199981
+10259209;1110.198079
+10265616;1159.226545
+10272025;1111.750438
+10278436;1093.811259
+10284849;1085.852087
+10291264;1136.941372
+10297681;1110.371647
+10304100;1144.199998
+10310521;1126.960336
+10316944;1123.499554
+10323369;1063.053105
+10329796;1031.567401
+10336225;1040.376318
+10342656;959.983512
+10349089;1054.200738
+10355524;1032.748371
+10361961;1080.843808
+10368400;1168.943276
+10374841;1116.791940
+10381284;1113.039458
+10387729;1076.542524
+10394176;1071.016929
+10400625;1090.440469
+10407076;1088.379837
+10413529;1093.265386
+10419984;1053.232591
+10426441;845.978921
+10432900;1038.715844
+10439361;1104.550158
+10445824;1094.368897
+10452289;1000.761590
+10458756;1121.846035
+10465225;1117.792987
+10471696;1120.017067
+10478169;1087.791511
+10484644;705.789146
+10491121;1116.602933
+10497600;1039.545583
+10504081;1095.209876
+10510564;1012.603397
+10517049;1102.099335
+10523536;1150.517711
+10530025;930.477765
+10536516;1136.148159
+10543009;1029.918604
+10549504;1136.491420
+10556001;692.706379
+10562500;1128.439245
+10569001;1119.856919
+10575504;1107.319039
+10582009;1095.052769
+10588516;1120.445823
+10595025;1060.344092
+10601536;1037.665256
+10608049;1040.130212
+10614564;1114.314707
+10621081;1127.760709
+10627600;1102.688685
+10634121;1091.093714
+10640644;1139.477617
+10647169;1046.152160
+10653696;1134.264623
+10660225;1117.119886
+10666756;1039.863550
+10673289;1149.250274
+10679824;1137.477573
+10686361;1115.338338
+10692900;1165.271238
+10699441;1111.009578
+10705984;1089.445561
+10712529;1087.038872
+10719076;735.759572
+10725625;1102.453732
+10732176;1197.208051
+10738729;1203.291402
+10745284;1080.153279
+10751841;1064.726592
+10758400;1040.900583
+10764961;1090.481287
+10771524;1107.021915
+10778089;1021.828932
+10784656;1098.444063
+10791225;1070.608276
+10797796;1116.754552
+10804369;1085.155518
+10810944;1049.142245
+10817521;1118.112472
+10824100;1041.310498
+10830681;1035.233896
+10837264;1062.912352
+10843849;1072.449953
+10850436;1142.291371
+10857025;1121.715394
+10863616;1034.695156
+10870209;1109.843349
+10876804;1090.144465
+10883401;1140.949997
+10890000;1131.498266
+10896601;1059.092043
+10903204;998.541867
+10909809;1134.929161
+10916416;1061.902398
+10923025;1092.824020
+10929636;1108.388181
+10936249;1166.505301
+10942864;1025.768490
+10949481;1053.849126
+10956100;1125.893375
+10962721;1092.525380
+10969344;1099.872084
+10975969;1104.011438
+10982596;1101.981832
+10989225;1097.337290
+10995856;1125.230028
+11002489;1063.773687
+11009124;1131.225885
+11015761;1086.167803
+11022400;1098.576560
+11029041;1084.548424
+11035684;1074.438484
+11042329;1132.563412
+11048976;1122.571958
+11055625;1161.286088
+11062276;1110.527041
+11068929;1056.382168
+11075584;1099.510311
+11082241;1086.825578
+11088900;1179.431212
+11095561;1076.650120
+11102224;569.466345
+11108889;1254.161860
+11115556;1093.794362
+11122225;1110.027085
+11128896;1116.370103
+11135569;1092.387769
+11142244;1143.066951
+11148921;1299.154801
+11155600;1152.408289
+11162281;1079.341582
+11168964;1126.504204
+11175649;1103.972445
+11182336;1100.114059
+11189025;1121.469559
+11195716;1083.312919
+11202409;1124.645026
+11209104;1253.825143
+11215801;1159.765469
+11222500;1129.638127
+11229201;1120.842928
+11235904;1123.971686
+11242609;1207.979565
+11249316;1285.114803
+11256025;1031.789587
+11262736;1060.602275
+11269449;1140.089832
+11276164;1033.526907
+11282881;1086.621080
+11289600;1106.009722
+11296321;972.935210
+11303044;1089.210815
+11309769;1084.873159
+11316496;1136.446871
+11323225;1064.466156
+11329956;1048.922635
+11336689;1196.028665
+11343424;1092.635399
+11350161;1386.693413
+11356900;1200.451956
+11363641;1085.375904
+11370384;1103.603985
+11377129;998.334059
+11383876;1341.230254
+11390625;1104.012793
+11397376;1031.165325
+11404129;1043.925476
+11410884;1182.203013
+11417641;1138.449627
+11424400;1088.927578
+11431161;1070.351469
+11437924;1118.507438
+11444689;1039.563409
+11451456;1050.382238
+11458225;980.674948
+11464996;1090.390388
+11471769;1066.057109
+11478544;1169.456611
+11485321;1025.613358
+11492100;1191.663045
+11498881;1134.982775
+11505664;1275.172177
+11512449;1108.275232
+11519236;1410.208569
+11526025;1075.781194
+11532816;1187.520977
+11539609;1231.605711
+11546404;1048.298474
+11553201;1042.668954
+11560000;1130.692714
+11566801;1056.978570
+11573604;1315.529624
+11580409;1135.437860
+11587216;1078.625697
+11594025;1043.773375
+11600836;1044.872852
+11607649;1337.625531
+11614464;1090.573460
+11621281;1326.674014
+11628100;1051.386536
+11634921;1105.389969
+11641744;1080.148162
+11648569;1187.378404
+11655396;1218.411039
+11662225;1444.959942
+11669056;1268.343009
+11675889;1352.666598
+11682724;1080.452191
+11689561;1034.867073
+11696400;1156.494070
+11703241;1091.872569
+11710084;1368.974486
+11716929;1256.800908
+11723776;1360.608721
+11730625;1239.979651
+11737476;1063.239450
+11744329;1135.749376
+11751184;984.044950
+11758041;1416.021909
+11764900;1046.240878
+11771761;1119.702309
+11778624;1145.186281
+11785489;1252.996184
+11792356;1138.612792
+11799225;1343.808442
+11806096;1343.744533
+11812969;1029.161445
+11819844;1145.921755
+11826721;1025.943038
+11833600;1120.060228
+11840481;1262.916208
+11847364;1142.714152
+11854249;1500.354779
+11861136;1105.555425
+11868025;1057.096018
+11874916;1071.429990
+11881809;1101.665786
+11888704;1397.459353
+11895601;1100.293543
+11902500;1320.696375
+11909401;1269.764599
+11916304;1184.333247
+11923209;1238.289245
+11930116;1094.767952
+11937025;1151.730253
+11943936;1065.997151
+11950849;1100.415152
+11957764;1239.244865
+11964681;1630.211674
+11971600;1078.126350
+11978521;1286.496194
+11985444;1136.865204
+11992369;1148.970852
+11999296;1156.080532
+12006225;1155.249842
+12013156;1458.840242
+12020089;1104.278047
+12027024;1150.017444
+12033961;1202.695931
+12040900;1081.223136
+12047841;1149.881136
+12054784;1328.183704
+12061729;1432.186212
+12068676;1124.517751
+12075625;1628.856037
+12082576;1573.774170
+12089529;1364.668614
+12096484;1278.593475
+12103441;1100.830181
+12110400;1092.120241
+12117361;1440.920192
+12124324;1060.712846
+12131289;1366.772658
+12138256;1061.879201
+12145225;1112.207641
+12152196;1093.659683
+12159169;1218.927177
+12166144;1362.838686
+12173121;1387.757299
+12180100;1039.980105
+12187081;1031.368676
+12194064;1073.719850
+12201049;1126.056571
+12208036;1117.921150
+12215025;1544.988105
+12222016;1146.708668
+12229009;1057.747095
+12236004;1063.335333
+12243001;1403.219811
+12250000;1116.987937
+12257001;1101.011158
+12264004;1092.634997
+12271009;1026.125203
+12278016;1131.629534
+12285025;1094.810161
+12292036;1594.335703
+12299049;1085.482169
+12306064;1047.412295
+12313081;1104.464915
+12320100;1030.304363
+12327121;1101.609841
+12334144;1331.313212
+12341169;1096.095690
+12348196;1045.913176
+12355225;1422.765289
+12362256;1097.148735
+12369289;1144.626026
+12376324;1233.882400
+12383361;1050.819396
+12390400;1571.033946
+12397441;1143.756001
+12404484;1125.666788
+12411529;1083.032104
+12418576;1545.008816
+12425625;1186.710850
+12432676;1435.921654
+12439729;1063.036294
+12446784;1044.290700
+12453841;1034.917316
+12460900;1049.062294
+12467961;1095.640499
+12475024;1095.160659
+12482089;1090.909543
+12489156;1177.303382
+12496225;1309.147804
+12503296;1055.604907
+12510369;1112.425328
+12517444;1444.495694
+12524521;1571.167256
+12531600;1069.492677
+12538681;1286.966007
+12545764;1339.860028
+12552849;1042.399821
+12559936;1062.868114
+12567025;1469.127965
+12574116;1557.211427
+12581209;1082.489640
+12588304;1752.417677
+12595401;1103.165771
+12602500;1430.813522
+12609601;1711.757918
+12616704;1406.863431
+12623809;1405.091573
+12630916;1300.806648
+12638025;1358.269375
+12645136;1151.192597
+12652249;1513.411482
+12659364;757.373641
+12666481;1042.733704
+12673600;1390.104664
+12680721;1602.233178
+12687844;1063.110776
+12694969;1095.027758
+12702096;1091.919844
+12709225;1615.914227
+12716356;1138.241548
+12723489;1645.295520
+12730624;1772.121862
+12737761;1639.556328
+12744900;1667.514201
+12752041;1607.129596
+12759184;1680.270225
+12766329;1607.166115
+12773476;1031.937943
+12780625;1147.640785
+12787776;1746.489023
+12794929;1123.088275
+12802084;1045.632162
+12809241;1037.322870
+12816400;1117.062866
+12823561;1560.177595
+12830724;1042.913323
+12837889;1738.897519
+12845056;998.075395
+12852225;1113.520857
+12859396;964.174122
+12866569;1004.778826
+12873744;1142.344830
+12880921;1165.288968
+12888100;1636.889062
+12895281;932.033386
+12902464;1710.314125
+12909649;1148.312299
+12916836;1501.800127
+12924025;1067.796247
+12931216;1742.988732
+12938409;1804.170483
+12945604;1144.354031
+12952801;1479.804180
+12960000;1466.327844
+12967201;1583.152897
+12974404;1516.208485
+12981609;1045.309420
+12988816;1266.042701
+12996025;1773.086198
+13003236;1574.772325
+13010449;1154.186921
+13017664;1048.253265
+13024881;1682.431963
+13032100;1074.520781
+13039321;1124.474037
+13046544;1129.121163
+13053769;1821.225632
+13060996;1394.609391
+13068225;1074.228476
+13075456;1135.127976
+13082689;1548.120565
+13089924;1051.243838
+13097161;1516.994665
+13104400;1266.353257
+13111641;1820.727225
+13118884;1190.220461
+13126129;1127.301085
+13133376;1587.324447
+13140625;1597.325726
+13147876;1265.169398
+13155129;1028.277868
+13162384;1335.537909
+13169641;1752.549917
+13176900;1901.915266
+13184161;1780.238589
+13191424;1121.494353
+13198689;1700.210402
+13205956;1110.485985
+13213225;1309.895303
+13220496;1176.752696
+13227769;1722.467438
+13235044;1151.267009
+13242321;1660.311459
+13249600;1083.913010
+13256881;1729.612534
+13264164;1510.834355
+13271449;1798.790306
+13278736;1283.711433
+13286025;1019.705094
+13293316;1279.138439
+13300609;1465.167663
+13307904;1068.905708
+13315201;1163.624898
+13322500;1552.621590
+13329801;1745.485888
+13337104;1427.064891
+13344409;1471.243903
+13351716;1872.975227
+13359025;1055.244066
+13366336;1044.586132
+13373649;1037.020240
+13380964;1637.228965
+13388281;1892.127303
+13395600;1035.843433
+13402921;1375.432582
+13410244;1033.715124
+13417569;1510.835449
+13424896;1113.931270
+13432225;1797.187902
+13439556;1833.427878
+13446889;1137.380151
+13454224;1154.189740
+13461561;1695.918940
+13468900;1901.897008
+13476241;2295.008138
+13483584;1582.615432
+13490929;1079.264877
+13498276;1152.221648
+13505625;1665.778753
+13512976;1219.908042
+13520329;1667.371343
+13527684;1721.377113
+13535041;1429.703567
+13542400;1012.179331
+13549761;1890.751333
+13557124;1954.477693
+13564489;1923.735116
+13571856;1199.215308
+13579225;1927.013590
+13586596;1178.254662
+13593969;2567.464423
+13601344;2376.990338
+13608721;1359.206559
+13616100;1192.469364
+13623481;1727.587737
+13630864;1747.826287
+13638249;1483.568710
+13645636;1954.528673
+13653025;1474.068372
+13660416;1153.556957
+13667809;2455.731840
+13675204;2030.371055
+13682601;1565.719447
+13690000;1904.038422
+13697401;1077.940566
+13704804;1964.390098
+13712209;1211.683035
+13719616;1243.036955
+13727025;1074.555423
+13734436;1252.896540
+13741849;1853.357672
+13749264;2068.859836
+13756681;1324.920201
+13764100;1917.823058
+13771521;2048.689176
+13778944;975.895249
+13786369;1913.340750
+13793796;1752.710611
+13801225;1119.251547
+13808656;1081.380304
+13816089;2081.725865
+13823524;3458.637786
+13830961;2413.008348
+13838400;2353.312585
+13845841;2234.655014
+13853284;1196.711226
+13860729;2101.046358
+13868176;1214.349745
+13875625;2088.356819
+13883076;1326.539296
+13890529;1115.454447
+13897984;1972.471542
+13905441;1081.641629
+13912900;1967.442025
+13920361;2074.563767
+13927824;1772.963662
+13935289;2117.351915
+13942756;2172.249518
+13950225;1976.158557
+13957696;1980.520185
+13965169;1240.876681
+13972644;1129.663955
+13980121;1030.927410
+13987600;1974.988503
+13995081;2176.314589
+14002564;2311.997810
+14010049;1811.437592
+14017536;2317.230689
+14025025;2103.665898
+14032516;1124.705900
+14040009;2151.132838
+14047504;1774.529799
+14055001;1135.910710
+14062500;1335.223102
+14070001;1691.741758
+14077504;1135.733003
+14085009;1878.846676
+14092516;1488.960626
+14100025;1203.473935
+14107536;1494.257796
+14115049;1362.206857
+14122564;1475.955172
+14130081;1917.272565
+14137600;2143.819608
+14145121;1632.626520
+14152644;1969.228449
+14160169;1687.111394
+14167696;2123.434576
+14175225;1643.244967
+14182756;1970.595509
+14190289;2118.938842
+14197824;965.303004
+14205361;1067.033512
+14212900;1933.585303
+14220441;1140.654181
+14227984;1452.043255
+14235529;1791.030564
+14243076;2058.372503
+14250625;3321.351246
+14258176;2075.052113
+14265729;1436.507796
+14273284;2236.571308
+14280841;2427.579621
+14288400;2151.135321
+14295961;2129.320906
+14303524;1169.503209
+14311089;2332.137000
+14318656;1061.044457
+14326225;1178.190119
+14333796;3772.243425
+14341369;3159.850586
+14348944;2697.439587
+14356521;2179.491364
+14364100;3837.004783
+14371681;2421.459289
+14379264;5483.759419
+14386849;2059.382862
+14394436;2814.613381
+14402025;2686.413417
+14409616;2606.324280
+14417209;2227.557874
+14424804;3323.827084
+14432401;3170.337449
+14440000;2441.531498
+14447601;1794.973826
+14455204;1271.610839
+14462809;3527.057652
+14470416;1703.529201
+14478025;1980.010328
+14485636;2795.973034
+14493249;2405.708412
+14500864;1514.929856
+14508481;2072.339670
+14516100;2237.360529
+14523721;2307.575646
+14531344;2138.093448
+14538969;2009.073321
+14546596;1923.056501
+14554225;2202.702352
+14561856;2076.486996
+14569489;1734.352073
+14577124;1229.966285
+14584761;1215.976610
+14592400;1690.350221
+14600041;2093.009235
+14607684;2051.888329
+14615329;1964.446739
+14622976;1591.290162
+14630625;1100.852803
+14638276;1181.290276
+14645929;1365.694966
+14653584;1713.734891
+14661241;1613.529503
+14668900;1812.303188
+14676561;2394.591595
+14684224;1884.324321
+14691889;1703.946008
+14699556;1093.076153
+14707225;1188.808269
+14714896;1790.118454
+14722569;1515.395359
+14730244;1652.960191
+14737921;1656.132624
+14745600;1249.321006
+14753281;1406.776275
+14760964;1209.196259
+14768649;2066.899894
+14776336;1648.685386
+14784025;1835.229002
+14791716;1511.864552
+14799409;1829.991677
+14807104;1137.898365
+14814801;2003.993322
+14822500;1543.701697
+14830201;1818.463549
+14837904;1129.165934
+14845609;1515.738040
+14853316;2118.070139
+14861025;1973.634032
+14868736;1267.840525
+14876449;1095.248617
+14884164;1783.950654
+14891881;1223.702334
+14899600;1953.119900
+14907321;1908.595027
+14915044;1282.991945
+14922769;1658.442187
+14930496;1963.230614
+14938225;1163.817126
+14945956;1762.308968
+14953689;1220.957929
+14961424;1815.302074
+14969161;1860.634669
+14976900;1334.965390
+14984641;1658.068063
+14992384;1136.719922
+15000129;1739.120123
+15007876;1004.695232
+15015625;1084.249361
+15023376;1058.813041
+15031129;1366.664700
+15038884;1610.986529
+15046641;1140.340069
+15054400;1216.015051
+15062161;1808.067026
+15069924;1460.799075
+15077689;1193.224929
+15085456;2094.525147
+15093225;1187.611310
+15100996;1754.937083
+15108769;2049.500856
+15116544;1394.939910
+15124321;1983.905927
+15132100;1903.186604
+15139881;2006.828962
+15147664;1816.607424
+15155449;1301.513219
+15163236;1565.829469
+15171025;1994.204641
+15178816;1548.040149
+15186609;1689.089787
+15194404;1937.497818
+15202201;1882.788621
+15210000;1416.116269
+15217801;1076.195409
+15225604;1826.928377
+15233409;2116.819945
+15241216;1480.255076
+15249025;1838.656659
+15256836;1679.895913
+15264649;1601.946831
+15272464;1588.157725
+15280281;1189.466090
+15288100;1272.434808
+15295921;1836.357527
+15303744;1251.947163
+15311569;1996.201572
+15319396;1138.639412
+15327225;1959.992595
+15335056;1259.897068
+15342889;1578.275795
+15350724;1976.720922
+15358561;2046.065298
+15366400;1597.728250
+15374241;1219.957946
+15382084;1924.501349
+15389929;1955.707407
+15397776;1142.851797
+15405625;1113.678734
+15413476;2016.821601
+15421329;1052.175127
+15429184;2026.228218
+15437041;1907.209528
+15444900;1856.308783
+15452761;1962.149653
+15460624;1302.216354
+15468489;2066.108587
+15476356;2167.784136
+15484225;1709.533989
+15492096;2541.149091
+15499969;1935.215079
+15507844;2024.901610
+15515721;1969.924578
+15523600;1938.525923
+15531481;2114.469293
+15539364;1245.303099
+15547249;1841.085309
+15555136;1521.326803
+15563025;1800.034442
+15570916;1580.885602
+15578809;2024.207877
+15586704;1584.954791
+15594601;1145.530795
+15602500;1665.958171
+15610401;1017.852489
+15618304;2051.031622
+15626209;1966.906523
+15634116;2081.911445
+15642025;2038.148321
+15649936;1129.714261
+15657849;1201.657836
+15665764;1533.160354
+15673681;2015.384350
+15681600;2044.719937
+15689521;1149.421229
+15697444;1019.348148
+15705369;1954.645044
+15713296;1540.914078
+15721225;1954.976865
+15729156;2070.252633
+15737089;1165.912699
+15745024;2020.026687
+15752961;1372.926397
+15760900;1063.097075
+15768841;2019.968057
+15776784;1396.784346
+15784729;1199.965281
+15792676;1134.709652
+15800625;2124.703628
+15808576;1324.056460
+15816529;1940.899643
+15824484;1815.988241
+15832441;2043.010397
+15840400;1790.993267
+15848361;2038.652284
+15856324;1186.940168
+15864289;2100.641786
+15872256;1840.705200
+15880225;2151.597365
+15888196;1914.843598
+15896169;2114.962839
+15904144;1543.909283
+15912121;2101.803800
+15920100;1182.116987
+15928081;2095.809734
+15936064;1089.165480
+15944049;2066.655365
+15952036;2046.488640
+15960025;2020.757544
+15968016;2143.534815
+15976009;1514.890499
+15984004;1122.963136
+15992001;1058.806990
+16000000;1240.228604
+16008001;1472.874252
+16016004;1643.010424
+16024009;1587.403532
+16032016;1921.155608
+16040025;1411.319510
+16048036;1936.090119
+16056049;1942.392761
+16064064;1894.803874
+16072081;1058.173909
+16080100;1390.795883
+16088121;1275.013437
+16096144;1907.193686
+16104169;1948.066632
+16112196;1995.046942
+16120225;2096.785694
+16128256;1552.961377
+16136289;1078.580872
+16144324;2073.437085
+16152361;2035.699460
+16160400;2000.732086
+16168441;2036.571052
+16176484;1290.193714
+16184529;2072.112199
+16192576;2123.466972
+16200625;1890.452068
+16208676;2173.475211
+16216729;1936.822300
+16224784;2156.725881
+16232841;1901.066190
+16240900;2183.977068
+16248961;2174.825417
+16257024;1975.346521
+16265089;2087.726876
+16273156;1135.147778
+16281225;1201.665950
+16289296;2074.634978
+16297369;2186.836875
+16305444;1167.325486
+16313521;1633.763332
+16321600;1082.480279
+16329681;1528.263014
+16337764;1098.360405
+16345849;1559.209496
+16353936;1400.875538
+16362025;1096.760042
+16370116;1569.070510
+16378209;1712.641095
+16386304;1446.146158
+16394401;1987.135392
+16402500;2016.430735
+16410601;1283.778327
+16418704;1984.289660
+16426809;2085.246758
+16434916;2111.360374
+16443025;2040.807896
+16451136;1545.063836
+16459249;1576.063594
+16467364;2099.357096
+16475481;2036.617572
+16483600;1911.713029
+16491721;1126.814413
+16499844;2146.091855
+16507969;2095.218932
+16516096;2143.771201
+16524225;2105.709857
+16532356;2102.677145
+16540489;1997.230805
+16548624;2172.354101
+16556761;1471.809592
+16564900;2091.662129
+16573041;1816.964059
+16581184;1979.572122
+16589329;2021.096631
+16597476;2065.479759
+16605625;2171.605176
+16613776;1977.678116
+16621929;1228.532086
+16630084;1780.106915
+16638241;2086.293693
+16646400;1337.415361
+16654561;1343.687135
+16662724;2144.594360
+16670889;1619.050879
+16679056;1029.201375
+16687225;2105.643844
+16695396;2146.812075
+16703569;1969.192955
+16711744;1139.596479
+16719921;1447.408464
+16728100;928.023741
+16736281;1073.541886
+16744464;2054.035375
+16752649;2038.723041
+16760836;2063.236617
+16769025;2055.366653
+16777216;2022.676268
+16785409;1941.672172
+16793604;2035.984468
+16801801;1253.032153
+16810000;1115.134988
+16818201;2063.553970
+16826404;1796.519187
+16834609;1918.012423
+16842816;2103.303220
+16851025;2112.420541
+16859236;1008.042130
+16867449;2067.873698
+16875664;2009.027599
+16883881;2011.999225
+16892100;2108.944378
+16900321;2121.095764
+16908544;2157.977164
+16916769;1746.940805
+16924996;2277.283547
+16933225;1122.098956
+16941456;2131.678647
+16949689;2084.047704
+16957924;1705.901132
+16966161;1347.313989
+16974400;1335.639260
+16982641;3469.962449
+16990884;3664.734910
+16999129;3311.409743
+17007376;2941.841765
+17015625;2457.751072
+17023876;2553.160669
+17032129;2403.976382
+17040384;1258.671125
+17048641;2365.453843
+17056900;2496.154411
+17065161;2497.712728
+17073424;2576.775920
+17081689;2716.897378
+17089956;3663.318775
+17098225;2278.826590
+17106496;2255.407488
+17114769;2283.035087
+17123044;2720.335420
+17131321;2433.001688
+17139600;2129.854965
+17147881;1778.432981
+17156164;2423.655586
+17164449;2221.160186
+17172736;2558.370567
+17181025;2348.038552
+17189316;2235.202868
+17197609;2185.263060
+17205904;1981.604356
+17214201;1113.203623
+17222500;1981.535812
+17230801;1638.979490
+17239104;2130.792708
+17247409;1878.544362
+17255716;1371.684228
+17264025;1994.855403
+17272336;1813.335661
+17280649;1995.939126
+17288964;2140.393732
+17297281;2187.886617
+17305600;1525.849374
+17313921;2077.238873
+17322244;2011.614243
+17330569;1457.422686
+17338896;2129.778643
+17347225;1794.601821
+17355556;2048.645171
+17363889;2250.926768
+17372224;1702.269971
+17380561;2236.300550
+17388900;2298.430469
+17397241;1596.275886
+17405584;2178.938162
+17413929;2358.230239
+17422276;2184.568052
+17430625;2232.822692
+17438976;1739.962974
+17447329;1945.941014
+17455684;1214.343014
+17464041;2269.104990
+17472400;2034.509846
+17480761;1997.272868
+17489124;1967.447717
+17497489;1891.473927
+17505856;2773.895184
+17514225;2122.105438
+17522596;2115.244055
+17530969;1921.495692
+17539344;1723.440818
+17547721;2090.848903
+17556100;2164.087960
+17564481;1943.165743
+17572864;2151.441665
+17581249;1127.718788
+17589636;2194.414240
+17598025;1069.498912
+17606416;1603.790786
+17614809;2427.161496
+17623204;2241.548185
+17631601;1458.319135
+17640000;1093.778051
+17648401;2130.042990
+17656804;3775.994120
+17665209;2043.189341
+17673616;2116.176203
+17682025;1580.302130
+17690436;1270.679486
+17698849;1095.515920
+17707264;2437.065152
+17715681;1705.145242
+17724100;1412.196077
+17732521;2050.279458
+17740944;1928.625224
+17749369;1879.400883
+17757796;2179.058570
+17766225;2724.498363
+17774656;2381.954130
+17783089;1933.168774
+17791524;2121.807595
+17799961;2751.776355
+17808400;2467.441567
+17816841;1072.310776
+17825284;2322.897500
+17833729;2263.472346
+17842176;2518.510711
+17850625;2427.740629
+17859076;2345.498287
+17867529;2359.069009
+17875984;2588.556785
+17884441;1828.636298
+17892900;2355.110216
+17901361;2530.624610
+17909824;2907.991033
+17918289;2279.416872
+17926756;2537.064657
+17935225;2519.603390
+17943696;1598.112184
+17952169;1878.748709
+17960644;1182.181742
+17969121;2612.651786
+17977600;2299.058356
+17986081;2239.278284
+17994564;2581.184378
+18003049;2274.648776
+18011536;2370.340094
+18020025;2082.165719
+18028516;1198.049399
+18037009;2656.820267
+18045504;2364.482591
+18054001;1469.071126
+18062500;2301.802894
+18071001;2401.713128
+18079504;2481.589040
+18088009;1189.735374
+18096516;2439.814394
+18105025;2486.104738
+18113536;2276.828894
+18122049;2139.584374
+18130564;2253.622073
+18139081;1871.049694
+18147600;2445.310549
+18156121;1951.742608
+18164644;1967.776436
+18173169;2482.146595
+18181696;1904.612346
+18190225;1543.546034
+18198756;2516.060924
+18207289;2144.633707
+18215824;2099.258628
+18224361;1994.081263
+18232900;1583.178186
+18241441;1800.306157
+18249984;2356.439601
+18258529;1460.566605
+18267076;1983.683733
+18275625;2443.659323
+18284176;2188.264684
+18292729;2393.552974
+18301284;1971.402551
+18309841;2242.289639
+18318400;1936.800401
+18326961;1721.576118
+18335524;1599.739275
+18344089;1991.898706
+18352656;2494.675122
+18361225;1787.902480
+18369796;1650.468521
+18378369;2296.499906
+18386944;1108.579217
+18395521;1648.860490
+18404100;2011.744388
+18412681;2109.923469
+18421264;1960.957169
+18429849;1955.181353
+18438436;2223.697405
+18447025;1873.035553
+18455616;2393.486978
+18464209;2332.612686
+18472804;2052.206312
+18481401;2227.653620
+18490000;1142.487378
+18498601;1180.489498
+18507204;1282.008233
+18515809;1998.480746
+18524416;2066.073147
+18533025;1755.097260
+18541636;2190.375836
+18550249;2501.387372
+18558864;2320.446550
+18567481;2046.183308
+18576100;2442.574420
+18584721;2151.928540
+18593344;1584.164563
+18601969;1121.694922
+18610596;2030.704793
+18619225;2308.472032
+18627856;2151.457159
+18636489;2284.390363
+18645124;2172.036355
+18653761;2213.580353
+18662400;1794.769694
+18671041;2277.799009
+18679684;2078.689628
+18688329;1995.732686
+18696976;1426.949456
+18705625;1053.778938
+18714276;2300.344070
+18722929;2361.191136
+18731584;2011.403676
+18740241;2219.978642
+18748900;1152.670768
+18757561;2462.348946
+18766224;2391.321031
+18774889;2243.803785
+18783556;2150.541537
+18792225;2029.571644
+18800896;2139.471074
+18809569;2264.480325
+18818244;2419.617037
+18826921;2278.030175
+18835600;2241.474754
+18844281;2264.525462
+18852964;2056.882123
+18861649;2403.587716
+18870336;1950.318791
+18879025;2363.859685
+18887716;2252.673106
+18896409;2357.768455
+18905104;1668.183010
+18913801;2108.699594
+18922500;1621.552316
+18931201;1109.071161
+18939904;2077.592550
+18948609;1988.257724
+18957316;2096.229528
+18966025;2440.786901
+18974736;2084.814791
+18983449;2248.825617
+18992164;2359.969092
+19000881;1088.512957
+19009600;1786.304752
+19018321;2379.127255
+19027044;2333.932263
+19035769;2259.423796
+19044496;2367.145017
+19053225;2393.515257
+19061956;2221.789255
+19070689;1092.158963
+19079424;1972.304080
+19088161;2340.365851
+19096900;1978.171392
+19105641;1839.906892
+19114384;2303.380234
+19123129;2392.954092
+19131876;1353.981192
+19140625;2035.117670
+19149376;1937.182888
+19158129;2265.315566
+19166884;2061.901104
+19175641;1069.453670
+19184400;2192.580608
+19193161;1840.104741
+19201924;1055.432681
+19210689;2217.469666
+19219456;2315.114456
+19228225;1677.799638
+19236996;2062.618929
+19245769;2176.786262
+19254544;1097.376325
+19263321;1590.905570
+19272100;2248.001978
+19280881;2158.557749
+19289664;2327.998580
+19298449;1679.919571
+19307236;2296.797315
+19316025;1979.024043
+19324816;1920.257200
+19333609;2244.754381
+19342404;2388.334764
+19351201;1834.649902
+19360000;2281.704789
+19368801;1862.985910
+19377604;2286.056945
+19386409;2245.178248
+19395216;2558.231282
+19404025;1491.472395
+19412836;2426.596509
+19421649;2374.763445
+19430464;2025.654881
+19439281;1526.056637
+19448100;2176.806184
+19456921;1708.749202
+19465744;2255.935605
+19474569;2012.599465
+19483396;2047.719402
+19492225;2100.103860
+19501056;1910.316755
+19509889;2332.361736
+19518724;2197.935109
+19527561;2129.305999
+19536400;1877.429241
+19545241;2232.872051
+19554084;2283.118558
+19562929;2383.061878
+19571776;2181.704289
+19580625;2089.551406
+19589476;2370.743029
+19598329;2123.339133
+19607184;1766.408937
+19616041;2156.848942
+19624900;2126.100817
+19633761;1821.867214
+19642624;2185.957405
+19651489;2254.261016
+19660356;1980.223841
+19669225;2241.648535
+19678096;1886.920660
+19686969;1060.912343
+19695844;2218.386092
+19704721;2314.401582
+19713600;2179.144655
+19722481;2337.210420
+19731364;2275.654165
+19740249;2283.731156
+19749136;1858.846656
+19758025;2268.294115
+19766916;2335.326221
+19775809;1653.008921
+19784704;2069.163709
+19793601;2181.663379
+19802500;2189.142910
+19811401;2118.828855
+19820304;2192.508691
+19829209;2216.918812
+19838116;2282.014110
+19847025;2286.419372
+19855936;2395.866800
+19864849;2216.473809
+19873764;1179.849768
+19882681;2035.895458
+19891600;1653.724721
+19900521;2306.803343
+19909444;1913.996393
+19918369;1586.842166
+19927296;2141.172654
+19936225;2212.858091
+19945156;2197.750829
+19954089;1695.623359
+19963024;2169.107456
+19971961;2363.192241
+19980900;2234.892440
+19989841;2210.895499
+19998784;1885.515348
+20007729;2262.247732
+20016676;2204.579963
+20025625;2081.618918
+20034576;1698.623186
+20043529;1826.889400
+20052484;2480.931920
+20061441;2236.937190
+20070400;2134.134884
+20079361;2238.024267
+20088324;1994.717040
+20097289;1885.428392
+20106256;2151.728101
+20115225;2275.501430
+20124196;2212.186175
+20133169;2196.455952
+20142144;2179.446089
+20151121;2064.702655
+20160100;2000.252840
+20169081;2058.483964
+20178064;2234.054566
+20187049;2023.913152
+20196036;1343.148367
+20205025;2006.525971
+20214016;2092.348200
+20223009;2428.677884
+20232004;2320.064545
+20241001;2370.825110
+20250000;2150.557957
+20259001;2164.976992
+20268004;2026.477937
+20277009;2295.345911
+20286016;1955.489482
+20295025;2290.404309
+20304036;2292.508791
+20313049;2225.879309
+20322064;2211.335647
+20331081;2578.448748
+20340100;2133.974641
+20349121;2124.532079
+20358144;2074.410845
+20367169;2143.488772
+20376196;2096.213131
+20385225;2063.175492
+20394256;2229.095078
+20403289;3181.857749
+20412324;2066.809878
+20421361;2107.848269
+20430400;1184.112413
+20439441;2158.603935
+20448484;2233.653761
+20457529;2199.131100
+20466576;2369.094752
+20475625;1925.187002
+20484676;3056.881091
+20493729;2693.358607
+20502784;2489.458129
+20511841;2292.933502
+20520900;2184.866980
+20529961;2218.083183
+20539024;2390.573950
+20548089;2249.347003
+20557156;1661.599145
+20566225;2239.526458
+20575296;2375.289242
+20584369;1949.088997
+20593444;2351.455261
+20602521;1944.744808
+20611600;2305.407973
+20620681;2255.267394
+20629764;2267.081448
+20638849;2318.915389
+20647936;2258.302503
+20657025;2286.131346
+20666116;2030.002964
+20675209;1118.377519
+20684304;2317.646622
+20693401;2231.759537
+20702500;2220.097157
+20711601;2185.213746
+20720704;2362.683122
+20729809;2166.605703
+20738916;1580.788118
+20748025;2314.891261
+20757136;2070.868396
+20766249;2376.957921
+20775364;1714.364296
+20784481;2067.132575
+20793600;2294.845767
+20802721;2243.249330
+20811844;2175.037747
+20820969;2193.764151
+20830096;1994.014470
+20839225;2460.077752
+20848356;2475.341900
+20857489;2273.886106
+20866624;2205.885213
+20875761;2015.609494
+20884900;2237.709730
+20894041;2164.133851
+20903184;2117.051689
+20912329;2276.493576
+20921476;2042.119316
+20930625;1104.489250
+20939776;2214.301005
+20948929;2200.190428
+20958084;1993.342256
+20967241;1145.855390
+20976400;2203.759897
+20985561;1724.810960
+20994724;1544.725177
+21003889;1858.005301
+21013056;1995.521662
+21022225;1325.590936
+21031396;2385.038375
+21040569;2342.912289
+21049744;2134.730272
+21058921;2145.019034
+21068100;2221.903164
+21077281;2026.829265
+21086464;2382.608286
+21095649;2177.529588
+21104836;2306.243305
+21114025;2212.400841
+21123216;1810.857194
+21132409;2135.402046
+21141604;1575.449394
+21150801;2228.305619
+21160000;2303.167606
+21169201;2290.826751
+21178404;2230.624943
+21187609;2267.760411
+21196816;2285.112762
+21206025;1213.068621
+21215236;2077.921051
+21224449;2150.685160
+21233664;2442.598453
+21242881;2194.734022
+21252100;2198.517502
+21261321;2323.116575
+21270544;2406.755514
+21279769;2527.794767
+21288996;2267.348810
+21298225;2073.067502
+21307456;1458.500522
+21316689;2318.012505
+21325924;1962.161066
+21335161;2182.108002
+21344400;1924.529910
+21353641;2301.735301
+21362884;1974.300883
+21372129;2250.120190
+21381376;2194.697577
+21390625;2110.352991
+21399876;2274.506443
+21409129;2256.331672
+21418384;1704.361237
+21427641;1916.637256
+21436900;2360.482422
+21446161;2113.860511
+21455424;2232.975667
+21464689;2235.848493
+21473956;2322.031952
+21483225;2346.248435
+21492496;1686.989113
+21501769;2039.072012
+21511044;2403.098808
+21520321;1963.821111
+21529600;2516.486967
+21538881;1743.815214
+21548164;2285.912358
+21557449;2305.419053
+21566736;2191.124109
+21576025;2327.695654
+21585316;2446.511487
+21594609;2174.013951
+21603904;2374.401011
+21613201;2263.976458
+21622500;2244.964107
+21631801;2296.468923
+21641104;2440.182378
+21650409;2188.471598
+21659716;2197.134616
+21669025;2053.212880
+21678336;2162.259359
+21687649;2244.900312
+21696964;2211.156988
+21706281;2418.568910
+21715600;1103.714847
+21724921;2215.821340
+21734244;2487.561955
+21743569;2345.670948
+21752896;2198.908206
+21762225;1153.507692
+21771556;2335.590936
+21780889;2291.009830
+21790224;2321.341698
+21799561;1725.089504
+21808900;2455.560420
+21818241;2147.164653
+21827584;2197.096090
+21836929;2281.542923
+21846276;2354.271643
+21855625;2309.251711
+21864976;1881.448201
+21874329;2859.963793
+21883684;2890.641625
+21893041;2103.818278
+21902400;2198.740849
+21911761;1895.694370
+21921124;2257.824735
+21930489;2732.666738
+21939856;2595.869325
+21949225;2611.888640
+21958596;2230.027878
+21967969;2747.370586
+21977344;1751.352864
+21986721;2371.501576
+21996100;2751.576564
+22005481;2214.464271
+22014864;2554.731453
+22024249;1979.792255
+22033636;2155.143103
+22043025;2342.985848
+22052416;2164.660504
+22061809;2570.427773
+22071204;2162.740486
+22080601;2544.558611
+22090000;2183.529102
+22099401;2596.093049
+22108804;2254.077370
+22118209;2341.021673
+22127616;2206.266332
+22137025;2337.095429
+22146436;2272.858483
+22155849;2216.858240
+22165264;1425.876389
+22174681;2324.430756
+22184100;2566.207108
+22193521;2162.439652
+22202944;2448.403572
+22212369;2578.075869
+22221796;2265.222274
+22231225;2024.820285
+22240656;2381.537859
+22250089;2246.509074
+22259524;2170.212766
+22268961;2689.214307
+22278400;2190.008300
+22287841;2363.565551
+22297284;2213.155783
+22306729;2201.298647
+22316176;2280.440370
+22325625;2267.287881
+22335076;2197.443466
+22344529;2402.510925
+22353984;2323.389871
+22363441;2683.923346
+22372900;2276.834556
+22382361;2488.022462
+22391824;2407.775392
+22401289;2648.080555
+22410756;2337.962609
+22420225;2137.272314
+22429696;2265.861310
+22439169;2189.791419
+22448644;1756.394793
+22458121;2177.921081
+22467600;1874.668630
+22477081;3278.686318
+22486564;3412.415545
+22496049;2294.998760
+22505536;2150.743290
+22515025;2217.793128
+22524516;2273.620503
+22534009;2112.249045
+22543504;2177.174202
+22553001;2198.909882
+22562500;2262.253470
+22572001;3726.569406
+22581504;3549.398686
+22591009;2062.472822
+22600516;1962.148260
+22610025;3642.234965
+22619536;1965.598355
+22629049;5795.220225
+22638564;1142.905457
+22648081;3845.231450
+22657600;2482.842914
+22667121;2342.592716
+22676644;3254.969660
+22686169;2428.015154
+22695696;2607.858661
+22705225;3064.391857
+22714756;2064.340588
+22724289;4023.658139
+22733824;3047.170030
+22743361;2061.727038
+22752900;3034.399254
+22762441;4160.116508
+22771984;3430.590742
+22781529;3442.764718
+22791076;2395.525565
+22800625;3990.060091
+22810176;3815.607436
+22819729;4061.810515
+22829284;3036.528692
+22838841;3098.304854
+22848400;4166.538743
+22857961;2031.783594
+22867524;2795.155551
+22877089;3123.228140
+22886656;2590.999231
+22896225;3964.013132
+22905796;3127.919958
+22915369;3096.136586
+22924944;3827.868925
+22934521;3023.679172
+22944100;3340.052243
+22953681;3085.967907
+22963264;3590.632952
+22972849;3217.249360
+22982436;3085.397435
+22992025;3039.415539
+23001616;2777.863234
+23011209;3142.796771
+23020804;2473.347865
+23030401;4052.495981
+23040000;2144.233918
+23049601;2825.292703
+23059204;3541.280740
+23068809;4058.520362
+23078416;3021.935418
+23088025;2024.174429
+23097636;3157.974182
+23107249;2050.075737
+23116864;3023.425916
+23126481;2123.662988
+23136100;4020.704401
+23145721;2711.375583
+23155344;3310.121870
+23164969;4053.670231
+23174596;2583.046920
+23184225;4053.327209
+23193856;3730.851745
+23203489;4040.795759
+23213124;3999.619284
+23222761;2973.184573
+23232400;3872.809428
+23242041;3854.105434
+23251684;4163.686872
+23261329;4008.829546
+23270976;2103.499707
+23280625;4003.986681
+23290276;4150.877646
+23299929;2925.399028
+23309584;2201.685242
+23319241;3723.810541
+23328900;4108.871872
+23338561;3026.417287
+23348224;3926.892865
+23357889;2704.711424
+23367556;3225.248003
+23377225;3999.996148
+23386896;2842.974757
+23396569;3029.757484
+23406244;3863.588495
+23415921;2098.600592
+23425600;3587.531245
+23435281;4005.041604
+23444964;3072.493343
+23454649;3115.599510
+23464336;4050.398527
+23474025;2203.393972
+23483716;3343.548629
+23493409;3959.208337
+23503104;3845.017718
+23512801;3178.825032
+23522500;3139.534616
+23532201;4113.113274
+23541904;4052.251609
+23551609;2829.562215
+23561316;2000.910203
+23571025;3933.194008
+23580736;3827.093630
+23590449;4327.036475
+23600164;3199.141682
+23609881;3615.385061
+23619600;2965.879413
+23629321;3797.855035
+23639044;3719.845905
+23648769;3233.704761
+23658496;3970.765369
+23668225;3718.489672
+23677956;3605.757156
+23687689;4032.312637
+23697424;4116.063369
+23707161;4329.824542
+23716900;3000.192620
+23726641;3024.821658
+23736384;3756.367741
+23746129;2923.201769
+23755876;4039.810125
+23765625;3518.400100
+23775376;3120.054359
+23785129;3042.295045
+23794884;2958.827909
+23804641;3032.894640
+23814400;3262.347835
+23824161;4129.669925
+23833924;3345.028862
+23843689;4105.687927
+23853456;3028.509516
+23863225;2094.333439
+23872996;4160.122954
+23882769;3106.725885
+23892544;3828.971290
+23902321;4117.437684
+23912100;3271.838275
+23921881;3956.987075
+23931664;2884.007572
+23941449;2782.062625
+23951236;3614.778200
+23961025;4171.949647
+23970816;3967.602786
+23980609;3677.863863
+23990404;3188.516521
+24000201;2965.328320
+24010000;3592.464711
+24019801;3925.808507
+24029604;4079.952185
+24039409;3382.332673
+24049216;3970.400095
+24059025;3105.350582
+24068836;4203.217629
+24078649;1820.958013
+24088464;3195.098930
+24098281;3264.232541
+24108100;4084.732911
+24117921;3952.055848
+24127744;3780.263532
+24137569;3619.583995
+24147396;3775.822225
+24157225;2786.271241
+24167056;4114.441576
+24176889;4161.871438
+24186724;3026.603588
+24196561;4059.477986
+24206400;2063.562941
+24216241;4174.645953
+24226084;3533.710754
+24235929;3993.728366
+24245776;3879.172338
+24255625;2026.734608
+24265476;3094.045074
+24275329;3527.667234
+24285184;4124.916763
+24295041;3927.432545
+24304900;3022.259287
+24314761;3790.529461
+24324624;3650.562279
+24334489;3116.808812
+24344356;3138.492975
+24354225;2578.599470
+24364096;4097.827327
+24373969;3267.955508
+24383844;3772.799400
+24393721;4081.882656
+24403600;3096.933079
+24413481;3378.130293
+24423364;3212.229136
+24433249;4154.571260
+24443136;4088.064045
+24453025;3872.628957
+24462916;4078.787520
+24472809;3750.502956
+24482704;4007.665290
+24492601;3377.507152
+24502500;3958.959773
+24512401;4123.565541
+24522304;3308.149770
+24532209;2103.513366
+24542116;3778.728117
+24552025;2733.920368
+24561936;3530.869291
+24571849;3513.464078
+24581764;3063.036149
+24591681;3997.492907
+24601600;3041.210324
+24611521;3593.226904
+24621444;3092.851314
+24631369;4055.343755
+24641296;4032.059894
+24651225;3760.929067
+24661156;4122.286384
+24671089;3885.047425
+24681024;3055.964588
+24690961;3839.254903
+24700900;2934.782373
+24710841;4042.257480
+24720784;2100.980796
+24730729;2339.943461
+24740676;4227.915398
+24750625;4086.557001
+24760576;2131.160630
+24770529;3154.474832
+24780484;4205.779765
+24790441;2245.431487
+24800400;3962.869523
+24810361;3035.844487
+24820324;3959.689247
+24830289;3093.937273
+24840256;2099.523677
+24850225;4090.289359
+24860196;3921.842894
+24870169;3027.243360
+24880144;4075.763820
+24890121;4087.838853
+24900100;3032.589927
+24910081;2512.261515
+24920064;4184.977819
+24930049;2017.857475
+24940036;2717.477747
+24950025;4113.151178
+24960016;3742.868040
+24970009;3030.620617
+24980004;4059.175926
+24990001;3194.324944
+25000000;4199.524228
+25010001;2640.925585
+25020004;2511.980816
+25030009;4050.918895
+25040016;4003.209242
+25050025;4133.798716
+25060036;1452.728311
+25070049;3120.636312
+25080064;3132.901330
+25090081;4090.841712
+25100100;3773.576505
+25110121;3177.206410
+25120144;4063.113694
+25130169;4079.679601
+25140196;2729.424800
+25150225;3869.710385
+25160256;3404.444635
+25170289;3047.003968
+25180324;3023.101786
+25190361;3086.988469
+25200400;4034.277170
+25210441;2464.623520
+25220484;4103.105948
+25230529;3537.191187
+25240576;4062.228311
+25250625;4120.033036
+25260676;4149.695603
+25270729;4111.070451
+25280784;4054.594904
+25290841;4074.657408
+25300900;3962.065807
+25310961;4066.170487
+25321024;3632.611581
+25331089;4137.366909
+25341156;4163.385471
+25351225;3032.966692
+25361296;3942.558708
+25371369;2636.360817
+25381444;4146.238796
+25391521;3883.201492
+25401600;3021.127249
+25411681;2843.952677
+25421764;2510.790303
+25431849;3707.037738
+25441936;3719.021362
+25452025;3102.914913
+25462116;1955.669457
+25472209;3092.121395
+25482304;3859.178543
+25492401;3059.538477
+25502500;4051.375633
+25512601;2448.685514
+25522704;3040.867601
+25532809;3924.508218
+25542916;3069.468313
+25553025;4062.921814
+25563136;4027.937721
+25573249;3152.296467
+25583364;3273.934792
+25593481;4108.771580
+25603600;4149.356269
+25613721;3062.445129
+25623844;1492.196171
+25633969;4141.233409
+25644096;3173.011413
+25654225;2646.800506
+25664356;2717.252170
+25674489;3112.895650
+25684624;3303.733804
+25694761;4115.769575
+25704900;4090.835898
+25715041;4152.821162
+25725184;4091.023910
+25735329;3121.798457
+25745476;3525.478013
+25755625;3508.975182
+25765776;3103.596330
+25775929;2131.201781
+25786084;4306.632255
+25796241;3104.291618
+25806400;3037.168857
+25816561;3815.368481
+25826724;4104.577362
+25836889;3168.648594
+25847056;4156.651661
+25857225;4153.870556
+25867396;4084.679469
+25877569;4224.840655
+25887744;3043.540085
+25897921;2819.803519
+25908100;3542.895965
+25918281;2874.246621
+25928464;2368.438568
+25938649;4110.614524
+25948836;3220.246820
+25959025;4122.369763
+25969216;4082.686325
+25979409;4092.482345
+25989604;3084.934469
+25999801;3158.808274
+26010000;3977.964286
+26020201;4088.939674
+26030404;3135.611744
+26040609;4153.549865
+26050816;4171.948616
+26061025;3426.232882
+26071236;3742.720700
+26081449;3154.630341
+26091664;3908.470300
+26101881;4032.038911
+26112100;3093.998881
+26122321;4157.687124
+26132544;2865.159222
+26142769;2124.627753
+26152996;4244.576160
+26163225;4120.862576
+26173456;4081.562966
+26183689;4271.598763
+26193924;3117.681908
+26204161;2144.343265
+26214400;2970.928798
+26224641;3953.265684
+26234884;2999.567880
+26245129;4046.449108
+26255376;4020.061889
+26265625;4099.133369
+26275876;2941.159696
+26286129;3535.921144
+26296384;4474.668744
+26306641;4096.312838
+26316900;4032.752449
+26327161;4100.788092
+26337424;4104.872622
+26347689;4117.933074
+26357956;4096.380618
+26368225;3866.356437
+26378496;3715.735949
+26388769;4026.445010
+26399044;3364.348244
+26409321;1615.673269
+26419600;3956.890114
+26429881;2158.681776
+26440164;4650.099071
+26450449;3982.892299
+26460736;3224.601675
+26471025;4097.140273
+26481316;4066.664506
+26491609;2782.503221
+26501904;4029.321279
+26512201;4548.101118
+26522500;3887.680173
+26532801;3154.749971
+26543104;4541.226114
+26553409;4309.410537
+26563716;3268.762376
+26574025;4082.045876
+26584336;3050.042904
+26594649;3932.577582
+26604964;4100.193161
+26615281;3492.433326
+26625600;3959.670607
+26635921;2918.084229
+26646244;4073.575453
+26656569;4072.704453
+26666896;1641.607795
+26677225;4110.899051
+26687556;3796.717451
+26697889;3211.473319
+26708224;3196.579273
+26718561;4054.518213
+26728900;4159.865513
+26739241;4574.228799
+26749584;2885.983277
+26759929;3300.240427
+26770276;4177.386550
+26780625;4087.597860
+26790976;3076.542550
+26801329;3676.891968
+26811684;2617.318731
+26822041;4575.441625
+26832400;2303.650438
+26842761;4073.234318
+26853124;3934.544754
+26863489;2153.130469
+26873856;4317.351119
+26884225;2722.960134
+26894596;3125.548451
+26904969;3384.788409
+26915344;4040.451143
+26925721;3065.753560
+26936100;4036.425278
+26946481;4506.124154
+26956864;2819.435527
+26967249;4060.702711
+26977636;3101.820483
+26988025;3727.875174
+26998416;4054.892959
+27008809;4086.457092
+27019204;3053.805854
+27029601;4550.203421
+27040000;3691.777641
+27050401;4533.845235
+27060804;2742.550404
+27071209;3809.079710
+27081616;4810.466490
+27092025;4736.521301
+27102436;3066.392569
+27112849;4042.945641
+27123264;3201.151930
+27133681;3756.812663
+27144100;3155.610632
+27154521;4154.935866
+27164944;3108.316714
+27175369;4069.812174
+27185796;4664.864707
+27196225;4034.796468
+27206656;3454.825911
+27217089;4114.646398
+27227524;2654.640102
+27237961;4744.682868
+27248400;4912.784117
+27258841;4569.722395
+27269284;4824.425537
+27279729;4806.564730
+27290176;4659.644744
+27300625;2734.689746
+27311076;2940.024673
+27321529;3044.800730
+27331984;3544.475081
+27342441;4565.403024
+27352900;4106.427204
+27363361;2923.585645
+27373824;4864.735522
+27384289;4524.830310
+27394756;3061.050899
+27405225;4747.058226
+27415696;3389.387643
+27426169;4650.279861
+27436644;4096.012475
+27447121;3510.367931
+27457600;4180.415385
+27468081;2086.902782
+27478564;3089.003846
+27489049;3024.967110
+27499536;4237.843065
+27510025;4664.142829
+27520516;3355.059826
+27531009;2824.920639
+27541504;3107.621489
+27552001;4079.979487
+27562500;4592.656866
+27573001;3263.994153
+27583504;2188.239933
+27594009;4588.280231
+27604516;3337.009101
+27615025;2167.003452
+27625536;4459.177415
+27636049;4354.606118
+27646564;4569.949363
+27657081;4144.346422
+27667600;4633.215148
+27678121;4082.730773
+27688644;3284.660106
+27699169;3118.792607
+27709696;3786.434309
+27720225;4154.886351
+27730756;4099.829443
+27741289;4111.264120
+27751824;4480.913939
+27762361;4474.897540
+27772900;4565.147371
+27783441;4373.703233
+27793984;2115.844759
+27804529;3249.927674
+27815076;4092.775131
+27825625;2707.399488
+27836176;3067.901450
+27846729;3392.378905
+27857284;3849.769915
+27867841;4714.361045
+27878400;3917.586648
+27888961;4562.452742
+27899524;3061.944336
+27910089;4745.999516
+27920656;3061.131847
+27931225;3514.281976
+27941796;3429.611158
+27952369;4087.738547
+27962944;3753.092127
+27973521;4021.067405
+27984100;3523.126764
+27994681;4685.268612
+28005264;3183.139249
+28015849;1052.311800
+28026436;4040.959355
+28037025;4104.621620
+28047616;3109.680435
+28058209;3156.016449
+28068804;3566.402058
+28079401;3334.816447
+28090000;4278.683279
+28100601;3182.910126
+28111204;4358.481680
+28121809;4038.872520
+28132416;4061.463850
+28143025;3089.624421
+28153636;2831.432607
+28164249;3034.602605
+28174864;2243.054838
+28185481;4100.562945
+28196100;2037.582074
+28206721;4055.768066
+28217344;4033.218237
+28227969;4466.898064
+28238596;3176.220509
+28249225;3760.433545
+28259856;3881.468438
+28270489;4826.887643
+28281124;3087.266813
+28291761;4716.711238
+28302400;4114.157329
+28313041;4201.490853
+28323684;4095.901431
+28334329;4861.797406
+28344976;4356.277104
+28355625;4794.326605
+28366276;4065.859131
+28376929;3960.669661
+28387584;3036.232431
+28398241;3659.779518
+28408900;4240.856893
+28419561;4121.407914
+28430224;4762.460306
+28440889;4039.082778
+28451556;4074.152602
+28462225;4252.343029
+28472896;3103.566439
+28483569;3813.974504
+28494244;3082.176015
+28504921;2483.530492
+28515600;4787.722114
+28526281;4835.491777
+28536964;2713.184881
+28547649;4025.218639
+28558336;4907.807140
+28569025;2104.354466
+28579716;4858.811051
+28590409;4217.459998
+28601104;4188.959600
+28611801;4371.106326
+28622500;2964.960431
+28633201;4647.630798
+28643904;4599.904210
+28654609;2323.176540
+28665316;4865.737230
+28676025;4565.832761
+28686736;4769.168541
+28697449;4414.705380
+28708164;3875.170787
+28718881;3024.954826
+28729600;4070.073503
+28740321;4109.145493
+28751044;4120.672929
+28761769;4043.436408
+28772496;4985.711743
+28783225;4131.808739
+28793956;4051.071186
+28804689;4039.052098
+28815424;4062.365747
+28826161;2779.461389
+28836900;4353.480348
+28847641;4386.832502
+28858384;4216.117747
+28869129;4709.804824
+28879876;3388.326198
+28890625;4100.920781
+28901376;4923.072007
+28912129;4394.655550
+28922884;4757.163137
+28933641;3100.968480
+28944400;5056.828860
+28955161;5036.937549
+28965924;3325.277666
+28976689;3094.438300
+28987456;4791.362494
+28998225;4123.301995
+29008996;4753.974993
+29019769;4109.325104
+29030544;4027.420460
+29041321;4852.103098
+29052100;4047.608778
+29062881;4496.210666
+29073664;4111.163257
+29084449;2981.414438
+29095236;5114.169313
+29106025;3094.324697
+29116816;3086.910564
+29127609;3099.704674
+29138404;4069.170109
+29149201;4045.905581
+29160000;3065.694763
+29170801;3399.237817
+29181604;4995.795683
+29192409;5086.224437
+29203216;4377.932493
+29214025;3045.894158
+29224836;3136.330175
+29235649;4852.902520
+29246464;3249.311434
+29257281;3847.080407
+29268100;5149.527097
+29278921;5167.916331
+29289744;4033.950916
+29300569;5204.479632
+29311396;4042.658792
+29322225;4911.336400
+29333056;4108.336806
+29343889;4607.239738
+29354724;4895.523057
+29365561;3901.376708
+29376400;4990.222978
+29387241;4959.112633
+29398084;3453.820232
+29408929;3042.730818
+29419776;2973.470788
+29430625;2608.695095
+29441476;3885.402442
+29452329;4778.324771
+29463184;2925.809881
+29474041;4441.901500
+29484900;4994.445213
+29495761;4558.341258
+29506624;4914.724655
+29517489;5378.003064
+29528356;3823.795714
+29539225;3292.439661
+29550096;3028.240417
+29560969;4686.878186
+29571844;4872.677297
+29582721;4361.521164
+29593600;5250.055209
+29604481;4920.601949
+29615364;4800.201391
+29626249;3099.671306
+29637136;3888.833054
+29648025;4866.322543
+29658916;4169.791534
+29669809;3909.512224
+29680704;3127.623787
+29691601;3137.447577
+29702500;4611.694771
+29713401;5060.149548
+29724304;4044.532141
+29735209;4937.472550
+29746116;4773.222738
+29757025;5053.701818
+29767936;4729.054133
+29778849;4712.070440
+29789764;4429.693249
+29800681;4486.828952
+29811600;3049.727595
+29822521;4324.276582
+29833444;3361.332865
+29844369;3856.765623
+29855296;1857.136829
+29866225;4790.367422
+29877156;4121.452425
+29888089;5139.618874
+29899024;3697.901734
+29909961;2085.135236
+29920900;4784.605800
+29931841;5162.896108
+29942784;3870.997609
+29953729;4851.647191
+29964676;4784.323719
+29975625;2738.334293
+29986576;5123.668533
+29997529;4957.617299
+30008484;4806.684380
+30019441;4095.311664
+30030400;4116.557576
+30041361;4733.096455
+30052324;5095.313147
+30063289;3996.659087
+30074256;4109.211315
+30085225;3516.472800
+30096196;5128.103234
+30107169;4842.983726
+30118144;3107.479689
+30129121;4995.178908
+30140100;3016.682608
+30151081;5144.132878
+30162064;5214.479809
+30173049;3347.974947
+30184036;3201.283618
+30195025;4147.484656
+30206016;4853.333017
+30217009;4238.911015
+30228004;3766.149984
+30239001;4938.660261
+30250000;4097.905358
+30261001;5066.011148
+30272004;5104.808326
+30283009;3749.033659
+30294016;2133.116115
+30305025;4966.024448
+30316036;4228.420840
+30327049;5012.791340
+30338064;5121.703274
+30349081;4119.832791
+30360100;4706.845761
+30371121;3852.523518
+30382144;5137.307744
+30393169;4046.584432
+30404196;3109.343510
+30415225;5086.484161
+30426256;3118.448725
+30437289;3342.831217
+30448324;2544.711975
+30459361;4048.098676
+30470400;4634.854938
+30481441;3105.635057
+30492484;3881.529062
+30503529;3750.423424
+30514576;4161.456737
+30525625;2064.730914
+30536676;5047.678036
+30547729;4777.933420
+30558784;5227.548583
+30569841;4141.600597
+30580900;4659.166186
+30591961;5104.387665
+30603024;2925.287906
+30614089;4066.782233
+30625156;5046.513519
+30636225;3865.270360
+30647296;3855.297430
+30658369;5187.210279
+30669444;2115.705338
+30680521;5120.619964
+30691600;4088.556216
+30702681;3963.985552
+30713764;5106.928757
+30724849;3081.536383
+30735936;5112.070014
+30747025;5137.216246
+30758116;5096.423443
+30769209;3760.538919
+30780304;5155.150760
+30791401;1095.767027
+30802500;4912.732024
+30813601;3994.172177
+30824704;5101.030081
+30835809;5116.514334
+30846916;3612.372791
+30858025;5176.322745
+30869136;5124.944317
+30880249;3208.844094
+30891364;5107.583173
+30902481;3647.201480
+30913600;4931.403512
+30924721;5111.476182
+30935844;4099.201423
+30946969;2986.876400
+30958096;4212.795208
+30969225;3378.654504
+30980356;5099.525271
+30991489;5036.838579
+31002624;4075.215570
+31013761;4762.678642
+31024900;4758.480676
+31036041;5144.238311
+31047184;5128.062358
+31058329;5115.928012
+31069476;4136.517510
+31080625;4838.607642
+31091776;4124.436262
+31102929;5164.715138
+31114084;4126.474480
+31125241;4100.621954
+31136400;4095.763495
+31147561;4338.706447
+31158724;5093.198622
+31169889;4104.029720
+31181056;4304.530413
+31192225;5114.479411
+31203396;5093.972765
+31214569;5177.858386
+31225744;3909.503282
+31236921;3584.590111
+31248100;5087.406355
+31259281;5064.689418
+31270464;4110.101349
+31281649;3114.350717
+31292836;5538.457155
+31304025;4977.051672
+31315216;4276.905762
+31326409;3815.519259
+31337604;4086.871822
+31348801;4936.657349
+31360000;4031.105080
+31371201;4082.071908
+31382404;4056.610153
+31393609;5104.718704
+31404816;4090.732500
+31416025;3953.049669
+31427236;5072.832520
+31438449;4727.881914
+31449664;4132.867164
+31460881;4993.888264
+31472100;3117.744614
+31483321;4958.670632
+31494544;3115.434328
+31505769;5116.958839
+31516996;4414.645962
+31528225;4352.459922
+31539456;4846.068977
+31550689;3493.830576
+31561924;4731.552563
+31573161;4202.619194
+31584400;3383.240850
+31595641;2781.298236
+31606884;4742.129895
+31618129;5024.852904
+31629376;4764.920740
+31640625;3321.709648
+31651876;2998.318370
+31663129;5133.954117
+31674384;4103.399465
+31685641;4716.006484
+31696900;5101.691952
+31708161;4042.284911
+31719424;4057.143961
+31730689;4927.073594
+31741956;5053.157860
+31753225;4064.853244
+31764496;4183.777677
+31775769;5105.363762
+31787044;5099.055647
+31798321;4458.553231
+31809600;3760.654285
+31820881;5055.268445
+31832164;3783.543487
+31843449;3027.745821
+31854736;3327.627226
+31866025;5158.807473
+31877316;4857.153277
+31888609;5084.939769
+31899904;2800.008508
+31911201;3792.720810
+31922500;4290.482244
+31933801;5112.310924
+31945104;4636.515492
+31956409;4684.216741
+31967716;5065.104150
+31979025;5025.260858
+31990336;3219.987193
+32001649;3529.124187
+32012964;5104.666135
+32024281;4126.693161
+32035600;4238.140861
+32046921;4716.419236
+32058244;4471.187515
+32069569;5067.843233
+32080896;4049.553478
+32092225;5053.040104
+32103556;5043.593295
+32114889;5069.935834
+32126224;5134.910445
+32137561;5157.954229
+32148900;3151.226204
+32160241;5029.027137
+32171584;5063.472543
+32182929;4093.738992
+32194276;2216.734704
+32205625;4100.140803
+32216976;3560.313435
+32228329;3086.545587
+32239684;3037.319001
+32251041;4675.302996
+32262400;5102.957967
+32273761;5027.263338
+32285124;5111.716345
+32296489;4129.325213
+32307856;5021.960366
+32319225;5050.092994
+32330596;3831.422240
+32341969;2700.636362
+32353344;4895.574490
+32364721;5033.554362
+32376100;5060.782519
+32387481;5133.324951
+32398864;5117.777551
+32410249;3159.730819
+32421636;4281.672265
+32433025;5285.785815
+32444416;4042.846269
+32455809;5078.316080
+32467204;4067.453314
+32478601;4314.569757
+32490000;4095.132217
+32501401;5158.662287
+32512804;3937.507009
+32524209;5032.151136
+32535616;4110.737950
+32547025;3112.005841