Let's call a positive integer good if there is no digit 0 in its decimal representation.

For an array of a good numbers a, one found out that the sum of some two neighboring elements is equal to x (i.e. x = a_i + a_{i + 1} for some i). x had turned out to be a good number as well.

Then the elements of the array a were written out one after another without separators into one string s. For example, if a = [12, 5, 6, 133], then s = 1256133.

You are given a string s and a number x. Your task is to determine the positions in the string that correspond to the adjacent elements of the array that have sum x. If there are several possible answers, you can print any of them.

Input

The first line contains the string s (2 ≤ |s| ≤ 5 ⋅ 10^5).

The second line contains an integer x (2 ≤ x < 10^{200000}).

An additional constraint on the input: the answer always exists, i.e you can always select two adjacent substrings of the string s so that if you convert these substrings to integers, their sum is equal to x.

Output

In the first line, print two integers l_1, r_1, meaning that the first term of the sum (a_i) is in the string s from position l_1 to position r_1.

In the second line, print two integers l_2, r_2, meaning that the second term of the sum (a_{i + 1}) is in the string s from position l_2 to position r_2.

Examples

Input


1256133
17


Output


1 2
3 3


Input


9544715561
525


Output


2 3
4 6


Input


239923
5


Output


1 1
2 2


Input


1218633757639
976272


Output


2 7
8 13

Note

In the first example s[1;2] = 12 and s[3;3] = 5, 12+5=17.

In the second example s[2;3] = 54 and s[4;6] = 471, 54+471=525.

In the third example s[1;1] = 2 and s[2;2] = 3, 2+3=5.

In the fourth example s[2;7] = 218633 and s[8;13] = 757639, 218633+757639=976272.
6724346775336763344646345654634456737536356367343567753377634557564556547345667475473663555555555555555555555555555555555555555555541
55555555555555555555555555555555555555555555
 75341425222343324753425262324443346666666666666666666666666666666666
133333333333333332
 7322541544213454245144115443733264165421346424524421645366666666666666666666666666666666666666666666666666666666
13333333333333333333333333332
 7451524554322352231431411334755253565432236224253242234466666666666666666666666666666666666666666666666666666666
13333333333333333333333333332
 1111111111111111111111111111111111111132222224322222329221
3222222432222232923
 7215312222224424534455131241154521514145531513143222214722541322333553553546524124225553252425663162315333231566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
13333333333333333333333333333333333333333333333333333332
 75321244441512241155122155753322454526223412551322556666666666666666666666666666666666666666666666666666
133333333333333333333333332
 72221321134523541221543221331513321522225422722214211445335522216532213425144325222355236666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
133333333333333333333333333333333333333333332
 723423221134423152233552724424221245524153243663666666666666666666666666666666666666666666666666
1333333333333333333333332
 72542134554133511726422355551345116666666666666666666666666666666666
133333333333333332
 741521344742521354666666666666666666
1333333332
 7142152212435311313322444154224515315454312333214423554154355554134334815216222353541141433244515432461632556542344322543455425546666423433566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
13333333333333333333333333333333333333333333333333333333333333333333332
 7123435314341353543221534414154525324212245124451352241723343541544235354322154551415562632421335622555236235266666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
13333333333333333333333333333333333333333333333333333332
 7551344531325354443521233254132313152532342223765235553242535544463224435413241326354334322366666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
13333333333333333333333333333333333333333333332
 1389741136579513931291454542257669814123353188882921233371869112934592515884229891613876299881532549
1869118859
 77
14
 7321135545352243251333425445513242544554143354732124565645325425144442655562424354455524446566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
13333333333333333333333333333333333333333333332
 725252531112121212735353532112121223666666666666666666666666666666666666
1333333333333333332
 74451523315422515524213224231233555244415442755526234265226155352243243412335662555155436666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
133333333333333333333333333333333333333333332
 7111111214111111552722222221522222256366666666666666666666666666666666666666
13333333333333333332
 7515252522752535363266666666666666666666
