#include <iostream>
#include <vector>
#include <queue>

using namespace std;
using dat = pair<int, int>;

vector<int>alpha[32];
priority_queue<dat, vector<dat>, greater<dat>>pq;
bool visit[4000];

int sol(string a, string b) {
	int max_length = 0;
	for (int i = 0; i < b.length(); i++) alpha[b[i] - 'A'].push_back(i);

	for (int i = 0; i < a.length()-max_length; i++) {
		while (!pq.empty() && pq.top().first <= i) {
			int t = pq.top().second;
			while (t >= 0 && visit[t])visit[t--] = 0;
			pq.pop();
		}
		for (auto j : alpha[a[i] - 'A']) {
			if (visit[j])continue;
			int t = 1,lim = min(a.length()-i,b.length() - j);
			while (t < lim && a[i + t] == b[j + t])t++;
			for (int p = i + 1; p <= i + t; p++) visit[p] = 1;
			max_length = max(t,max_length);
			pq.push(make_pair(i+t, j + t));
		}
	}
	return max_length;
}

int main() {
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	string a, b;
	
	cin >> a >> b;
	if (a.length() > b.length()) {
		cout << sol(b, a);
	}
	else {
		cout << sol(a, b);
	}

	return 0;
}

#include<iostream>
#define endl "\n"
#include<vector>
using namespace std;

struct node {
	int right;
	int left;
};

int num, root, l, r;
vector<node> Tree(10009); // 구조체를 이용해서 트리를 만듦

void postOrder(int cur) { // 후위선회 코드
	if (Tree[cur].left) postOrder(Tree[cur].left); // left에 노드가 있으면 left로
	if (Tree[cur].right) postOrder(Tree[cur].right); // right에 노드가 있으면 right로
	cout << cur << endl; // 자식이 없으면 자신을 출력
}

void makeTree(int cur) { // 현재 노드 기준
	if (num < cur) { // 자기보다 작은수면 왼쪽
		if (Tree[cur].left == 0) { // 왼쪽에 삽입된게 없으면 삽입
			Tree[cur].left = num;
			//cout << cur << "'s left is " << num << endl;
			return;
		}
		makeTree(Tree[cur].left); // 있으면 내려감
	}
	if (num > cur) { // 자기보다 크면 오른쪽
		if (Tree[cur].right == 0) { // 오른쪽에 삽입된게 없으면 삽입
			Tree[cur].right = num;
			//cout << cur << "'s right is " << num << endl;
			return;
		}
		makeTree(Tree[cur].right); // 있으면 내려감
	}
}

int main() {

	ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
	
	cin >> num;
	int Root = num;

	while (cin>>num) { 
		if (num == EOF) break; // 데이터가 끝나면 반복문 탈출 <- 이부분이 문제인가..??
		makeTree(Root);
	}
	
	postOrder(Root);

	return 0;
}

#include<iostream>
#include<vector>
#include<queue>
#define endl "\n"
using namespace std;

int d;
//vector<vector<int>> Word(1000);
vector<string> Word[1001];
queue<string> Q;
string word, dict, answer, word2;

