Go: // 九九を出すだけ
package main
import (
	"fmt"
	"os"
	"bufio"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)
var out = bufio.NewWriter(os.Stdout)

func main(){
	sc.Split(bufio.ScanWords)
	defer out.Flush()
	for sc.Scan(){
	    s := nextIntIs()
	    sc.Scan()
	    t := nextIntIs()
        a := len(strconv.Itoa(s+t))
	    fmt.Fprintln(out, a)
	}
}

func next() string{
	sc.Scan()
	return sc.Text()
}

func nextInt() int{
	a, _ := strconv.Atoi(next())
	return a
}

func nextIntIs() int{
	a, _ := strconv.Atoi(sc.Text())
	return a
}

C++: #include<iostream>
#include<string>
using namespace std;

int main(){
  int x, y;

  while(1){
    cin >> x >> y;
    cout << to_string(x + y).size() << endl;
    if(cin.eof()) {break;}
  }

  return 0;
}

C++: #include <iostream>
#include <string>
#include <vector>
#include <sstream>
using namespace std;
int main()
{

	int len[200];
	int max = 0;
	for(int num = 0 ;num < 200 ; num++)
	{
		string str;
		string item;
		vector<string> list;
		getline(cin, str);
		if (str == "")
		{
			break;
		}

		stringstream ss(str);
		while (getline(ss, item, ' ') && !item.empty()) {
			list.push_back(item);
		}
		int sum = stoi(list[0].c_str()) + stoi(list[1].c_str());
		int count = 0;
		for (int i = 10; i <= 1000000; i = i * 10)
		{
			count++;
			if(sum < i)
			{
				len[num] = count;
				max++;
				break;
			}


		}
	}
	for (int num = 0; num < max; num++)
	{
		cout << len[num] << endl;

	}
	return 0;
}

C++: #include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
int main()
{  
    long long a,b,s;
    while( cin>>a>>b )
    {
           long long dem=0;
           s=a+b;
           while(s>0)
           {
                     s=s/10;
                     dem++;
           }
           cout<<dem<<endl;
    }
}

C++: #include<stdio.h>

 int main(void){
   int div = 1;
   int i,s,sum,count = 0;

   fscanf(stdin,"%d %d",&i,&s);
   sum = i + s;

   while(1){
     if(sum/div == 0){
       break;
     }
     div *= 10;
     count++;
   }

   printf("%d\n",count);

   return 0;
 }

C++: #include <iostream>
using namespace std;

#define INPUTSIZE 10

int main() {
    int a, b, sum, digit;

    while (cin >> a >> b) {
        sum = a + b;

        digit = 0;
        while (sum > 0) {
            sum /= 10;
            digit++;
        }
        cout << digit << endl;
    }

    return 0;
}

C++: #include<iostream>
using namespace std;
int num(int x){
  int r;
  while(x!=0){
  x= x/10;
    r++;
  }
  return r;
}
int main(){
  int a,b;
  cin>>a>>b;
   a+=b;
   cout<<num(a)<<endl;
  return 0;
}

C++: #include <iostream>
using namespace std;

int main()
{
	int a,b,sum;
	int count = 1;

	cin >> a >> b;
	sum = a + b;
	
	while(sum > 1){

		sum = sum / 10;
		count++;
	}

	cout << count << endl;


	return 0;
}

C++: #include <stdio.h>

int main() {
    int a, b, result, sum;
    while (scanf("%d %d", &a, &b) != EOF) {
        result = 0;
        sum = a+b;
        while (sum != 0) {
            sum /= 10;
            result++;
        }
        printf("%d\n", result);
    }
}

C++: #include <iostream>
using namespace std;