13333333332
 72435133535314454515551153143454121434233153245335513342155515735461435454255556155622641434642315442442543463355134432556166666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
133333333333333333333333333333333333333333333333333333333333332
 721523533542244514253454222454252551141552312244432331244233721533543552254625264465223565352561251562323354542431244334166666666666666666666666666666666666666661333333333333333333316666666666666666666666666666666666666666
1333333333333333333333333333333333333333333333333333333333332
 723423215525454544222115724424226625464545223126666666666666666666666666666666666666666666666666
1333333333333333333333332
 7121241524253335342723135263525334534366666666666666666666666666666666666666
13333333333333333332
 1111111111111111111111111111111111111132222222382222222841
3222222238222222285
 7213421422513211131231351222731342253262332224224236233266666666666666666666666666666666666666666666666666666666
13333333333333333333333333332
 7111115552722222565366666666666666666666
13333333332
 7155435311353333135234223554112212513224414324726654632245443424623532365422321352333541542466666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
13333333333333333333333333333333333333333333332
 71111543323213312542532145423325212422232121453313424531534114534445235821225443242143236535432565244263135332321225543244346425452156444552356666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
133333333333333333333333333333333333333333333333333333333333333333333332
 73233433145135133542323554241115544313331743435432561461346433336542422256454133416666666666666666666666666666666666666666666666666666666666666666666666666666666666
133333333333333333333333333333333333333332
 7125352343513324311722545234462442542266666666666666666666666666666666666666
13333333333333333332
 722552511241531111354442321415344442554313145373355362125153222236444332242635544365542425636666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666611111111111112345
13333333333333333333333333333333333333333333332
 7215352445451415433545542342722536345555242543465554334366666666666666666666666666666666666666666666666666666666
13333333333333333333333333332
 63451234887584191635778146328716294424124839893546
6996469335
 44
8
 49912217999385523554991221799938552355119789323198525256511
11978932319852525652
 7111551231232252334251215245512545222422334212821166234233225334536131635662255523243234522266666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
13333333333333333333333333333333333333333333332
 8993916542682434571141424849823473251739621791489112772491331576369966321319943333635595635194459724
78613
 711124452213553314344225233225434151523143351534352345431114214332231544215331142722224552224653425354335334235445262624243452635453346542215315333342654215341143666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
1333333333333333333333333333333333333333333333333333333333333333333333333333333332
 712124152425333534311111111111111111723135263525334534322222222222222221666666666666666666666666666666666666666666666666666666666666666666666666
1333333333333333333333333333333333332
 5727944836753191447441188857216798214675797767295497143968172216181828777762464112176717672592669436
16993845184753532657289664818579199818525236939897
 7114542154142244353344334341423243821554325524325546444533534143424366666666666666666666666666666666666666666666666666666666666666666666
13333333333333333333333333333333332