void BFS() {
	Q.push(word); // push "cal"
	int Len = 4;

	while (!Q.empty()) {
		int re = Q.size();
		for (int q = 0; q < re; q++) { // 검사할 Q 안에 있는 문자들. ex) cal
			for (int i = 0; i < Word[Len].size(); i++) { // 문자열의 길이가 Len인 모든 문자들 검사. ex) calf, call, coal

				string com_q = Word[Len][i]; // 검사당할 문자열 복사. ex) calf
				string Q_f = Q.front(); // 검사할 문자열 복사. ex) cal
				int decom = 0;

				for (int j = 0; j < Len-1; j++) { // 문자열의 길이만큼 검사. ex) calf, call, coal 은 모두 3번 검사

					int index = com_q.find(Q_f[j]); // 길이가 Len인 문자열에서 i 번째 문자열의 j번째 단어. ex) Len=4 이면 calf 의 j번째 단어를 찾음.
					//cout << "q_f : " << Q_f[j] << ", index : " << index << endl;
					if (index != string::npos) { // 존재한다면
						//cout << "del : " << com_q[index] << endl;
						com_q.erase(index, 1); // 그 문자 삭제
					}

					if (com_q.size() == 1) { // 결국에 하나만 남는다면, ex) calf -> f
						//cout << "push : " << Word[Len][i] << endl;
						Q.push(Word[Len][i]); // 하나만 달라야지 토를 단것이라 할 수 있다.
						answer = Word[Len][i]; // 그리고 정답 갱신. ex) calfs
					}
				}
				//cout << "com_q : " << com_q << endl;
			}
			Q.pop(); // 검사를 다한 Q는 pop
			//cout << endl;
		}
		Len++;
	}
}

int main() {
	ios_base::sync_with_stdio(false); cout.tie(NULL); cin.tie(NULL);

	cin >> d >> word;

	for (int i = 0; i < d; i++) {
		cin >> dict;
		Word[dict.size()].push_back(dict); // 길이별로 저장한다.
	}

	BFS();

	cout << answer;

	return 0;
}

#include <string>
#include <vector>
#include<iostream>
#include<sstream>
#include<string.h>
#include<cmath>

using namespace std;

vector<char> Kakao = { 'A','C','F','J','M','N','R','T'};
vector<string> All = {"RNFAT", "NFRTA", "RNAFT"}; // 예시로 해둔거에용

int solution(int n, vector<string> data) {

    for (int i = 0; i < n; i++) { // 조건만큼 반복
        for (int j = 0; j < All.size(); j++) {
            cout << endl;

            int f_i = All[j].find(data[i][0]); // ex) 첫번째 예시에서는 N -> 1
            int s_i = All[j].find(data[i][2]); // ex) 첫번째 예시에서는 F -> 2 
            int Abs = abs(s_i - f_i) - 1; // 두 캐릭터 사이의 거리

            cout << "첫번째 캐릭터 위치, 두번째 캐릭터 위치 = " << f_i << ", " << s_i << ", 두 캐릭터 사이의 거리 = " << Abs << endl;
            cout << "현재 검사하는 배치 : " << All[j] << ", 조건 : " << data[i] << endl;

            if (data[i][3] == '=') // i번째 조건의 부호
            {
                cout << "=";
                if (Abs == 0) cout << "문제없음" << endl;
                if (Abs != 0) { // 붙어있지 않으면
                    cout << "erase, ";
                    cout << All[j] << endl;
                    All.erase(All.begin() + j);
                    j--; // 지워주고 j를 하나 빼준다. why? 삭제되면 size가 작아져서
                }
            }

            else if (data[i][3] == '>')
            {
                cout << ">";
                if (Abs > data[i][4]) cout << "문제없음" << endl;
                if (Abs <= data[i][4]) { // 거리가 가까우면 삭제
                    cout << "erase, ";
                    cout << All[j] << endl;
                    All.erase(All.begin() + j);
                    j--;
                }
            }

            else if (data[i][3] == '<')
            {
                cout << "<";
                if (Abs < data[i][4]) cout << "문제없음" << endl;
                if (Abs >= data[i][4]) { // 거리가 멀면 삭제
                    cout << "erase, ";
                    cout << All[j] << endl;
                    All.erase(All.begin() + j);
                    j--;
                }
            }
        }
    }

    
    int answer = All.size();
    cout << answer;
    return answer;
}


int main() {

    vector<string> Data = { "N~F=0", "R~T>2" };
    int n = 2;

    cout << All.size() << endl;
    // 모든 문자열을 만들었다 치자
    // 그게 All임.

    solution(n, Data);

    return 0;
}

#include <iostream>
#include <string>
#include <vector>

using namespace std;

string str;
vector<string> vec;

