#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int isValidSquare(int** grid, int** horizontal, int** vertical, int row, int col, int size) {
    // Check if we can form a square of given size at (row, col)
    // Top and bottom edges need horizontal runs of 'size'
    if (horizontal[row][col] < size || 
        horizontal[row + size - 1][col] < size) {
        return 0;
    }
    
    // Left and right edges need vertical runs of 'size'
    if (vertical[row][col] < size || 
        vertical[row][col + size - 1] < size) {
        return 0;
    }
    
    return 1;
}

int solution(int** grid, int rows, int cols) {
    if (grid == NULL || rows == 0 || cols == 0) {
        return 0;
    }
    
    // Allocate DP tables
    int** horizontal = (int**)malloc(rows * sizeof(int*));
    int** vertical = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        horizontal[i] = (int*)calloc(cols, sizeof(int));
        vertical[i] = (int*)calloc(cols, sizeof(int));
    }
    
    // Build horizontal DP table (right to left)
    for (int i = 0; i < rows; i++) {
        for (int j = cols - 1; j >= 0; j--) {
            if (grid[i][j] == 1) {
                horizontal[i][j] = 1 + (j + 1 < cols ? horizontal[i][j + 1] : 0);
            }
        }
    }
    
    // Build vertical DP table (bottom to top)
    for (int i = rows - 1; i >= 0; i--) {
        for (int j = 0; j < cols; j++) {
            if (grid[i][j] == 1) {
                vertical[i][j] = 1 + (i + 1 < rows ? vertical[i + 1][j] : 0);
            }
        }
    }
    
    int maxSize = 0;
    
    // Try every possible top-left corner and size
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            int maxPossible = (rows - i) < (cols - j) ? (rows - i) : (cols - j);
            for (int size = 1; size <= maxPossible; size++) {
                if (isValidSquare(grid, horizontal, vertical, i, j, size)) {
                    int currentSize = size * size;
                    if (currentSize > maxSize) {
                        maxSize = currentSize;
                    }
                }
            }
        }
    }
    
    // Free DP tables
    for (int i = 0; i < rows; i++) {
        free(horizontal[i]);
        free(vertical[i]);
    }
    free(horizontal);
    free(vertical);
    
    return maxSize;
}

int** parseGrid(const char* input, int* rows, int* cols) {
    *rows = 0;
    *cols = 0;
    
    // Count opening brackets to find number of rows
    int rowCount = 0;
    int i = 0;
    int foundFirstBracket = 0;
    while (input[i]) {
        if (input[i] == '[') {
            if (foundFirstBracket) {
                rowCount++;
            } else {
                foundFirstBracket = 1;
            }
        }
        i++;
    }
    
    // Find the first row to count columns
    int colCount = 0;
    i = 0;
    int bracketCount = 0;
    while (input[i]) {
        if (input[i] == '[') {
            bracketCount++;
            if (bracketCount == 2) { // Inside first row
                i++;
                while (input[i] && input[i] != ']') {
                    if (input[i] >= '0' && input[i] <= '9') {
                        colCount++;
                    }
                    i++;
                }
                break;
            }
        }
        i++;
    }
    
    *rows = rowCount;
    *cols = colCount;
    
    if (rowCount == 0 || colCount == 0) {
        return NULL;
    }
    
    // Allocate grid
    int** grid = (int**)malloc(rowCount * sizeof(int*));
    for (int r = 0; r < rowCount; r++) {
        grid[r] = (int*)malloc(colCount * sizeof(int));
    }
    
    // Parse the grid values
    i = 0;
    int currentRow = 0;
    int currentCol = 0;
    bracketCount = 0;
    
    while (input[i] && currentRow < rowCount) {
        if (input[i] == '[') {
            bracketCount++;
        } else if (input[i] >= '0' && input[i] <= '9' && bracketCount >= 2) {
            grid[currentRow][currentCol] = input[i] - '0';
            currentCol++;
            if (currentCol >= colCount) {
                currentCol = 0;
                currentRow++;
            }
        } else if (input[i] == ']' && bracketCount >= 2) {
            bracketCount--;
        }
        i++;
    }
    
    return grid;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int rows, cols;
    int** grid = parseGrid(line, &rows, &cols);
    
    int result = solution(grid, rows, cols);
    printf("%d\n", result);
    
    if (grid) {
        for (int i = 0; i < rows; i++) {
            free(grid[i]);
        }
        free(grid);
    }
    return 0;
}