89 132
133 133 35 51
52 68 57 84
85 112 57 84
85 112 38 38
39 57 111 165
166 220 53 78
79 104 89 132
133 176 49 72
73 96 35 51
52 68 19 27
28 36 141 210
211 280 111 165
166 220 93 138
139 184 58 67
68 71 1 1
2 2 93 138
139 184 37 54
55 72 89 132
133 176 39 57
58 76 21 30
31 40 124 185
186 247 121 161
162 222 48 71
72 95 39 57
58 76 38 38
39 57 57 84
85 112 21 30
31 40 93 138
139 184 143 213
214 284 83 123
124 164 39 57
58 76 93 138
139 184 57 84
85 112 28 37
38 47 1 1
2 2 39 58
59 59 93 138
139 184 8 12
13 17 163 243
244 324 73 108
109 144 2 50
51 99 69 102
103 136
/*学习古代文章，诗词
长恨歌

白居易

汉皇重色思倾国，御宇多年求不得。

杨家有女初长成，养在深闺人未识。

天生丽质难自弃，一朝选在君王侧。

回眸一笑百媚生，六宫粉黛无颜色。

春寒赐浴华清池，温泉水滑洗凝脂。

侍儿扶起娇无力，始是新承恩泽时。

云鬓花颜金步摇，芙蓉帐暖度春宵。

春宵苦短日高起，从此君王不早朝。

承欢侍宴无闲暇，春从春游夜专夜。

后宫佳丽三千人，三千宠爱在一身。

金屋妆成娇侍夜，玉楼宴罢醉和春。

姊妹弟兄皆列土，可怜光彩生门户。

遂令天下父母心，不重生男重生女。

骊宫高处入青云，仙乐风飘处处闻。

缓歌慢舞凝丝竹，尽日君王看不足。

渔阳鼙鼓动地来，惊破霓裳羽衣曲。

九重城阙烟尘生，千乘万骑西南行。

翠华摇摇行复止，西出都门百余里。

六军不发无奈何，宛转蛾眉马前死。

花钿委地无人收，翠翘金雀玉搔头。

君王掩面救不得，回看血泪相和流。

黄埃散漫风萧索，云栈萦纡登剑阁。

峨嵋山下少人行，旌旗无光日色薄。

蜀江水碧蜀山青，圣主朝朝暮暮情。

行宫见月伤心色，夜雨闻铃肠断声。

天旋地转回龙驭，到此踌躇不能去。

马嵬坡下泥土中，不见玉颜空死处。

君臣相顾尽沾衣，东望都门信马归。

归来池苑皆依旧，太液芙蓉未央柳。

芙蓉如面柳如眉，对此如何不泪垂？

春风桃李花开日，秋雨梧桐叶落时。

西宫南内多秋草，落叶满阶红不扫。

梨园弟子白发新，椒房阿监青娥老。

夕殿萤飞思悄然，孤灯挑尽未成眠。

迟迟钟鼓初长夜，耿耿星河欲曙天。

鸳鸯瓦冷霜华重，翡翠衾寒谁与共？

悠悠生死别经年，魂魄不曾来入梦。

临邛道士鸿都客，能以精诚致魂魄。

为感君王辗转思，遂教方士 殷勤觅。

排空驭气奔如电，升天入地求之遍。

上穷碧落下黄泉，两处茫茫皆不见。

忽闻海上有仙山，山在虚无缥缈间。

楼阁玲珑五云起，其中绰约多仙子。

中有一人字太真，雪肤花貌参差是。

金阙西厢叩玉扃，转教小玉报双成。

闻道汉家天子使，九华帐里梦魂惊。

揽衣推枕起徘徊，珠箔银屏迤逦开。

云鬓半偏新睡觉，花冠不整下堂来。

风吹仙袂飘飖举，犹似霓裳羽衣舞。

玉容寂寞泪阑干，梨花一枝春带雨。

含情凝睇谢君王，一别音容两渺茫。

昭阳殿里恩爱绝，蓬莱宫中日月长。

回头下望人寰处，不见长安见尘雾。

惟将旧物表深情，钿合金钗寄将去。

钗留一股合一扇，钗擘黄金合分钿。

但教心似金钿坚，天上人间会相见。

临别殷勤重寄词，词中有誓两心知。

七月七日长生殿，夜半无人私语时。

在天愿作比翼鸟，在地愿为连理枝。

天长地久有时尽，此恨绵绵无绝期。
*/
//Generated at 2021-10-12 15:12:17 UTC+8
//Created by Alphagocc
#ifndef TYPE_HPP
#define TYPE_HPP
#include <type_traits>
#ifndef __cpp_lib_void_t
namespace std
{
template <typename...> using void_t = void;
}
#endif
template <typename T, typename _ = void> struct is_container : std::false_type
{};
template <typename... Ts> struct is_container_helper
{};
template <typename T>
struct is_container<T,
    typename std::conditional<false,
        is_container_helper<decltype(std::declval<T>().size()),
            decltype(std::declval<T>().begin()),
            decltype(std::declval<T>().end()),
            decltype(std::declval<T>().cbegin()),
            decltype(std::declval<T>().cend())>,
        void>::type> : public std::true_type
{};
#endif
#include <bits/stdc++.h>
#define FORCE_INLINE __inline__ __attribute__((always_inline))
class IO
{
    static const int bufSize = 1 << 20;