int main() {
    cin >> str;
    int cnt = 0;
    for (int i = 0; i < str.size(); i++) {
        if (str[i] == ':') cnt++;
    }
    string temp;
    bool flag = false;
    for (int i = 0; i < str.size(); i++) {
        if (str[i] == ':') {  // : 일경우
            if (temp.size() == 0 && str[i + 1] == ':') {
                for (int j = 0; j < 8 - cnt; j++) {
                    vec.push_back("0000:");
                }
                continue;
            } else {
                int s = temp.size();
                for (int j = 0; j < 4 - s; j++) {
                    temp.insert(0, "0");
                }
                temp += ":";
                vec.push_back(temp);
                temp = "";
            }
        } else {  // 숫자일경우
            temp += str[i];
            if (i == str.size() - 1) {
                int s = temp.size();
                for (int j = 0; j < 4 - s; j++) {
                    temp.insert(0, "0");
                }
                vec.push_back(temp);
            }
        }
    }
    for (int i = 0; i < vec.size(); i++) {
        if (i == 7) {
            for (int j = 0; j < 4; j++) {
                cout << vec[i][j];
            }
        } else
            cout << vec[i];
    }
}```

#include <algorithm>
#include <iostream>
#include <queue>
#include <string>
#include <vector>

using namespace std;

vector<string> vec;  // 사전 담을배열
int n;
string ori;       // 처음 들어갈 문자열
int maximum = 0;  // 가장큰 문자열 초기화하는 함수
string result;    // 가장큰 문자열 담을 변수
int idx;          // 사전을 길이대로 sort 시켜놓았기때문에, 큐에들어가는 문자열의 길이는, 큐에서 일찍 pop 될 수록 작거나 같다.

bool compare(string a, string b) { return a.length() < b.length(); }  // quick sort의 컴페어 함수, 문자열 길이를 기준으로 오름차순 으로 만듬

void analyze_max(string a) {  // string a 를 넣어서 맥시멈 값과 가장 큰 문자열을 변수에 각각 입력.
    if (int(a.length()) > maximum) {
        maximum = a.length();
        result = a;
    }
}

void bfs() {
    queue<string> que;
    que.push(ori);
    analyze_max(ori);
    while (!que.empty()) {
        string cur = que.front();
        que.pop();
        while (cur.length() >= vec[idx].length() && idx < vec.size()) idx++;  // vec[idx] 가 vec 의 사이즈보다 작고 현재 cur의 문자열 길이보다 작거나 같으면 idx++
        for (int i = 97; i <= 122; i++) {                                     // 아스키 코드 a~z를 문자열 temp에다가 넣어줌.
            string temp;                                                      // cur을 바꾸지않고 일단 temp에 저장해서 그걸바꿔서 비교할거임
            for (int j = 0; j <= cur.length(); j++) {                         // 현재 cur의 인덱스 곳곳마다 알파벳 하나씩 넣어볼거임
                temp = cur;
                string a;                                                                     // 여거 temp 에 넣어줄거
                a = char(i) + '\0';                                                           // i 를 string 으로 만들어주려면 이렇게 해야댐
                temp.insert(j, a);                                                            // temp 는 a~z를 각 인덱스에 한번씩 넣어본 모든경우의 수의 문자열입니다.
                for (int k = idx; temp.length() == vec[k].length() && k < vec.size(); k++) {  // temp의 길이보다 vec의 idx 에있는 문자 길이가 같으면 계속진행
                    if (temp == vec[k]) {                                                     // 만약 찾는값이 벡터에있다면
                        que.push(temp);                                                       // 큐에푸쉬
                        analyze_max(temp);                                                    // 가장큰지확인.
                    }
                }
                if (idx >= vec.size()) break;  // 만약 idx가 벡터사이즈보다 크다면 브릭.
            }
        }
    }
}

int main() {
    ios_base ::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    cin >> n >> ori;

    for (int i = 0; i < n; i++) {
        string a;
        cin >> a;
        vec.push_back(a);
    }

    sort(vec.begin(), vec.end(), compare);  // 오름차순정렬
    bfs();
    cout << result;
}```

