#include <cstdio>
#include <unordered_map>

const long long MOD = 998244353;

long long q_pow(long long base, long long idx)  //带取模的快速幂
{
    long long answer = 1;
    while (idx)
    {
        if (idx & 1)
        {
            answer = answer * base % MOD;
        }
        base = base * base % MOD;
        idx >>= 1;
    }
    return answer;
}

long long a, b, c, d;

long long calc(long long x, long long y, long long base)
{
    long long sum = 0; //求算出来最终的幂
    for (long long i = a; i <= b; ++i)
    {
        long long min = x * i / y; //使得y*k > x*i的最小值
        /*有关min用法：
        【相应的分析放到了“题目分析”里】
        */
        if (min > d) //这里的处理方式是，如果bound > d，则不存在k∈(mid,d]的区间，直接令min=d，使得后面加这个区间时len(k)=0--->sum+=0。
            min = d;
        else if (min < c) //同理，如果min < c，则不存在k∈[c,min]的区间，直接令min=c-1，使得后面加这个区间时sum(k)=0--->sum+=0。
            min = c - 1;
        sum = (sum + (y * (c + min) * (min - c + 1) / 2)) % (MOD - 1); //对应k∈[c,min]情况
        sum = (sum + x * i * (d - min)) % (MOD - 1);                   //对应k∈(min,d]情况
        /* % (MOD - 1)的原因：
        这里是数论里的欧拉函数应用
        */
    }
    long long res = q_pow((long long)base, sum);
    return res;
}

int main()
{
    long long x, y;
    scanf("%lld %lld %lld %lld %lld %lld", &a, &b, &c, &d, &x, &y);

    std::unordered_map<long long, long long> factor_nums;

    for (long long i = 2; i * i <= x; ++i) //分解x的质因数
    {
        while (x % i == 0)
        {
            ++factor_nums[i];
            x /= i;
        }
    }
    if (x > 1)
        ++factor_nums[x];

    long long answer = 1;
    for (long long i = 2; i * i <= y; ++i) //对y按顺序分解质因数
    {
        if (y % i == 0)
        {
            long long count = 0;
            do
            {
                ++count;
                y /= i;
            } while (y % i == 0);
            if (factor_nums[i])
                answer = answer * calc(factor_nums[i], count, i) % MOD;
        }
    }
    if (y > 1 && factor_nums[y]) //y剩下的
        answer = answer * calc(factor_nums[y], 1, y) % MOD;
    printf("%lld\n", answer);
    return 0;
}