int main(){
	int a,b,c;
	int ans;
	int cnt=-1;
	
	while(cin>>a>>b){
		cnt++;
		//-----test-----
		if(a<1190) break;
		
		//--------------
		c=a+b;
		ans=1;
		while(10<=c){
			c/=10;
			ans++;
		}
		cout<<ans<<endl;
	}
	
	return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;

int main(){
	int a,b,keta;
	while(cin>>a>>b){
		keta = 1;
		a = a+b;
		while(a /= 10){
			keta++;
		}

		cout<<keta<<endl;
	}
	return 0;
}

C++: #include<iostream>

int main(){
	int a,b,c,sum=1;
	std::cin>>a>>b;
	c=a+b;
	while(c/10!=0){
		sum++;
		c/=10;
	}
	std::cout<<sum<<std::endl;
	return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;

int main(){
	int a,b;
	while(	cin >> a >> b ){
		int s = a+b;
		int ans = 0;
		while(s){
			ans++;
			s /= 10;
		}
		if( a+b == 0 ) cout << 1 << endl;
		else cout << ans << endl;
	}
}

C++: #include <bits/stdc++.h> // {{{

#define GET_MACRO(a, b, c, d, NAME, ...) NAME
#define REP(...) GET_MACRO(__VA_ARGS__, REP4, REP3, REP2)(__VA_ARGS__)
#define REP2(i, a) REP3(i, 0, a)
#define REP3(i, a, b) REP4(i, a, b, 1)
#define REP4(i, a, b, s) for (int i = (a); i < (int)(b); i += (s))
#define REPR(...) GET_MACRO(__VA_ARGS__, REPR4, REPR3, REPR2)(__VA_ARGS__)
#define REPR2(i, a) REPR3(i, 0, a)
#define REPR3(i, a, b) REPR4(i, a, b, 1)
#define REPR4(i, a, b, s) for (int i = (b)-1; i >= (int)(a); i -= (s))
#define ALL(c) (c).begin(), (c).end()
#define DUMP(x) (std::cerr << #x << ':' << ' ' << x << '\n')
#define TMPL_T template <typename T>
#define TMPL_TU template <typename T, typename U>
#define mut auto
#define let const auto

using Int = long long;
// clang-format off
namespace extio {
std::string delimiter=" ",pdelimiter=" ";
std::string bracket_b="",bracket_e="";
void chdelim(const std::string&s){delimiter=s;}
void chpdelim(const std::string&s){pdelimiter=s;}
void chbracket(const std::string&b,const std::string&e){bracket_b=b,bracket_e=e;}
TMPL_T  void pcont(std::ostream&os,const T&x){int c=0;for(const auto&a:x){if(c++)os<<delimiter;os<<a;}}
TMPL_TU void ppair(std::ostream&os,const std::pair<T,U>&p){os<<bracket_b<<p.first<<pdelimiter<<p.second<<bracket_e;}
}
namespace std {
TMPL_T ostream& operator<<(ostream&os,const vector<T>&x){extio::pcont(os,x);return os;}
TMPL_T ostream& operator<<(ostream&os,const set<T>&x){extio::pcont(os,x);return os;}
TMPL_T ostream& operator<<(ostream&os,const multiset<T>&x){extio::pcont(os,x);return os;}
TMPL_T ostream& operator<<(ostream&os,const deque<T>&x){extio::pcont(os,x);return os;}
TMPL_TU ostream& operator<<(ostream&os,const map<T,U>&x){extio::pcont(os,x);return os;}
TMPL_TU ostream& operator<<(ostream&os,const pair<T,U>&x){extio::ppair(os,x);return os;}
}
TMPL_TU inline bool chmax(T&x,U a){return x<a&&(x=a,1);}
TMPL_TU inline bool chmin(T&x,U a){return a<x&&(x=a,1);}

inline int in(){int x;std::cin>>x;return x;}

struct Initializer_ {
  Initializer_(){
    std::cin.tie(0);
    std::ios::sync_with_stdio(0);
    std::cout << std::setprecision(10);
    std::cerr << std::setprecision(10);
  }
} precalc;
// clang-format on
// }}}

using namespace std;

signed main() {
  int a, b;
  while (cin >> a >> b) {
    cout << to_string(a + b).size() << endl;
  }
  return 0;
}

C++: #include<iostream>
int main(){
	int d=100;
	while(d>0){
		int a,b;
		std::cin>>a>>b;
		int n=a+b;
		if(n<10)std::cout<<1<<std::endl;
		if(n>=10&&n<100)std::cout<<2<<std::endl;
		if(n>=100&&n<1000)std::cout<<3<<std::endl;
		if(n>=1000&&n<10000)std::cout<<4<<std::endl;
		if(n>=10000&&n<100000)std::cout<<5<<std::endl;
		if(n>=100000&&n<1000000)std::cout<<6<<std::endl;
		if(n>=1000000&&n<10000000)std::cout<<7<<std::endl;
		d--;
	}
	return 0;
}

C++: #include <cstdio>
#include <iostream>

int count(int x ) {
	if (0 == x) return 1;
	int re = 0;
	while (x > 0) {
		++re;
		x /= 10;
	}
	return re;
}

int main() {
	int a, b;
	while (2 == scanf("%d%d", &a, &b)) {
		printf("%d\n", count(a + b));
	}
	return 0;
}

C++: #include <algorithm>
#include <map>
#include <vector>
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstring>
#include <cctype>
#include <cstdlib>
#include <cmath>
#include <string>
#include <queue>
using namespace std;

#define REP(i,n) for(int i=0; i<n; ++i)
#define IREP(it,array) for(vector<int>::iterator it=array.begin(); it!=array.end(); ++it)
#define SREP(it,array) for(vector<string>::iterator it=array.begin(); it!=array.end(); ++it)
#define MP make_pair


int main()
{
  cout.setf(ios::fixed, ios::floatfield);
  cout.precision(10);

  int INF = 1000000;

  int a,b;
  while(cin>>a>>b){
    int sum=a+b;
    int deg=0;
    while(sum>0){
      sum /= 10;
      deg++;
    }
    cout << deg << endl;
  }

  return 0;
}

C++: #include <stdio.h>
int main(){
	int a,b;
	int n;
	while(scanf("%d %d",&a,&b) != EOF){
		a = a + b;
		for(n = 0;;n++){
			a /= 10;
			if(a <= 0)break;
		}
		printf("%d\n",n+1);
	}
	return 0;
}