#include<iostream>
#include<algorithm>
#define endl "\n"

using namespace std;

int n;
bool isSosu[10002] = { false, };
bool Said[10001] = { false, };

int d_large[3] = { 0,0,0 };
int g_large[3] = { 0,0,0 };

void Sosu_making() { // 에라토스 테네스의 체

	int s = 10001;
	fill_n(isSosu, 10001, true); // 전부 소수로 표시
	isSosu[0] = isSosu[1] = false; // 소수가 아닌 두 수 표시

	for (int i = 2; i <= sqrt(s); i++) { 
		if (isSosu[i] == true) {
			for (int j = i + i; j <= s; j += i) {
				isSosu[j] = false;
			}
		}
	}
}

void Game(int n, long long int d_score, long long int g_score) {
	int d_index = 0, g_index = 0;

	for (int i = 0; i < n; i++) {
		int dae, guu;
		cin >> dae >> guu; // 대웅이와 규성이가 순서대로 말함

		if (!isSosu[dae]) { // 대웅이가 말한게 소수가 아닌 경우
			if (g_large[2] == 0) { // 규성이가 말한 소수가 3개가 안되면
				cout << "g+=1000" << endl;
				g_score += 1000; // 천점을 더해준다.
			}
			else { // 규성이가 말한 소수가 3개 이상이라면
				cout << "g+=large" << endl;
				g_score += g_large[0]; // 말한 소수 중 3번째로 큰 수를 더해준다.
			}
		}
		else if (Said[dae]) { // 대웅이가 말한게 이전에 말한 소수인 경우
			cout << "d-=1000" << endl;
			d_score -= 1000; // 해당팀 -1000
		}
		else { // 조건에 맞는 소수인 경우
			Said[dae] = true; // 말한 것으로 기록한다.
			if (d_index < 3) { // 대웅이가 말한 소수가 3개 미만이면
				cout << "dae say sosu! & input" << endl;
				d_large[d_index] = dae; // 말한 소수로 넣어주고 인덱스를 더한다.
				d_index++;
				if(d_index==3) sort(d_large, d_large + 3); // d_lareg[0] 가 3번째로 큰 수가 되게함.
			}
			else {
				cout << "dae say sosu!" << endl;
				d_large[0] = max(d_large[0], dae);
				sort(d_large, d_large + 3); // d_lareg[0] 가 3번째로 큰 수가 되게함.
			}
		}

		if (!isSosu[guu]) { 
			if (d_large[2] == 0) { 
				cout << "d+=1000" << endl;
				d_score += 1000; 
			}
			else { 
				cout << "d+=large" << endl;
				d_score += d_large[0]; 
			}
		}
		else if (Said[guu]) {
			cout << "g-=1000" << endl;
			g_score -= 1000; 
		}
		else { 
			Said[guu] = true; 
			if (g_index < 3) { 
				cout << "guu say sosu! & input" << endl;
				g_large[g_index] = guu;
				g_index++;
				if (g_index == 3) sort(g_large, g_large + 3);
			}
			else {
				cout << "guu say sosu!" << endl;
				g_large[0] = max(g_large[0], guu);
				sort(g_large, g_large + 3);
			}
		}
	}
	cout << "대웅 : " << d_score << endl; // 1000
	cout << "규성 : " << g_score << endl; // 0
}

int main(){

	ios_base::sync_with_stdio(false); cout.tie(NULL); cin.tie(NULL);

	Sosu_making();

	cin >> n; // 라운드

	long long int d_score = 0, g_score = 0;
	Game(n, d_score, g_score);

	cout << "대웅 : " << d_score << endl; // 0
	cout << "규성 : " << g_score << endl; // 0

	return 0;
}