using AtCoder;
using AtCoder.Internal;
using System;
using System.Diagnostics;
using System.Globalization;
using System.Numerics;
using System.Runtime.CompilerServices;
class Program
{
    static void Main()
    {
        SourceExpander.Expander.Expand();

        int T = int.Parse(Console.ReadLine());
        for (int i = 0; i < T; i++)
        {
            Solve();
        }

        void Solve()
        {
            long[] input = Console.ReadLine().Split().Select(_ => long.Parse(_)).ToArray();
            long H1 = input[0];
            long A1 = input[1];
            long S1 = input[2];
            long H2 = input[3];
            long A2 = input[4];
            long S2 = input[5];

            long T1 = H1 % A2 == 0 ? H1 / A2 : H1 / A2 + 1;
            long T2 = H2 % A1 == 0 ? H2 / A1 : H2 / A1 + 1;

            StaticModInt<AtCoder.Mod998244353> res = new StaticModInt<Mod998244353>();
            if (S1 > S2)
            {
                res = F(T1, T2);
            }
            if (S1 < S2)
            {
                res = 1 - F(T2, T1);
            }
            if (S1 == S2)
            {
                res = (F(T1, T2) + 1 - F(T2, T1)) / 2;
            }
            Console.WriteLine(res.Value);
        }

        StaticModInt<AtCoder.Mod998244353> F(long x, long y)
        {
            StaticModInt<AtCoder.Mod998244353> res = new StaticModInt<AtCoder.Mod998244353>();
            StaticModInt<AtCoder.Mod998244353> ten = new StaticModInt<AtCoder.Mod998244353>(10);

            if (x == 1 && y == 1)
            {
                res = 10;
                res /= 11;
                return res;
            }
            if (x >= 2 && y >= 2)
            {
                return F(x - Math.Min(x - 1, y - 1), y - Math.Min(x - 1, y - 1));
            }
            if (x == 1 && y >= 2)
            {
                return (1 / ten).Pow(y - 1) * F(1, 1);
            }
            if (x >= 2 && y == 1)
            {
                return (1 / ten).Pow(x - 1) * F(1, 1) + (1 - ((1 / ten).Pow(x - 1)));
            }
            return 0;
        }
    }
}

