/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

#define max(a,b) ((a > b)?(a):(b))
#define get(a, i, j) a[i][j][0]
#define set(a, i, j, k) a[i][j][0]=k;


int height(struct TreeNode *root) {
    if (root == NULL)
        return 0;

    int left  = 1 + height(root->left);
    int right = 1 + height(root->right);

    return max(left, right);
}


/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */

char ***init_grid(int n, int m) {
    char ***grid = (char ***) malloc(m * sizeof(char **));

    if (grid == NULL)
        return NULL;

    for (int i = 0; i < m; i++) {
        grid[i] = (char **) malloc(n * sizeof(char *));

        if (grid[i] == NULL)
            return NULL;

        for (int j = 0; j < n; j++) {
            grid[i][j] = (char *) malloc(1);

            if (grid[i][j] == NULL)
                return NULL;
            grid[i][j][0] = 'A';
        }
    }
    return grid;
}

void fill(char ***grid, struct TreeNode *root, int row, int col_low, int col_high) {

    int mid = (col_high - col_low) / 2;

    if (root == NULL) {
        //set(grid, row, mid, '\0');
        return;
    }



}
char *** printTree(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
    int m = height(root);
    int n = (1 << m) - 1; // ?

    *returnSize = m;
    int *colSizes = (int *) malloc(m * sizeof(int));
    for (int i = 0; i < m; i++) colSizes[i] = n;
    *returnColumnSizes = colSizes;

    char ***grid = init_grid(n, m);


    return NULL;
}