import java.util.Scanner;
class Node{
private int iData;
public Node(int key){
iData = key;
}
public int getKey(){
return iData;
}
public void setKey(int id){
iData = id;
}
}
class Heap{
private Node[] heapArray;
private int maxSize;
private int currentSize;
public Heap(int mx){
maxSize = mx;
currentSize = 0;
heapArray = new Node[maxSize];
}
public boolean isEmpty(){
return currentSize == 0;
}
public boolean insert(int key){
if(currentSize<maxSize){
heapArray[currentSize] = new Node(key);
trickleUp(currentSize++);
return true;
}
return false;
}
public void trickleUp(int index){
Node bottom = heapArray[index];
int current = index;
int parent = (index-1)/2;
while(parent>=0){
if(heapArray[parent].getKey()>bottom.getKey()){
heapArray[current] = bottom;
return;
}
heapArray[current]=heapArray[parent];
current = parent;
parent = (parent-1)/2;
}
heapArray[0]=bottom;
}
public Node rmove(){
if(currentSize==0){
return null;
}
Node root = heapArray[0];
heapArray[0] = heapArray[currentSize-1];
currentSize--;
trickleDown(0);
return root;
}
private void trickleDown(int index) {
Node temp = heapArray[index];
while(index<currentSize/2){
int left = index*2+1;
int right = left+1;
int biggerChild;
if(right<currentSize
&&heapArray[right].getKey()>heapArray[left].getKey()){
biggerChild = right;
}else{
biggerChild = left;
}
if(temp.getKey()>heapArray[biggerChild].getKey()){
break;
}
heapArray[index]=heapArray[biggerChild];
index = biggerChild;
}
heapArray[index] = temp;
}
public boolean change(int index,int newValue){
if(index>=currentSize){
return false;
}
int preKey = heapArray[index].getKey();
heapArray[index].setKey(newValue);
if(preKey>newValue){
trickleDown(index);
}
if(preKey<newValue){
trickleUp(index);
}
return true;
}
}
public class TestForString{
private static class TreeNode{
int height;
char val;
TreeNode left;
TreeNode right;
public TreeNode(char data){
this.val=data;
height=0;
}
}
private static class Tree{
TreeNode root;
int height=0;
public Tree(){
//Scanner scan = new Scanner(System.in);
String strForRoot = scan.next();
if(strForRoot.charAt(0)=='#'){
return;
}else{
root=new TreeNode(strForRoot.charAt(0));
Tree left=new Tree();
Tree right=new Tree();
root.left = left.root;
root.right= right.root;
height = 1+ Math.max(left.height, right.height);
}
}
public int getHeight(){
return height;
}
}
public static Scanner scan = new Scanner(System.in);
public static void main(String[] arg){
int height=1;
while(height>0){
Tree tree = new Tree();
height = tree.getHeight();
System.out.println(height);
}
}
}
class DataItem{
private int iData;
public DataItem(int data){
iData = data;
}
public int getKey(){
return iData;
}
}
class HashTable{
private DataItem[] hashArray;
private int arraySize;
private DataItem nonItem;
public HashTable(int size){
arraySize = size;
hashArray = new DataItem[arraySize];
nonItem = new DataItem(-1);
}
public void displayTable(){
System.out.print("Table: ");
for(int j=0;j<arraySize;j++){
if(hashArray[j]!=null){
System.out.print(hashArray[j].getKey()+" ");
}else{
System.out.print("** ");
}
}
System.out.println();
}
public int hashFunc2(int key){
return 5-key%5;
}
public int hashFunc1(int key){
return key%arraySize;
}
/**
* 这个函数只能假设表示未满的
* @param item
*/
public void insert(DataItem item){
int key = item.getKey();
int hashVal = hashFunc1(key);
int step=hashFunc2(key);
while(hashArray[hashVal]!=null
&&hashArray[hashVal].getKey()!=-1){
hashVal+=step;
hashVal%=arraySize;
}
hashArray[hashVal]=item;
}
public DataItem delete(int key){
int hashVal = hashFunc1(key);
int step = hashFunc2(key);
while(hashArray[hashVal]!=null){
if(hashArray[hashVal].getKey()==key){
DataItem temp = hashArray[hashVal];
hashArray[hashVal]=nonItem;
return temp;
}
hashVal+=step;
hashVal%=arraySize;
}
return null;
}
public DataItem find(int key){
int hashVal = hashFunc1(key);
int step = hashFunc2(key);
while(hashArray[hashVal]!=null){
if(hashArray[hashVal].getKey()==key){
return hashArray[hashVal];
}
hashVal+=step;
hashVal%=arraySize;
}
return null;
}
private static class Link{
public Link next;
private int iData;
public Link(int iData){
this.iData = iData;
}
public int getKey(){
return iData;
}
public void displayLink(){
System.out.print(iData+" ");
}
}
private static class SortedList{
Link first;
public SortedList(){
first = null;
}
public void insert(Link theLink){
int key = theLink.getKey();
Link pre = null;
Link current = first;
while(current!=null&¤t.getKey()<key){
pre = current;
current = current.next;
}
if(pre!=null){
pre.next=theLink;
theLink.next = current;
return;
}
first = theLink;
}
public void delete(Link theLink){
if(first == null){
return;
}
Link pre = null;
Link current = first;
int key = theLink.getKey();
while(current!=null&¤t.getKey()<key){
pre = current;
current = current.next;
}
if(pre==null&¤t.getKey()==key){
first=current.next;
}
if(pre!=null&¤t!=null&¤t.getKey()==key){
pre.next=current.next;
}
}
public Link find(int key){
Link current = first;
while(current!=null&¤t.getKey()<key){
current = current.next;
}
if(current!=null&¤t.getKey()==key){
return current;
}
return null;
}
public void displayList(){
System.out.print("List (first-->last): ");
Link current = first;
while(current!=null){
current.displayLink();
current = current.next;
}
System.out.println();
}
}
private static class LinkedHashTable{
private SortedList[] hashArray;
private int arraySize;
public LinkedHashTable(int size){
arraySize = size;
hashArray = new SortedList[arraySize];
for(int i=0;i<arraySize;i++){
hashArray[i]=new SortedList();
}
}
public void displayTable(){
for(int i=0;i<arraySize;i++){
hashArray[i].displayList();
}
}
public int hashFunction(int key){
return key%arraySize;
}
public void insert(Link theLink){
int hash = hashFunction(theLink.getKey());
hashArray[hash].insert(theLink);
}
public void delete(Link theLink){
int hash = hashFunction(theLink.getKey());
hashArray[hash].delete(theLink);
}
public Link find(int key){
int hash = hashFunction(key);
return hashArray[hash].find(key);
}
}
}