#include <bits/stdc++.h>
#define Length 100005
#define to_Left toLoc - 1
#define to_Right toLoc + 1
using namespace std;
int start[Length], to[Length], current[Length] = {0}, n, l, sum = 0;
int check(int topPrime, int top, int toLoc)
{
    if (current[top] && to[top] == toLoc)
        return 0;
    /* FIX&WA
    FIX.1. 经过已经到达了要去的点，应该直接返回0。
    WA.2. 第一次改没加to[top]==toLoc，可能在之后的使用中要去的点不是本要去的点，但却在之前current=1
    */
    if (toLoc < start[top]) //左移
    {
        if (top == 1) //最左边的节点
        {
            if (toLoc == 1) //去左墙
            {
                if (toLoc == to[top]) //如果恰好是要去的地方，把current=1
                    current[top] = 1; 
                return 1;
            }
            else
                return -1;
        }
        else //不是最左边的
        {
            if (topPrime == top - 1) //反复横跳了
                return -1;
            int checkToLeft = check(top, top - 1, to_Left); //左边那个，能否去要去点的左边
            if (checkToLeft != -1)
            {
                if (toLoc == to[top])
                    current[top] = 1; //如果恰好是要去的地方，把current=1
                return checkToLeft + 1;
            }
            else
                return -1;
        }
    }
    else if (toLoc > start[top]) //右移
    {
        if (top == n) //最右边的节点
        {
            if (toLoc == l) //去右墙
            {
                if (toLoc == to[top])
                    current[top] = 1; //如果恰好是要去的地方，把current=1
                return 1;
            }
            else
                return -1;
        }
        else //不是最右边的
        {
            if (topPrime == top + 1) //反复横跳了
                return -1;
            int checkToLeft = check(top, top + 1, to_Right); //右边那个，能否去要去点的右边
            if (checkToLeft != -1)
            {
                if (toLoc == to[top])
                    current[top] = 1; //如果恰好是要去的地方，把current=1
                return checkToLeft + 1;
            }
            else
                return -1;
        }
    }
    else //不移动
    {
        if (toLoc == to[top])
        /* WA
        WA.3. 有可能这步要让他在原地不动，但不是他最终要去的地方，故这个判断很重要！
        */
            current[top] = 1;
            /* WA
            WA.1. 不移动的时候要改current=1
            */
        return 0;
    }
}
signed main()
{
#ifdef SuperSASS
    freopen("data.in", "r", stdin);
#endif
    scanf("%d%d", &n, &l);
    for (int i = 1; i <= n; i++)
        scanf("%d", start + i);
    for (int i = 1; i <= n; i++)
        scanf("%d", to + i);
    for (int i = 1; i <= n; i++) //从左到右check。
        if (!current[i]) //如果在某次操作中已经到达最终位置，便不再计算
        {
            int value = check(i, i, to[i]);
            if (value == -1)
            {
                printf("-1");
                return 0;
            }
            else
                sum += value;
        }
    printf("%d", sum);
    return 0;
}

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

typedef long long LL;

const int N = 100005;

int n, m, a[N + 9], b[N + 9];

LL ans;

void Get_ans()
{
    ++n;
    a[n] = b[n] = m + 1;         //技巧1：最右侧加个墙壁，方便计算最右侧区间长度。
    for (int i = n; i >= 1; --i) //把始末状态转换为区间长度，其中a[i]=i-1~i的距离
        a[i] -= a[i - 1] + 1, b[i] -= b[i - 1] + 1;
    for (int i = 1, j = 1; i <= n; ++i)
    {
        if (!b[i]) //从左向右，一直找到终状态存在长度（需要合并操作）的区间。
            continue;
        for (; !a[j]; ++j); //从初状态中未合并过的区间开始向右找，找到存在长度（可以合并）的区间。
        int sum = 0, l = j; //l记录左边开始进行合并的位置。
        for (; j <= n && sum < b[i]; ++j) //尝试进行b[i]=a[l]+a[l+1]+...+a[r-1]+a[r]这个操作
            sum += a[j];
        if (sum ^ b[i]) //如果无法把b[i]这个区间由若干个a[i]区间拼合而成，则不满足，输出-1
        {
            ans = -1;
            return;
        }
        ans += max(i - l, 0) + max(j - 1 - i, 0); //ans加上：完成这个区间合并操作所要操作的节点个数（左侧和右侧）。【要合并1——3区间，只需要移动2个节点，即3-1=2……

        /* 变量解释：
        i为当前要合并的区间
        l为操作到最左边的区间
        j为操作到最右边的区间(由于for的原因，这里j比实际的r多了1)
          【这里非常巧妙的是：正因为j比实际的r多1，导致下次查找的时候j会跳过之前已找过的区间，不会重复合并。
        */
        /* 是否需要max：
        是需要的。存在减为负数的情况。
        如：
        > 1 2 3 4 5
        > 6 7 8 9 10
        a（开始状态）数组为: 0、0、0、0、0、5
        b（结束状态）数组为: 5、0、0、0、0、0
        那么i=1、l=6、j=7
        */
    }
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i)
        scanf("%d", &a[i]);
    for (int i = 1; i <= n; ++i)
        scanf("%d", &b[i]);
    Get_ans();
    printf("%lld\n", ans);
    return 0;
}