diff --git a/bst/.2022-03-16-Note-11-42.autosave.xopp b/bst/.2022-03-16-Note-11-42.autosave.xopp
new file mode 100644
index 0000000000000000000000000000000000000000..80524acf84103709b80ae231ae9c04504db84acb
Binary files /dev/null and b/bst/.2022-03-16-Note-11-42.autosave.xopp differ
diff --git a/bst/2022-03-16-Note-11-42.xopp b/bst/2022-03-16-Note-11-42.xopp
index 3ff4e6bebf398a958fad814278ac8cbcf8165180..305a4a7aacb0e3bb5f36f0956b328322b56e2bdc 100644
Binary files a/bst/2022-03-16-Note-11-42.xopp and b/bst/2022-03-16-Note-11-42.xopp differ
diff --git a/quad_tree/cours.md b/quad_tree/cours.md
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/quad_tree/quad_tree.c b/quad_tree/quad_tree.c
new file mode 100644
index 0000000000000000000000000000000000000000..0463b765973e8f7b29662c2b9a80ac4328d69fa4
--- /dev/null
+++ b/quad_tree/quad_tree.c
@@ -0,0 +1,144 @@
+
+#include <stdio.h>
+
+typedef int value_t;
+typedef struct node_
+{
+	value_t value;
+	node_ *child[4]
+} node_t;
+
+/**
+ * @brief Create a tree with a specified depth
+ *
+ * @param depth
+ * @return created node_t*
+ */
+node_t *create_tree(int depth)
+{
+	if (depth == 0)
+		return NULL;
+	node_t *node = malloc(sizeof(node_t));
+	node->value = 0;
+	for (int i = 0; i < 4; i++)
+	{
+		node->child[i] = create_tree(depth - 1);
+	}
+	return node;
+}
+
+/**
+ * @brief Recursivly count the number of nodes in a tree
+ *
+ * @param tree
+ * @return int - Number of nodes
+ */
+int count_nodes(node_t *tree)
+{
+	int count = 0;
+	if (tree == NULL)
+		return 0;
+
+	for (int i = 0; i < 4; i++)
+	{
+		count += count_nodes(tree->child[i]);
+	}
+}
+
+value_t jmax(value_t a, value_t b)
+{
+	return (a > b) ? a : b;
+}
+
+/**
+ * @brief Count the maximum depth of a tree
+ *
+ * @param  tree
+ * @return int - Depth
+ */
+int count_depth(node_t *tree)
+{
+	int depth = 0;
+	if (tree == NULL)
+		return 0;
+
+	for (int i = 0; i < 4; i++)
+	{
+		// replace depth with new depth if it's bigger
+		depth = max(depth, count_depth(tree->child[i]));
+	}
+	return depth; // + 1 ?
+}
+
+node_t *position(node_t *tree, int x, int y)
+{
+	if (tree == NULL)
+		return NULL;
+
+	int d = count_depth(tree);
+
+	if (d == 0)
+		return tree;
+
+	while (d > 1)
+	{
+		int i = (2 * (y % pow(2, d)) / pow(2, d - 1)) + ((x % pow(2, d)) / pow(2, d - 1));
+		tree = tree->child[i];
+		d--;
+	}
+	return tree;
+}
+
+/**
+ * @brief Create and fill a tree with image pixels
+ *
+ * @param image - image data
+ * @param x     - side size of image
+ * @return node_t*
+ */
+node_t *fill_tree(int x, int image[x][x])
+{
+	node_t *tree = create_tree(x);
+	for (int i = 0; i < x; i++)
+	{
+		for (int j = 0; j < x; j++)
+		{
+			position(tree, i, j)->value = image[i][j];
+		}
+	}
+	return tree;
+}
+
+/**
+ * @brief Create and fill a matrix from a tree
+ *
+ * @param tree - Source tree
+ * @return int** - Created matrix
+ */
+int **fill_matrix_from_tree(node_t *tree)
+{
+	int d = pow(count_depth(tree), 2);
+	// Allocate matrix
+	int **matrix = malloc(sizeof(int *) * d);
+	for (int i = 0; i < d; i++)
+	{
+		matrix[i] = malloc(sizeof(int) * d);
+	}
+
+	for (int i = 0; i < d; i++)
+	{
+		for (int j = 0; j < d; j++)
+		{
+			matrix[i][j] = position(tree, i, j)->value;
+		}
+	}
+	return matrix;
+}
+
+node_t *tree_vert_sym(node_t *tree)
+{
+	int **m = matrix_from_tree(tree);
+	matrix_vert_sym(m);
+	tree = fill_tree(m);
+	return tree;
+}