    char inBuf[bufSize], outBuf[bufSize];
    char *ip1 = inBuf, *ip2 = inBuf;
    int goodReadBit = 1, op1 = -1, op2 = bufSize - 1;
    FORCE_INLINE int gc()
    {
        return ip1 == ip2
                && (ip2 = (ip1 = inBuf) + fread(inBuf, 1, bufSize, stdin),
                    ip1 == ip2)
            ? (goodReadBit = 0, EOF)
            : *ip1++;
    }
    template <typename T> FORCE_INLINE void __RI(T &x)
    {
        int ch = gc(), neg = 1;
        x = 0;
        for (; !(isdigit(ch) || ch == '-' || ch == EOF); ch = gc()) {}
        if (ch == EOF) return;
        if (ch == '-') neg = -1, ch = gc();
        for (; isdigit(ch); ch = gc()) x = x * 10 + (ch - 48) * neg;
    }
    template <typename T> FORCE_INLINE void __RC(T &x)
    {
        int ch;
        while (isspace(ch = gc())) {}
        if (ch == EOF) return;
        x = ch;
    }
    FORCE_INLINE void __RS(std::string &x)
    {
        char ch;
        x.clear();
        for (ch = gc(); isspace(ch); ch = gc()) {}
        if (ch == EOF) return;
        for (; !isspace(ch) && ch != EOF; ch = gc()) x.push_back(ch);
    }

public:
    FORCE_INLINE IO &R(char &x) { return __RC(x), (*this); }
    FORCE_INLINE IO &R(unsigned char &x) { return __RC(x), (*this); }
    FORCE_INLINE IO &R(std::string &x) { return __RS(x), (*this); }
    template <typename T1, typename T2> FORCE_INLINE IO &R(std::pair<T1, T2> &x)
    {
        return R(x.first), R(x.second), (*this);
    }
    template <typename T, typename... Args> FORCE_INLINE IO &RA(T *a, int n)
    {
        for (int i = 0; i < n; ++i) R(a[i]);
        return (*this);
    }
    template <typename T, typename... Args>
    FORCE_INLINE IO &R(T &x, Args &...args)
    {
        return R(x), R(args...), (*this);
    }
    template <typename T, typename... Args>
    FORCE_INLINE IO &RA(T *a, int n, Args... args)
    {
        for (int i = 0; i < n; ++i) RA(a[i], args...);
        return (*this);
    }
    template <typename T>
    FORCE_INLINE typename std::enable_if<std::is_integral<T>::value, IO>::type &
        R(T &x)
    {
        return __RI(x), (*this);
    }
    template <typename T>
    FORCE_INLINE typename std::enable_if<is_container<T>::value, IO>::type &R(
        T &x)
    {
        for (auto &i : x) R(i);
        return (*this);
    }
    template <typename T>
    FORCE_INLINE typename std::enable_if<
        std::is_void<std::void_t<decltype(std::declval<T>().read())>>::value,
        IO>::type &
        R(T &x)
    {
        return x.read(), (*this);
    }

private:
    char space = ' ';
    FORCE_INLINE void pc(const char &x)
    {
        if (op1 == op2) flush();
        outBuf[++op1] = x;
    }
    template <typename T> FORCE_INLINE void __WI(T x)
    {
        static char buf[sizeof(T) * 16 / 5];
        static int len = -1;
        if (x >= 0) {
            do {
                buf[++len] = x % 10 + 48, x /= 10;
            } while (x);
        } else {
            pc('-');
            do {
                buf[++len] = -(x % 10) + 48, x /= 10;
            } while (x);
        }
        while (len >= 0) { pc(buf[len]), --len; }
    }

public:
    FORCE_INLINE void flush() { fwrite(outBuf, 1, op1 + 1, stdout), op1 = -1; }
    FORCE_INLINE IO &W(const char &x) { return pc(x), (*this); }
    FORCE_INLINE IO &W(const char *x)
    {
        while (*x != '\0') pc(*(x++));
        return (*this);
    }
    FORCE_INLINE IO &W(const std::string &x) { return W(x.c_str()), (*this); }
    template <typename T1, typename T2>
    FORCE_INLINE IO &W(const std::pair<T1, T2> &x)
    {
        WS(x.first);
        W(x.second);
        return (*this);
    }
    FORCE_INLINE IO &WL() { return W('\n'), (*this); }
    template <typename T> FORCE_INLINE IO &WL(const T &x)
    {
        return W(x), W('\n'), (*this);
    }
    FORCE_INLINE IO &WS() { return W(space), (*this); }
    template <typename T> FORCE_INLINE IO &WS(const T &x)
    {
        return W(x), W(space), (*this);
    }
    template <typename T> FORCE_INLINE IO &WA(T *a, int n)
    {
        for (int i = 0; i < n; i++) WS(a[i]);
        WL();
        return (*this);
    }
    template <typename T, typename... Args>
    FORCE_INLINE IO &W(const T &x, const Args &...args)
    {
        W(x), W(space), W(args...);
        return (*this);
    }
    template <typename T, typename... Args>
    FORCE_INLINE IO &WS(const T &x, const Args &...args)
    {
        return W(x), W(space), W(args...), W(space), (*this);
    }
    template <typename... Args> FORCE_INLINE IO &WL(const Args &...args)
    {
        return W(args...), W('\n'), (*this);
    }
    template <typename T, typename... Args>
    FORCE_INLINE IO &WA(T *a, int n, Args... args)
    {
        for (int i = 0; i < n; i++) WA(a[i], args...);
        return (*this);
    }
    template <typename T>
    FORCE_INLINE typename std::enable_if<std::is_integral<T>::value, IO>::type &
        W(const T &x)
    {
        return __WI(x), (*this);
    }
    template <typename T>
    FORCE_INLINE typename std::enable_if<is_container<T>::value, IO>::type &W(
        const T &x)
    {

        for (auto &i : x) WS(i);
        WL();
        return (*this);
    }
    template <typename T>
    FORCE_INLINE typename std::enable_if<
        std::is_void<std::void_t<decltype(std::declval<T>().write())>>::value,
        IO>::type &
        W(const T &x)
    {
        return x.write(), (*this);
    }
    template <typename T> FORCE_INLINE IO &operator>>(T &x)
    {
        R(x);
        return (*this);
    }
    template <typename T> FORCE_INLINE IO &operator<<(const T &x)
    {
        W(x);
        return (*this);
    }
    int good() { return goodReadBit; }
    IO() {}
    ~IO() { flush(); }
} io;
#undef FORCE_INLINE

