#include <iostream>
#include <algorithm>

using namespace std;

struct Node {
    int val;
    Node *left, *right;
};

Node *new_node(int val, Node *left = nullptr, Node *right = nullptr) 
{
    Node* node = new Node();

    node->val = val;
    node->left = left;
    node->right = right;

    return node;
}

void free(Node* tree) 
{
    if (tree != nullptr) {
        free(tree->left);
        free(tree->right);
        delete tree;
    }
}

Node *load() 
{
  char c;
  cin >> c;

  if (c == '-')
    return nullptr;

  // c == '['
  int val;
  cin >> val >> ws;
  Node *left = load();
  cin >> ws;
  Node *right = load();
  cin >> ws;

  cin >> c;
  // c == ']'

  return new_node(val, left, right);
}

int height(Node *tree)
{
    if (tree == nullptr) return 0;

    return 1 + max(height(tree->left), height(tree->right));
}

int unbalance(Node *tree)
{
    if (tree == nullptr) return 0;

    int height_left = height(tree->left);
    int height_right = height(tree->right);

    int factor_left = unbalance(tree->left);
    int factor_right = unbalance(tree->right);

    return max({ factor_left, factor_right, abs(height_right - height_left) });
}

void unbalance_height(Node *tree, int &height, int &factor)
{
    if (tree == nullptr) {
        height = 0;
        factor = 0;
        return;
    }

    int height_left, height_right, factor_left, factor_right;
    unbalance_height(tree->left, height_left, factor_left);
    unbalance_height(tree->right, height_right, factor_right);

    height = 1 + max(height_left, height_right);
    factor = max({ factor_left, factor_right, abs(height_left - height_right) });
}

int main(void)
{
    Node *tree = load();

    cout << height(tree) << endl;
    cout << unbalance(tree) << endl;

    int height, factor;

    unbalance_height(tree, height, factor);

    cout << height << endl << factor << endl;

    free(tree);
    
    return 0;
}