#region Expanded by https://github.com/kzrnm/SourceExpander
namespace AtCoder.Internal{public class Barrett(uint m){public readonly uint Mod=m;public readonly ulong IM=ulong.MaxValue/m+1;[MethodImpl(256)]public uint Mul(uint a,uint b)=>Reduce((ulong)a*b);[MethodImpl(256)]public uint Reduce(ulong z){var x=System.Math.BigMul(IM,z,out _);var y=x*Mod;if(z<y)return(uint)(z-y+Mod);return(uint)(z-y);}[MethodImpl(256)]public uint Pow(long x,long n){return Pow(x,(ulong)n);}[MethodImpl(256)]public uint Pow(long x,ulong n){if(Mod==1)return 0;uint r=1,y=(uint)ModCalc.SafeMod(x,Mod);while(n>0){if((n&1)!=0)r=Mul(r,y);y=Mul(y,y);n>>=1;}return r;}}}
namespace AtCoder.Internal{public static class ModCalc{[MethodImpl(256)]public static long InvMod(long x,long m){var(g,res)=InvGcd(x,m);return res;}[MethodImpl(256)]public static(long,long)InvGcd(long a,long b){a=SafeMod(a,b);if(a==0)return(b,0);long s=b,t=a;long m0=0,m1=1;long u;while(true){if(t==0){if(m0<0)m0+=b/s;return(s,m0);}u=s/t;s-=t*u;m0-=m1*u;if(s==0){if(m1<0)m1+=b/t;return(t,m1);}u=t/s;t-=s*u;m1-=m0*u;}}[MethodImpl(256)]public static long SafeMod(long x,long m){x%=m;if(x<0)x+=m;return x;}[MethodImpl(256)]public static uint PowMod(long x,long n,int m){if(m==1)return 0;return new Barrett((uint)m).Pow(x,n);}[MethodImpl(256)]public static(long y,long z)Crt(long[]r,long[]m){long r0=0,m0=1;for(int i=0;i<m.Length;i++){long r1=SafeMod(r[i],m[i]);long m1=m[i];if(m0<m1){(r0,r1)=(r1,r0);(m0,m1)=(m1,m0);}if(m0%m1==0){if(r0%m1!=r1)return(0,0);continue;}var(g,im)=InvGcd(m0,m1);long u1=(m1/g);if((r1-r0)%g!=0)return(0,0);long x=(r1-r0)/g%u1*im%u1;r0+=x*m0;m0*=u1;if(r0<0)r0+=m0;}return(r0,m0);}}}
namespace AtCoder{public interface IIntBase<T>:INumberBase<T>where T:IIntBase<T>{static T INumberBase<T>.Zero=>default;static T IAdditiveIdentity<T,T>.AdditiveIdentity=>T.Zero;static T IMultiplicativeIdentity<T,T>.MultiplicativeIdentity=>T.One;static int INumberBase<T>.Radix=>2;static bool INumberBase<T>.IsZero(T v)=>v==T.Zero;static bool INumberBase<T>.IsCanonical(T v)=>true;static bool INumberBase<T>.IsSubnormal(T v)=>false;static bool INumberBase<T>.IsComplexNumber(T v)=>false;static bool INumberBase<T>.IsRealNumber(T v)=>true;static bool INumberBase<T>.IsImaginaryNumber(T v)=>false;static bool INumberBase<T>.IsFinite(T v)=>true;static bool INumberBase<T>.IsInfinity(T v)=>false;static bool INumberBase<T>.IsNegativeInfinity(T v)=>false;static bool INumberBase<T>.IsPositiveInfinity(T v)=>false;static bool INumberBase<T>.IsInteger(T v)=>true;static bool INumberBase<T>.IsNaN(T v)=>false;static bool INumberBase<T>.IsNormal(T v)=>!T.IsZero(v);static abstract bool TryParse(ReadOnlySpan<char>s,out T r);static virtual T Parse(ReadOnlySpan<char>s)=>T.TryParse(s,out T r)?r:throw new FormatException();static bool INumberBase<T>.TryParse(ReadOnlySpan<char>s,NumberStyles style,IFormatProvider provider,out T res)=>T.TryParse(s,out res);static bool INumberBase<T>.TryParse(string s,NumberStyles style,IFormatProvider provider,out T res)=>T.TryParse(s,out res);static bool ISpanParsable<T>.TryParse(ReadOnlySpan<char>s,IFormatProvider provider,out T res)=>T.TryParse(s,out res);static bool IParsable<T>.TryParse(string s,IFormatProvider provider,out T res)=>T.TryParse(s,out res);static T INumberBase<T>.Parse(ReadOnlySpan<char>s,NumberStyles style,IFormatProvider provider)=>T.Parse(s);static T INumberBase<T>.Parse(string s,NumberStyles style,IFormatProvider provider)=>T.Parse(s);static T IParsable<T>.Parse(string s,IFormatProvider provider)=>T.Parse(s);static T ISpanParsable<T>.Parse(ReadOnlySpan<char>s,IFormatProvider provider)=>T.Parse(s);}}
namespace AtCoder{public interface IModInt<T>:INumberBase<T>where T:INumberBase<T>{T Inv();T Pow(ulong n);int Value{get;}static abstract int Mod{get;}static abstract T Raw(int v);}public interface IModIntNumberBase<T>:IModInt<T>,IIntBase<T>where T:IModInt<T>,IIntBase<T>{static T INumberBase<T>.Abs(T v)=>v;static bool INumberBase<T>.IsPositive(T v)=>true;static bool INumberBase<T>.IsNegative(T v)=>false;static bool INumberBase<T>.IsEvenInteger(T v)=>int.IsEvenInteger(v.Value);static bool INumberBase<T>.IsOddInteger(T v)=>int.IsOddInteger(v.Value);static T INumberBase<T>.MaxMagnitude(T x,T y)=>T.Raw(int.Max(x.Value,y.Value));static T INumberBase<T>.MaxMagnitudeNumber(T x,T y)=>T.Raw(int.Max(x.Value,y.Value));static T INumberBase<T>.MinMagnitude(T x,T y)=>T.Raw(int.Min(x.Value,y.Value));static T INumberBase<T>.MinMagnitudeNumber(T x,T y)=>T.Raw(int.Min(x.Value,y.Value));bool ISpanFormattable.TryFormat(Span<char>destination,out int charsWritten,ReadOnlySpan<char>format,IFormatProvider provider)=>Value.TryFormat(destination,out charsWritten,format,provider);static bool Cnv<TF,TT>(TF v,out TT r)where TF:INumberBase<TF>where TT:INumberBase<TT> =>typeof(TF)==typeof(TT)?(r=(TT)(object)v)is{}:TT.TryConvertFromChecked(v,out r)||TF.TryConvertToChecked(v,out r);[MethodImpl(256)]static bool ConvF<TF>(TF v,out T r)where TF:INumberBase<TF>{BigInteger b;if(typeof(TF)==typeof(BigInteger))b=(BigInteger)(object)v;else if(!Cft(v,out b)&&!TF.TryConvertToTruncating(v,out b)){r=default;return false;}var m=(int)(b%T.Mod);if(m<0)m+=T.Mod;r=T.Raw(m);return true;[MethodImpl(256)]static bool Cft<B>(TF v,out B r)where B:INumberBase<B> =>B.TryConvertFromTruncating(v,out r);}static bool INumberBase<T>.TryConvertFromChecked<TF>(TF v,out T r)=>ConvF(v,out r);static bool INumberBase<T>.TryConvertFromSaturating<TF>(TF v,out T r)=>ConvF(v,out r);static bool INumberBase<T>.TryConvertFromTruncating<TF>(TF v,out T r)=>ConvF(v,out r);static bool INumberBase<T>.TryConvertToChecked<TT>(T v,out TT r)=>Cnv(v.Value,out r);static bool INumberBase<T>.TryConvertToSaturating<TT>(T v,out TT r)=>Cnv(v.Value,out r);static bool INumberBase<T>.TryConvertToTruncating<TT>(T v,out TT r)=>Cnv(v.Value,out r);}public interface IStaticMod{uint Mod{get;}bool IsPrime{get;}}public readonly struct Mod1000000007:IStaticMod{public uint Mod=>1000000007;public bool IsPrime=>true;}public readonly struct Mod998244353:IStaticMod{public uint Mod=>998244353;public bool IsPrime=>true;}}
namespace AtCoder{public readonly struct StaticModInt<T>:IEquatable<StaticModInt<T>>,IFormattable,IModIntNumberBase<StaticModInt<T>>where T:struct,IStaticMod{internal readonly uint _v;private static readonly T op=default;public int Value=>(int)_v;public static int Mod=>(int)op.Mod;public static StaticModInt<T>Zero=>default;public static StaticModInt<T>One=>new(1u);[MethodImpl(256)]public static StaticModInt<T>Raw(int v){var u=unchecked((uint)v);return new(u);}[MethodImpl(256)]public StaticModInt(long v):this((uint)ModCalc.SafeMod(v,op.Mod)){}[MethodImpl(256)]public StaticModInt(ulong v):this((uint)(v%op.Mod)){}[MethodImpl(256)]private StaticModInt(uint v)=>_v=v;[MethodImpl(256)]public static StaticModInt<T>operator ++(StaticModInt<T>v){var x=v._v+1;if(x==op.Mod){x=0;}return new(x);}[MethodImpl(256)]public static StaticModInt<T>operator --(StaticModInt<T>v){var x=v._v;if(x==0){x=op.Mod;}return new(x-1);}[MethodImpl(256)]public static StaticModInt<T>operator+(StaticModInt<T>lhs,StaticModInt<T>rhs){var v=lhs._v+rhs._v;if(v>=op.Mod){v-=op.Mod;}return new(v);}[MethodImpl(256)]public static StaticModInt<T>operator-(StaticModInt<T>lhs,StaticModInt<T>rhs){unchecked{var v=lhs._v-rhs._v;if(v>=op.Mod){v+=op.Mod;}return new(v);}}[MethodImpl(256)]public static StaticModInt<T>operator*(StaticModInt<T>lhs,StaticModInt<T>rhs)=>new((uint)((ulong)lhs._v*rhs._v%op.Mod));[MethodImpl(256)]public static StaticModInt<T>operator/(StaticModInt<T>lhs,StaticModInt<T>rhs)=>lhs*rhs.Inv();[MethodImpl(256)]public static StaticModInt<T>operator+(StaticModInt<T>v)=>v;[MethodImpl(256)]public static StaticModInt<T>operator-(StaticModInt<T>v)=>new(v._v==0?0:op.Mod-v._v);[MethodImpl(256)]public static bool operator==(StaticModInt<T>lhs,StaticModInt<T>rhs)=>lhs._v==rhs._v;[MethodImpl(256)]public static bool operator!=(StaticModInt<T>lhs,StaticModInt<T>rhs)=>lhs._v!=rhs._v;[MethodImpl(256)]public static implicit operator StaticModInt<T>(int v)=>new(v);[MethodImpl(256)]public static implicit operator StaticModInt<T>(uint v)=>new((ulong)v);[MethodImpl(256)]public static implicit operator StaticModInt<T>(long v)=>new(v);[MethodImpl(256)]public static implicit operator StaticModInt<T>(ulong v)=>new(v);[MethodImpl(256)]public StaticModInt<T>Pow(long n){return Pow((ulong)n);}[MethodImpl(256)]public StaticModInt<T>Pow(ulong n){var x=this;StaticModInt<T>r=new(1U);while(n>0){if((n&1)>0){r*=x;}x*=x;n>>=1;}return r;}[MethodImpl(256)]public StaticModInt<T>Inv(){if(op.IsPrime){return Pow(op.Mod-2);}else{var(g,x)=ModCalc.InvGcd(_v,op.Mod);return new(x);}}public override string ToString()=>_v.ToString();public string ToString(string format,IFormatProvider formatProvider)=>_v.ToString(format,formatProvider);public override bool Equals(object obj)=>obj is StaticModInt<T>m&&Equals(m);[MethodImpl(256)]public bool Equals(StaticModInt<T>other)=>_v==other._v;public override int GetHashCode()=>_v.GetHashCode();public static bool TryParse(ReadOnlySpan<char>s,out StaticModInt<T>result){result=Zero;StaticModInt<T>ten=10u;s=s.Trim();bool minus=false;if(s.Length>0&&s[0]=='-'){minus=true;s=s.Slice(1);}for(int i=0;i<s.Length;i++){var d=(uint)(s[i]-'0');if(d>=10)return false;result=result*ten+d;}if(minus)result=-result;return true;}public static StaticModInt<T>Parse(ReadOnlySpan<char>s){if(!TryParse(s,out var r))Throw();return r;void Throw()=>throw new FormatException();}}}
namespace SourceExpander{public class Expander{[Conditional("EXP")]public static void Expand(string inputFilePath=null,string outputFilePath=null,bool ignoreAnyError=true){}public static string ExpandString(string inputFilePath=null,bool ignoreAnyError=true){return "";}}}
#endregion Expanded by https://github.com/kzrnm/SourceExpander