#ifndef UTIL_HPP
#define UTIL_HPP
#include <bits/stdc++.h>
#define var auto
#define ALL(x) x.begin(), x.end()
const std::int32_t INF = 0x3f3f3f3f;
const std::int64_t INFL = 0x3f3f3f3f3f3f3f3f;
#define If(x, y, z) ((x) ? (y) : (z))
#endif
#include "windows.h"
// https://www.zhihu.com/question/378525362/answer/1078276038;

constexpr unsigned int CreateSeed(
    const char *str, const unsigned int initial_result = 0)
{
    return *str == 0
        ? initial_result
        : CreateSeed(str + 1, ((initial_result << 8ULL) + *str) & UINT_MAX);
}

template <typename... RemainingStrings>
constexpr unsigned int CreateSeed(
    const char *first_str, const RemainingStrings &...remaining_strs)
{
    return CreateSeed(first_str, CreateSeed(remaining_strs...));
}

template <unsigned int Seed> struct Random
{
    static constexpr unsigned int value
        = (134775813ULL * Seed + 1ULL) & UINT_MAX;
    using next = Random<value>;
};
constexpr bool isPrime(int x)
{
    for (int i = 2; i * i <= x; i++)
        if (x % i == 0) return 0;
    return 1;
}
using namespace std;
constexpr unsigned int kSeed = CreateSeed(__TIME__, __DATE__);
constexpr int randomPrimeInCompileTime()
{
    int x = Random<kSeed>::value;
    x &= 0x3fffffff;
    if (x < int(1e8)) x += 1e8;
    while (!isPrime(x)) x++;
    return x;
}
int CodeforcesRandSeed()
{
    int x = GetCurrentProcessId();
    x ^= (int64_t)GetProcessHeap();
    x ^= (int64_t)HeapAlloc(GetProcessHeap(), 0, 1);
    auto dummy = new char;
    x ^= (int64_t)dummy;
    x ^= random_device{}();
    x ^= chrono::high_resolution_clock().now().time_since_epoch().count();
    return x;
}
mt19937_64 rng(CodeforcesRandSeed());
int randomPrime()
{
    int x = Random<kSeed>::value;
    x &= 0x3fffffff;
    if (x < int(1e8)) x += 1e8;
    while (!isPrime(x)) x++;
    return x;
}
vector<int> zAlgo(string s)
{
    int n = s.length();
    vector<int> z(n + 1);
    z[0] = n;
    int j = 0;
    for (int i = 1; i <= n;) {
        for (; i + j < n && s[i + j] == s[j]; j++)
            ;
        if (z[i] = j) {
            int k;
            for (k = 1; k + z[k] < z[i]; k++) z[i + k] = z[k];
            i += k;
            j -= k;
        } else
            i++;
    }
    return z;
}
const int Ps[] = { 257, 65537, 17 };
uniform_int_distribution<int> dis(0, sizeof(Ps) / sizeof(Ps[0]) - 1);
namespace Math
{
template <typename T, typename T2> T qpow(T a, T2 b, const int &MOD)
{
    T ans = 1;
    for (; b; b >>= 1) {
        if (b & 1) ans = (a * ans) % MOD;
        a = (a * a) % MOD;
    }
    return ans;
}
template <typename T> T exgcd(T l, T r, T &x, T &y)
{
    if (!r) {
        x = 1, y = 0;
        return l;
    } else {
        int d = exgcd(r, l % r, y, x);
        y -= l / r * x;
        return d;
    }
}
template <typename T> T inv(T a, const int &MOD)
{
    return qpow(a, MOD - 2, MOD);
}
template <typename T> T exinv(T a, const int &MOD)
{
    T x, y;
    exgcd(a, MOD, x, y);
    x %= MOD;
    return x + ((x >> (sizeof(T) * 8 - 1)) & MOD);
}
// Only Use Signed Integer
template <typename T, T MOD> struct ModInt
{
    T x;
    ModInt(T x = 0)
        : x(x)
    {
        while (x < 0) x += MOD;
    }
    ModInt<T, MOD> operator+=(const ModInt<T, MOD> &y)
    {
        x += y.x - MOD;
        x += (x >> (sizeof(T) * 8 - 1)) & MOD;
        return (*this);
    }
    ModInt<T, MOD> operator-=(const ModInt<T, MOD> &y)
    {
        x = x - y.x;
        x += (x >> (sizeof(T) * 8 - 1)) & MOD;
        return (*this);
    }
    ModInt<T, MOD> operator*=(const ModInt<T, MOD> &y)
    {
        x = x * y.x % MOD;
        return (*this);
    }
    ModInt<T, MOD> operator/=(const ModInt<T, MOD> &y)
    {
        x = x * inv(y.x, MOD) % MOD;
        return (*this);
    }
    ModInt<T, MOD> pow(int64_t p) { return x = qpow(x, p, MOD), *this; }
    void write() const { io.W(x); }
};
template <typename T, T MOD>
ModInt<T, MOD> operator+(ModInt<T, MOD> a, const ModInt<T, MOD> &b)
{
    a += b;
    return a;
}
template <typename T, T MOD>
ModInt<T, MOD> operator-(ModInt<T, MOD> a, const ModInt<T, MOD> &b)
{
    a -= b;
    return a;
}
template <typename T, T MOD>
ModInt<T, MOD> operator*(ModInt<T, MOD> a, const ModInt<T, MOD> &b)
{
    a *= b;
    return a;
}
template <typename T, T MOD>
ModInt<T, MOD> operator/(ModInt<T, MOD> a, const ModInt<T, MOD> &b)
{
    a /= b;
    return a;
}
template <typename T, T MOD>
bool operator==(const ModInt<T, MOD> &a, const ModInt<T, MOD> &b)
{
    return a.x == b.x;
}
}
const int MOD1 = randomPrimeInCompileTime(), MOD2 = randomPrime();
struct Hash2
{
    using mint = Math::ModInt<int64_t, MOD1>;
    using H = Hash2;
    mint h1;
    int64_t h2;
    Hash2(mint h1 = 0, int64_t h2 = 0)
        : h1(h1)
        , h2(h2)
    {}
    H &operator+=(const H &y)
    {
        h2 += y.h2 - MOD2;
        h2 += (h2 >> (sizeof(int64_t) * 8 - 1)) & MOD2;
        h1 += y.h1;
        return *this;
    }
    H &operator-=(const H &y)
    {
        h2 -= y.h2;
        h2 += (h2 >> (sizeof(int64_t) * 8 - 1)) & MOD2;
        h1 -= y.h1;
        return *this;
    }
    H &operator*=(const H &y)
    {
        h1 = h1 * y.h1;
        h2 = h2 * y.h2 % MOD2;
        return *this;
    }
};
Hash2 operator+(Hash2 a, const Hash2 &b)
{
    a += b;
    return a;
}
Hash2 operator-(Hash2 a, const Hash2 &b)
{
    a -= b;
    return a;
}
Hash2 operator*(Hash2 a, const Hash2 &b)
{
    a *= b;
    return a;
}
bool operator==(const Hash2 &a, const Hash2 &b)
{
    return a.h1 == b.h1 && a.h2 == b.h2;
}
struct RollingHash
{
    using H = Hash2;
    int n;
    vector<H> pw, hs;
    RollingHash(string s, int P1, int P2)
    {
        n = s.size();
        auto P = H(P1, P2);
        pw.resize(n + 1, H(0, 0));
        hs = pw;
        pw[0] = H(1, 1);
        for (int i = 1; i <= n; i++) pw[i] = pw[i - 1] * P;
        for (int i = 0; i < n; i++)
            hs[i + 1] = hs[i] * P + H(s[i] - '0', s[i] - '0');
    }
    H getHash(int l, int r) { return hs[r] - hs[l] * pw[r - l]; }
};

