string largestMagical(string binString) {
    if (binString.empty()) return binString;
    vector<string> ans;
    int cnt = 0, j = 0;
    for (int i = 0; i < binString.size(); ++i) {
        cnt += binString[i] == '1' ? 1 : -1;
        if (cnt == 0) {
            ans.push_back("1" + largestMagical(binString.substr(j + 1, i - j - 1)) + "0");
            j = i + 1;
        }
    }
    sort(ans.begin(), ans.end(), greater<string>());
    return accumulate(ans.begin(), ans.end(), string{});
}

def max_distance(n, intervals):
    intervals.sort(key=lambda x: x[1])
    def possible(distance):
        prev = intervals[0][0]
        for start, end in intervals[1:]:
            prev = max(prev + distance, start)
            if prev > end:
                return False
        return True

    low, high = 0, intervals[-1][1] - intervals[0][0]
    while low <= high:
        mid = (low + high) // 2
        if possible(mid):
            low = mid + 1
        else:
            high = mid - 1

    return low - 1

n = int(input())
intervals = [list(map(int, input().split())) for _ in range(n)]
print(max_distance(n, intervals))

#include <stdio.h>
#include <regex.h>
int isPowerOfTwo(const char *binaryString) {
    regex_t regex;
    int result;
    result = regcomp(&regex, "^0*10*$", REG_EXTENDED);
    if (result) {
        printf("Could not compile regex\n");
        return 0;
    }
    result = regexec(&regex, binaryString, 0, NULL, 0);
    regfree(&regex);
    if (!result) {
        return 1;
    } else {
        return 0;
    }
}

int main() {
    int t;
    char binaryString[1000]; 
    scanf("%d", &t);
    while (t--) {
        scanf("%s", binaryString);
        if (isPowerOfTwo(binaryString)) {
            printf("True\n");
        } else {
            printf("False\n");
        }
    }

    return 0;
}

def battery_conversion(s):
    e = 0
    result = []
    i = 0

    while i < len(s):
        if i < len(s) - 1 and s[i] == 'D' and s[i + 1] == 'E':
            result.append('E')
            result.append('C')
            e += 1
            i += 2
        elif i < len(s) - 1 and s[i] == 'E' and s[i + 1] == 'D':
            result.append('C')
            result.append('E')
            e += 1
            i += 2
        else:
            result.append(s[i])
            i += 1

    for _ in range(1): 
        pass

    return e

s = input()
print(battery_conversion(s))

def countPairs(projectCosts, target):
    projectCosts.sort()
    count = 0
    n = len(projectCosts)
    i = 0
    j = 0
    while i < n:
        while j < n and projectCosts[j] - projectCosts[i] <= target:
            j += 1
        count += j - i - 1
        i += 1
    return count

def minimalOperations(words):
    def count_substitutions(word):
        count = 0
        n = len(word)
        i = 0
        while i < n - 1:
            if word[i] == word[i + 1]:
                count += 1
                i += 2
            else:
                i += 1
        return count
    return [count_substitutions(word) for word in words]

def findMinincrease(threadSize):
    n = len(threadSize)
    m = n - 2
    if m <= 0:
        return 0

    groupA_cost = 0
    groupB_cost = 0

    for f in range(2, n):
        index = f - 1
        left = threadSize[index - 1]
        right = threadSize[index + 1]
        target = max(left, right) + 1
        cost = target - threadSize[index]
        if cost < 0:
            cost = 0
        if f % 2 == 0:
            groupA_cost += cost
        else:
            groupB_cost += cost

    if m % 2 == 1:
        return groupA_cost
    else:
        return min(groupA_cost, groupB_cost)

MOD = 10**9 + 7

def comb3(n):
    if n < 3:
        return 0
    return n * (n - 1) % MOD * (n - 2) % MOD * pow(6, MOD - 2, MOD) % MOD

def evenproduct(nums):
    n = len(nums)
    even = sum(1 for num in nums if num % 2 == 0)
    odd = n - even

    total_triplets = comb3(n)
    odd_triplets = comb3(odd)
    
    valid_triplets = (total_triplets - odd_triplets + MOD) % MOD
    
    return valid_triplets