int main()
{
    string s, t;
    io >> s >> t;
    auto z = zAlgo(t + "$" + s);
    int P1 = 10, P2 = 10;
    auto hs = RollingHash(s, P1, P2);
    auto ht = RollingHash(t, P1, P2);
    int n = s.size(), m = t.size();
    auto want = ht.getHash(0, m);
    vector<int> lcp(n);
    for (int i = 0; i < n; i++) { lcp[i] = min(z[i + m + 1], m); }
    auto test = [&](int l1, int r1, int l2, int r2) {
        /* io.WL(l1 + 1, r1, l2 + 1, r2);
        io.WL(hs.getHash(l1, r1).h1, hs.getHash(l1, r1).h2);
        io.WL(hs.getHash(l2, r2).h1, hs.getHash(l2, r2).h2);
        io.WL(want.h1, want.h2); */
        if (hs.getHash(l1, r1) + hs.getHash(l2, r2) == want) {
            io.WL(l1 + 1, r1).WL(l2 + 1, r2);
            exit(0);
        }
    };
    auto check = [&](int l, int r, int k) {
        // io.WL(l, r, k);
        if (k > 0) {
            if (r + k <= n) test(l, r, r, r + k);
            if (l - k >= 0) test(l - k, l, l, r);
        }
    };
    for (int i = 0; i < n; i++) {
        {
            check(i, i + m, m - lcp[i] + 1);
            check(i, i + m, m - lcp[i]);
        }
        if (m > 1) {
            check(i, i + m - 1, m);
            check(i, i + m - 1, m - 1);
        }
    }
    return 0;
}