using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Threading;
using System.Text;
using System.Text.RegularExpressions;
using System.Diagnostics;
using static util;
using P = pair<int, int>;

class Program {
    static void Main(string[] args) {
        var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
        var solver = new Solver(sw);
        // var t = new Thread(solver.solve, 1 << 26); // 64 MB
        // t.Start();
        // t.Join();
        solver.solve();
        sw.Flush();
    }
}

class Solver {
    StreamWriter sw;
    Scan sc;
    void Prt(string a) => sw.WriteLine(a);
    void Prt<T>(IEnumerable<T> a) => Prt(string.Join(" ", a));
    void Prt(params object[] a) => Prt(string.Join(" ", a));
    public Solver(StreamWriter sw) {
        this.sw = sw;
        this.sc = new Scan();
    }

    public void solve() {
        int T = sc.Int;
        for (int _ = 0; _ < T; _++)
        {
            long h, c, t;
            sc.Multi(out h, out c, out t);
            t -= c;
            h -= c;
            if (h >= t * 2) {
                Prt(2);
                continue;
            }
            int u = 0, l = M;
            while (u + 1 < l) {
                int m = (u + l) / 2;
                if (m * h == t * (m * 2 - 1)) {
                    Prt(m * 2 - 1);
                    goto A;
                }
                if (m * h > t * (m * 2 - 1)) {
                    u = m;
                }
                else {
                    l = m;
                }
            }
            double min = Math.Abs(h / 2.0 - t);
            int ans = 2;
            for (int i = Math.Max(1, u - 5); i <= u + 5; i++)
            {
                double tt = (i * h) / (double)(i * 2 - 1);
                if (min > Math.Abs(tt - t)) {
                    min = Math.Abs(tt - t);
                    ans = i * 2 - 1;
                }
            }
            Prt(ans);
            A: continue;
        }
    }
}

class pair<T, U> : IComparable<pair<T, U>> {
    public T v1;
    public U v2;
    public pair() : this(default(T), default(U)) {}
    public pair(T v1, U v2) { this.v1 = v1; this.v2 = v2; }
    public int CompareTo(pair<T, U> a) {
        int c = Comparer<T>.Default.Compare(v1, a.v1);
        return c != 0 ? c : Comparer<U>.Default.Compare(v2, a.v2);
    }
    public override string ToString() => v1 + " " + v2;
    public void Deconstruct(out T a, out U b) { a = v1; b = v2; }
}
static class util {
    // public static readonly int M = 1000000007;
    public static readonly int M = 998244353;
    public static readonly long LM = 1L << 60;
    public static readonly double eps = 1e-11;
    public static void DBG(string a) => Console.Error.WriteLine(a);
    public static void DBG<T>(IEnumerable<T> a) => DBG(string.Join(" ", a));
    public static void DBG(params object[] a) => DBG(string.Join(" ", a));
    public static void Assert(params bool[] conds) {
        if (conds.Any(x => !x)) throw new Exception();
    }
    public static pair<T, U> make_pair<T, U>(T v1, U v2) => new pair<T, U>(v1, v2);
    public static int CompareList<T>(IList<T> a, IList<T> b) where T : IComparable<T> {
        for (int i = 0; i < a.Count && i < b.Count; i++)
            if (a[i].CompareTo(b[i]) != 0) return a[i].CompareTo(b[i]);
        return a.Count.CompareTo(b.Count);
    }
    public static bool inside(int i, int j, int h, int w) => i >= 0 && i < h && j >= 0 && j < w;
    static readonly int[] dd = { 0, 1, 0, -1 };
    // static readonly string dstring = "RDLU";
    public static P[] adjacents(int i, int j)
        => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1])).ToArray();
    public static P[] adjacents(int i, int j, int h, int w)
        => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1]))
                                         .Where(p => inside(p.v1, p.v2, h, w)).ToArray();
    public static P[] adjacents(this P p) => adjacents(p.v1, p.v2);
    public static P[] adjacents(this P p, int h, int w) => adjacents(p.v1, p.v2, h, w);
    public static Dictionary<T, int> compress<T>(this IEnumerable<T> a)
        => a.Distinct().OrderBy(v => v).Select((v, i) => new { v, i }).ToDictionary(p => p.v, p => p.i);
    public static Dictionary<T, int> compress<T>(params IEnumerable<T>[] a) => compress(a.Aggregate(Enumerable.Union));
    public static T[] inv<T>(this Dictionary<T, int> dic) {
        var res = new T[dic.Count];
        foreach (var item in dic) res[item.Value] = item.Key;
        return res;
    }
    public static void swap<T>(ref T a, ref T b) where T : struct { var t = a; a = b; b = t; }
    public static void swap<T>(this IList<T> a, int i, int j) where T : struct { var t = a[i]; a[i] = a[j]; a[j] = t; }
    public static T[] copy<T>(this IList<T> a) {
        var ret = new T[a.Count];
        for (int i = 0; i < a.Count; i++) ret[i] = a[i];
        return ret;
    }
    public static void Deconstruct<T>(this IList<T> v, out T a) {
        a = v[0];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b) {
        a = v[0]; b = v[1];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c) {
        a = v[0]; b = v[1]; c = v[2];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c, out T d) {
        a = v[0]; b = v[1]; c = v[2]; d = v[3];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c, out T d, out T e) {
        a = v[0]; b = v[1]; c = v[2]; d = v[3]; e = v[4];
    }
}

class Scan {
    StreamReader sr;
    public Scan() { sr = new StreamReader(Console.OpenStandardInput()); }
    public Scan(string path) { sr = new StreamReader(path); }
    public int Int => int.Parse(Str);
    public long Long => long.Parse(Str);
    public double Double => double.Parse(Str);
    public string Str => sr.ReadLine().Trim();
    public pair<T, U> Pair<T, U>() {
        T a; U b;
        Multi(out a, out b);
        return new pair<T, U>(a, b);
    }
    public P P => Pair<int, int>();
    public int[] IntArr => StrArr.Select(int.Parse).ToArray();
    public long[] LongArr => StrArr.Select(long.Parse).ToArray();
    public double[] DoubleArr => StrArr.Select(double.Parse).ToArray();
    public string[] StrArr => Str.Split(new[]{' '}, StringSplitOptions.RemoveEmptyEntries);
    bool eq<T, U>() => typeof(T).Equals(typeof(U));
    T ct<T, U>(U a) => (T)Convert.ChangeType(a, typeof(T));
    T cv<T>(string s) => eq<T, int>()    ? ct<T, int>(int.Parse(s))
                       : eq<T, long>()   ? ct<T, long>(long.Parse(s))
                       : eq<T, double>() ? ct<T, double>(double.Parse(s))
                       : eq<T, char>()   ? ct<T, char>(s[0])
                                         : ct<T, string>(s);
    public void Multi<T>(out T a) => a = cv<T>(Str);
    public void Multi<T, U>(out T a, out U b) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]);
    }
    public void Multi<T, U, V>(out T a, out U b, out V c) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]);
    }
    public void Multi<T, U, V, W>(out T a, out U b, out V c, out W d) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]);
    }
    public void Multi<T, U, V, W, X>(out T a, out U b, out V c, out W d, out X e) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]); e = cv<X>(ar[4]);
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Threading;
using System.Text;
using System.Text.RegularExpressions;
using System.Diagnostics;
using static util;
using P = pair<int, int>;

class Program {
    static void Main(string[] args) {
        var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
        var solver = new Solver(sw);
        // var t = new Thread(solver.solve, 1 << 26); // 64 MB
        // t.Start();
        // t.Join();
        solver.solve();
        sw.Flush();
    }
}

class Solver {
    StreamWriter sw;
    Scan sc;
    void Prt(string a) => sw.WriteLine(a);
    void Prt<T>(IEnumerable<T> a) => Prt(string.Join(" ", a));
    void Prt(params object[] a) => Prt(string.Join(" ", a));
    public Solver(StreamWriter sw) {
        this.sw = sw;
        this.sc = new Scan();
    }

    public void solve() {
        int T = sc.Int;
        for (int _ = 0; _ < T; _++)
        {
            long h, c, t;
            sc.Multi(out h, out c, out t);
            if (h + c >= t * 2) {
                Prt(2);
                continue;
            }
            double min = Math.Abs((h + c) / 2.0 - t);
            long ans = 2;
            long k = (t - c) / (t * 2 - c - h);
            for (long i = Math.Max(k - 5, 1); i <= k + 5; i++)
            {
                double tt = (h * i + c * (i - 1)) / (double)(i * 2 - 1);
                if (min > Math.Abs(tt - t)) {
                    min = Math.Abs(tt - t);
                    ans = i * 2 - 1;
                }
            }
            Prt(ans);
        }
    }
}

class pair<T, U> : IComparable<pair<T, U>> {
    public T v1;
    public U v2;
    public pair() : this(default(T), default(U)) {}
    public pair(T v1, U v2) { this.v1 = v1; this.v2 = v2; }
    public int CompareTo(pair<T, U> a) {
        int c = Comparer<T>.Default.Compare(v1, a.v1);
        return c != 0 ? c : Comparer<U>.Default.Compare(v2, a.v2);
    }
    public override string ToString() => v1 + " " + v2;
    public void Deconstruct(out T a, out U b) { a = v1; b = v2; }
}
static class util {
    // public static readonly int M = 1000000007;
    public static readonly int M = 998244353;
    public static readonly long LM = 1L << 60;
    public static readonly double eps = 1e-11;
    public static void DBG(string a) => Console.Error.WriteLine(a);
    public static void DBG<T>(IEnumerable<T> a) => DBG(string.Join(" ", a));
    public static void DBG(params object[] a) => DBG(string.Join(" ", a));
    public static void Assert(params bool[] conds) {
        if (conds.Any(x => !x)) throw new Exception();
    }
    public static pair<T, U> make_pair<T, U>(T v1, U v2) => new pair<T, U>(v1, v2);
    public static int CompareList<T>(IList<T> a, IList<T> b) where T : IComparable<T> {
        for (int i = 0; i < a.Count && i < b.Count; i++)
            if (a[i].CompareTo(b[i]) != 0) return a[i].CompareTo(b[i]);
        return a.Count.CompareTo(b.Count);
    }
    public static bool inside(int i, int j, int h, int w) => i >= 0 && i < h && j >= 0 && j < w;
    static readonly int[] dd = { 0, 1, 0, -1 };
    // static readonly string dstring = "RDLU";
    public static P[] adjacents(int i, int j)
        => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1])).ToArray();
    public static P[] adjacents(int i, int j, int h, int w)
        => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1]))
                                         .Where(p => inside(p.v1, p.v2, h, w)).ToArray();
    public static P[] adjacents(this P p) => adjacents(p.v1, p.v2);
    public static P[] adjacents(this P p, int h, int w) => adjacents(p.v1, p.v2, h, w);
    public static Dictionary<T, int> compress<T>(this IEnumerable<T> a)
        => a.Distinct().OrderBy(v => v).Select((v, i) => new { v, i }).ToDictionary(p => p.v, p => p.i);
    public static Dictionary<T, int> compress<T>(params IEnumerable<T>[] a) => compress(a.Aggregate(Enumerable.Union));
    public static T[] inv<T>(this Dictionary<T, int> dic) {
        var res = new T[dic.Count];
        foreach (var item in dic) res[item.Value] = item.Key;
        return res;
    }
    public static void swap<T>(ref T a, ref T b) where T : struct { var t = a; a = b; b = t; }
    public static void swap<T>(this IList<T> a, int i, int j) where T : struct { var t = a[i]; a[i] = a[j]; a[j] = t; }
    public static T[] copy<T>(this IList<T> a) {
        var ret = new T[a.Count];
        for (int i = 0; i < a.Count; i++) ret[i] = a[i];
        return ret;
    }
    public static void Deconstruct<T>(this IList<T> v, out T a) {
        a = v[0];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b) {
        a = v[0]; b = v[1];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c) {
        a = v[0]; b = v[1]; c = v[2];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c, out T d) {
        a = v[0]; b = v[1]; c = v[2]; d = v[3];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c, out T d, out T e) {
        a = v[0]; b = v[1]; c = v[2]; d = v[3]; e = v[4];
    }
}

class Scan {
    StreamReader sr;
    public Scan() { sr = new StreamReader(Console.OpenStandardInput()); }
    public Scan(string path) { sr = new StreamReader(path); }
    public int Int => int.Parse(Str);
    public long Long => long.Parse(Str);
    public double Double => double.Parse(Str);
    public string Str => sr.ReadLine().Trim();
    public pair<T, U> Pair<T, U>() {
        T a; U b;
        Multi(out a, out b);
        return new pair<T, U>(a, b);
    }
    public P P => Pair<int, int>();
    public int[] IntArr => StrArr.Select(int.Parse).ToArray();
    public long[] LongArr => StrArr.Select(long.Parse).ToArray();
    public double[] DoubleArr => StrArr.Select(double.Parse).ToArray();
    public string[] StrArr => Str.Split(new[]{' '}, StringSplitOptions.RemoveEmptyEntries);
    bool eq<T, U>() => typeof(T).Equals(typeof(U));
    T ct<T, U>(U a) => (T)Convert.ChangeType(a, typeof(T));
    T cv<T>(string s) => eq<T, int>()    ? ct<T, int>(int.Parse(s))
                       : eq<T, long>()   ? ct<T, long>(long.Parse(s))
                       : eq<T, double>() ? ct<T, double>(double.Parse(s))
                       : eq<T, char>()   ? ct<T, char>(s[0])
                                         : ct<T, string>(s);
    public void Multi<T>(out T a) => a = cv<T>(Str);
    public void Multi<T, U>(out T a, out U b) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]);
    }
    public void Multi<T, U, V>(out T a, out U b, out V c) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]);
    }
    public void Multi<T, U, V, W>(out T a, out U b, out V c, out W d) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]);
    }
    public void Multi<T, U, V, W, X>(out T a, out U b, out V c, out W d, out X e) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]); e = cv<X>(ar[4]);
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Threading;
using System.Text;
using System.Text.RegularExpressions;
using System.Diagnostics;
using static util;
using P = pair<int, int>;

class Program {
    static void Main(string[] args) {
        var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
        var solver = new Solver(sw);
        // var t = new Thread(solver.solve, 1 << 26); // 64 MB
        // t.Start();
        // t.Join();
        solver.solve();
        sw.Flush();
    }
}

class Solver {
    StreamWriter sw;
    Scan sc;
    void Prt(string a) => sw.WriteLine(a);
    void Prt<T>(IEnumerable<T> a) => Prt(string.Join(" ", a));
    void Prt(params object[] a) => Prt(string.Join(" ", a));
    public Solver(StreamWriter sw) {
        this.sw = sw;
        this.sc = new Scan();
    }

    public void solve() {
        int T = sc.Int;
        for (int _ = 0; _ < T; _++)
        {
            long h, c, t;
            sc.Multi(out h, out c, out t);
            c -= t;
            h -= t;
            if (h + c >= t * 2) {
                Prt(2);
                continue;
            }
            long u = 0, l = M;
            while (u + 1 < l) {
                long m = (u + l) / 2;
                if (m * h + (m - 1) * c == t * (m * 2 - 1)) {
                    Prt(m * 2 - 1);
                    goto A;
                }
                if (m * h + (m - 1) * c > t * (m * 2 - 1)) {
                    u = m;
                }
                else {
                    l = m;
                }
            }
            double min = Math.Abs((h + c) / 2.0 - t);
            long ans = 2;
            for (long i = Math.Max(1, u - 5); i <= u + 5; i++)
            {
                double tt = (i * h + (i - 1) * c) / (double)(i * 2 - 1);
                if (min > Math.Abs(tt - t)) {
                    min = Math.Abs(tt - t);
                    ans = i * 2 - 1;
                }
            }
            Prt(ans);
            A: continue;
        }
    }
}

class pair<T, U> : IComparable<pair<T, U>> {
    public T v1;
    public U v2;
    public pair() : this(default(T), default(U)) {}
    public pair(T v1, U v2) { this.v1 = v1; this.v2 = v2; }
    public int CompareTo(pair<T, U> a) {
        int c = Comparer<T>.Default.Compare(v1, a.v1);
        return c != 0 ? c : Comparer<U>.Default.Compare(v2, a.v2);
    }
    public override string ToString() => v1 + " " + v2;
    public void Deconstruct(out T a, out U b) { a = v1; b = v2; }
}
static class util {
    // public static readonly int M = 1000000007;
    public static readonly int M = 998244353;
    public static readonly long LM = 1L << 60;
    public static readonly double eps = 1e-11;
    public static void DBG(string a) => Console.Error.WriteLine(a);
    public static void DBG<T>(IEnumerable<T> a) => DBG(string.Join(" ", a));
    public static void DBG(params object[] a) => DBG(string.Join(" ", a));
    public static void Assert(params bool[] conds) {
        if (conds.Any(x => !x)) throw new Exception();
    }
    public static pair<T, U> make_pair<T, U>(T v1, U v2) => new pair<T, U>(v1, v2);
    public static int CompareList<T>(IList<T> a, IList<T> b) where T : IComparable<T> {
        for (int i = 0; i < a.Count && i < b.Count; i++)
            if (a[i].CompareTo(b[i]) != 0) return a[i].CompareTo(b[i]);
        return a.Count.CompareTo(b.Count);
    }
    public static bool inside(int i, int j, int h, int w) => i >= 0 && i < h && j >= 0 && j < w;
    static readonly int[] dd = { 0, 1, 0, -1 };
    // static readonly string dstring = "RDLU";
    public static P[] adjacents(int i, int j)
        => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1])).ToArray();
    public static P[] adjacents(int i, int j, int h, int w)
        => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1]))
                                         .Where(p => inside(p.v1, p.v2, h, w)).ToArray();
    public static P[] adjacents(this P p) => adjacents(p.v1, p.v2);
    public static P[] adjacents(this P p, int h, int w) => adjacents(p.v1, p.v2, h, w);
    public static Dictionary<T, int> compress<T>(this IEnumerable<T> a)
        => a.Distinct().OrderBy(v => v).Select((v, i) => new { v, i }).ToDictionary(p => p.v, p => p.i);
    public static Dictionary<T, int> compress<T>(params IEnumerable<T>[] a) => compress(a.Aggregate(Enumerable.Union));
    public static T[] inv<T>(this Dictionary<T, int> dic) {
        var res = new T[dic.Count];
        foreach (var item in dic) res[item.Value] = item.Key;
        return res;
    }
    public static void swap<T>(ref T a, ref T b) where T : struct { var t = a; a = b; b = t; }
    public static void swap<T>(this IList<T> a, int i, int j) where T : struct { var t = a[i]; a[i] = a[j]; a[j] = t; }
    public static T[] copy<T>(this IList<T> a) {
        var ret = new T[a.Count];
        for (int i = 0; i < a.Count; i++) ret[i] = a[i];
        return ret;
    }
    public static void Deconstruct<T>(this IList<T> v, out T a) {
        a = v[0];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b) {
        a = v[0]; b = v[1];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c) {
        a = v[0]; b = v[1]; c = v[2];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c, out T d) {
        a = v[0]; b = v[1]; c = v[2]; d = v[3];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c, out T d, out T e) {
        a = v[0]; b = v[1]; c = v[2]; d = v[3]; e = v[4];
    }
}

class Scan {
    StreamReader sr;
    public Scan() { sr = new StreamReader(Console.OpenStandardInput()); }
    public Scan(string path) { sr = new StreamReader(path); }
    public int Int => int.Parse(Str);
    public long Long => long.Parse(Str);
    public double Double => double.Parse(Str);
    public string Str => sr.ReadLine().Trim();
    public pair<T, U> Pair<T, U>() {
        T a; U b;
        Multi(out a, out b);
        return new pair<T, U>(a, b);
    }
    public P P => Pair<int, int>();
    public int[] IntArr => StrArr.Select(int.Parse).ToArray();
    public long[] LongArr => StrArr.Select(long.Parse).ToArray();
    public double[] DoubleArr => StrArr.Select(double.Parse).ToArray();
    public string[] StrArr => Str.Split(new[]{' '}, StringSplitOptions.RemoveEmptyEntries);
    bool eq<T, U>() => typeof(T).Equals(typeof(U));
    T ct<T, U>(U a) => (T)Convert.ChangeType(a, typeof(T));
    T cv<T>(string s) => eq<T, int>()    ? ct<T, int>(int.Parse(s))
                       : eq<T, long>()   ? ct<T, long>(long.Parse(s))
                       : eq<T, double>() ? ct<T, double>(double.Parse(s))
                       : eq<T, char>()   ? ct<T, char>(s[0])
                                         : ct<T, string>(s);
    public void Multi<T>(out T a) => a = cv<T>(Str);
    public void Multi<T, U>(out T a, out U b) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]);
    }
    public void Multi<T, U, V>(out T a, out U b, out V c) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]);
    }
    public void Multi<T, U, V, W>(out T a, out U b, out V c, out W d) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]);
    }
    public void Multi<T, U, V, W, X>(out T a, out U b, out V c, out W d, out X e) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]); e = cv<X>(ar[4]);
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Threading;
using System.Text;
using System.Text.RegularExpressions;
using System.Diagnostics;
using static util;
using P = pair<int, int>;

class Program {
    static void Main(string[] args) {
        var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
        var solver = new Solver(sw);
        // var t = new Thread(solver.solve, 1 << 26); // 64 MB
        // t.Start();
        // t.Join();
        solver.solve();
        sw.Flush();
    }
}

class Solver {
    StreamWriter sw;
    Scan sc;
    void Prt(string a) => sw.WriteLine(a);
    void Prt<T>(IEnumerable<T> a) => Prt(string.Join(" ", a));
    void Prt(params object[] a) => Prt(string.Join(" ", a));
    public Solver(StreamWriter sw) {
        this.sw = sw;
        this.sc = new Scan();
    }

    public void solve() {
        int T = sc.Int;
        for (int _ = 0; _ < T; _++)
        {
            long h, c, t;
            sc.Multi(out h, out c, out t);
            if (h + c >= t * 2) {
                Prt(2);
                continue;
            }
            int u = 0, l = M;
            while (u + 1 < l) {
                int m = (u + l) / 2;
                if (m * h + (m - 1) * c == t * (m * 2 - 1)) {
                    Prt(m * 2 - 1);
                    goto A;
                }
                if (m * h + (m - 1) * c > t * (m * 2 - 1)) {
                    u = m;
                }
                else {
                    l = m;
                }
            }
            double min = Math.Abs((h + c) / 2.0 - t);
            int ans = 2;
            for (int i = Math.Max(1, u - 5); i <= u + 5; i++)
            {
                double tt = (i * h + (i - 1) * c) / (double)(i * 2 - 1);
                if (min > Math.Abs(tt - t)) {
                    min = Math.Abs(tt - t);
                    ans = i * 2 - 1;
                }
            }
            Prt(ans);
            A: continue;
        }
    }
}

class pair<T, U> : IComparable<pair<T, U>> {
    public T v1;
    public U v2;
    public pair() : this(default(T), default(U)) {}
    public pair(T v1, U v2) { this.v1 = v1; this.v2 = v2; }
    public int CompareTo(pair<T, U> a) {
        int c = Comparer<T>.Default.Compare(v1, a.v1);
        return c != 0 ? c : Comparer<U>.Default.Compare(v2, a.v2);
    }
    public override string ToString() => v1 + " " + v2;
    public void Deconstruct(out T a, out U b) { a = v1; b = v2; }
}
static class util {
    // public static readonly int M = 1000000007;
    public static readonly int M = 998244353;
    public static readonly long LM = 1L << 60;
    public static readonly double eps = 1e-11;
    public static void DBG(string a) => Console.Error.WriteLine(a);
    public static void DBG<T>(IEnumerable<T> a) => DBG(string.Join(" ", a));
    public static void DBG(params object[] a) => DBG(string.Join(" ", a));
    public static void Assert(params bool[] conds) {
        if (conds.Any(x => !x)) throw new Exception();
    }
    public static pair<T, U> make_pair<T, U>(T v1, U v2) => new pair<T, U>(v1, v2);
    public static int CompareList<T>(IList<T> a, IList<T> b) where T : IComparable<T> {
        for (int i = 0; i < a.Count && i < b.Count; i++)
            if (a[i].CompareTo(b[i]) != 0) return a[i].CompareTo(b[i]);
        return a.Count.CompareTo(b.Count);
    }
    public static bool inside(int i, int j, int h, int w) => i >= 0 && i < h && j >= 0 && j < w;
    static readonly int[] dd = { 0, 1, 0, -1 };
    // static readonly string dstring = "RDLU";
    public static P[] adjacents(int i, int j)
        => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1])).ToArray();
    public static P[] adjacents(int i, int j, int h, int w)
        => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1]))
                                         .Where(p => inside(p.v1, p.v2, h, w)).ToArray();
    public static P[] adjacents(this P p) => adjacents(p.v1, p.v2);
    public static P[] adjacents(this P p, int h, int w) => adjacents(p.v1, p.v2, h, w);
    public static Dictionary<T, int> compress<T>(this IEnumerable<T> a)
        => a.Distinct().OrderBy(v => v).Select((v, i) => new { v, i }).ToDictionary(p => p.v, p => p.i);
    public static Dictionary<T, int> compress<T>(params IEnumerable<T>[] a) => compress(a.Aggregate(Enumerable.Union));
    public static T[] inv<T>(this Dictionary<T, int> dic) {
        var res = new T[dic.Count];
        foreach (var item in dic) res[item.Value] = item.Key;
        return res;
    }
    public static void swap<T>(ref T a, ref T b) where T : struct { var t = a; a = b; b = t; }
    public static void swap<T>(this IList<T> a, int i, int j) where T : struct { var t = a[i]; a[i] = a[j]; a[j] = t; }
    public static T[] copy<T>(this IList<T> a) {
        var ret = new T[a.Count];
        for (int i = 0; i < a.Count; i++) ret[i] = a[i];
        return ret;
    }
    public static void Deconstruct<T>(this IList<T> v, out T a) {
        a = v[0];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b) {
        a = v[0]; b = v[1];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c) {
        a = v[0]; b = v[1]; c = v[2];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c, out T d) {
        a = v[0]; b = v[1]; c = v[2]; d = v[3];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c, out T d, out T e) {
        a = v[0]; b = v[1]; c = v[2]; d = v[3]; e = v[4];
    }
}

class Scan {
    StreamReader sr;
    public Scan() { sr = new StreamReader(Console.OpenStandardInput()); }
    public Scan(string path) { sr = new StreamReader(path); }
    public int Int => int.Parse(Str);
    public long Long => long.Parse(Str);
    public double Double => double.Parse(Str);
    public string Str => sr.ReadLine().Trim();
    public pair<T, U> Pair<T, U>() {
        T a; U b;
        Multi(out a, out b);
        return new pair<T, U>(a, b);
    }
    public P P => Pair<int, int>();
    public int[] IntArr => StrArr.Select(int.Parse).ToArray();
    public long[] LongArr => StrArr.Select(long.Parse).ToArray();
    public double[] DoubleArr => StrArr.Select(double.Parse).ToArray();
    public string[] StrArr => Str.Split(new[]{' '}, StringSplitOptions.RemoveEmptyEntries);
    bool eq<T, U>() => typeof(T).Equals(typeof(U));
    T ct<T, U>(U a) => (T)Convert.ChangeType(a, typeof(T));
    T cv<T>(string s) => eq<T, int>()    ? ct<T, int>(int.Parse(s))
                       : eq<T, long>()   ? ct<T, long>(long.Parse(s))
                       : eq<T, double>() ? ct<T, double>(double.Parse(s))
                       : eq<T, char>()   ? ct<T, char>(s[0])
                                         : ct<T, string>(s);
    public void Multi<T>(out T a) => a = cv<T>(Str);
    public void Multi<T, U>(out T a, out U b) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]);
    }
    public void Multi<T, U, V>(out T a, out U b, out V c) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]);
    }
    public void Multi<T, U, V, W>(out T a, out U b, out V c, out W d) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]);
    }
    public void Multi<T, U, V, W, X>(out T a, out U b, out V c, out W d, out X e) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]); e = cv<X>(ar[4]);
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Threading;
using System.Text;
using System.Text.RegularExpressions;
using System.Diagnostics;
using static util;
using P = pair<int, int>;

class Program {
    static void Main(string[] args) {
        var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
        var solver = new Solver(sw);
        // var t = new Thread(solver.solve, 1 << 26); // 64 MB
        // t.Start();
        // t.Join();
        solver.solve();
        sw.Flush();
    }
}

class Solver {
    StreamWriter sw;
    Scan sc;
    void Prt(string a) => sw.WriteLine(a);
    void Prt<T>(IEnumerable<T> a) => Prt(string.Join(" ", a));
    void Prt(params object[] a) => Prt(string.Join(" ", a));
    public Solver(StreamWriter sw) {
        this.sw = sw;
        this.sc = new Scan();
    }

    public void solve() {
        int T = sc.Int;
        for (int _ = 0; _ < T; _++)
        {
            long h, c, t;
            sc.Multi(out h, out c, out t);
            if (h + c >= t * 2) {
                Prt(2);
                continue;
            }
            double min = Math.Abs((h + c) / 2.0 - t);
            long ans = 2;
            long k = (t - c) / (t * 2 - c - h);
            for (long i = Math.Max(k - 5, 1); i <= k + 5; i++)
            {
                double tt = (h * i + c * (i - 1)) / (double)(i * 2 - 1);
                if (min > Math.Abs(tt - t) + eps) {
                    min = Math.Abs(tt - t);
                    ans = i * 2 - 1;
                }
            }
            Prt(ans);
        }
    }
}

class pair<T, U> : IComparable<pair<T, U>> {
    public T v1;
    public U v2;
    public pair() : this(default(T), default(U)) {}
    public pair(T v1, U v2) { this.v1 = v1; this.v2 = v2; }
    public int CompareTo(pair<T, U> a) {
        int c = Comparer<T>.Default.Compare(v1, a.v1);
        return c != 0 ? c : Comparer<U>.Default.Compare(v2, a.v2);
    }
    public override string ToString() => v1 + " " + v2;
    public void Deconstruct(out T a, out U b) { a = v1; b = v2; }
}
static class util {
    // public static readonly int M = 1000000007;
    public static readonly int M = 998244353;
    public static readonly long LM = 1L << 60;
    public static readonly double eps = 1e-11;
    public static void DBG(string a) => Console.Error.WriteLine(a);
    public static void DBG<T>(IEnumerable<T> a) => DBG(string.Join(" ", a));
    public static void DBG(params object[] a) => DBG(string.Join(" ", a));
    public static void Assert(params bool[] conds) {
        if (conds.Any(x => !x)) throw new Exception();
    }
    public static pair<T, U> make_pair<T, U>(T v1, U v2) => new pair<T, U>(v1, v2);
    public static int CompareList<T>(IList<T> a, IList<T> b) where T : IComparable<T> {
        for (int i = 0; i < a.Count && i < b.Count; i++)
            if (a[i].CompareTo(b[i]) != 0) return a[i].CompareTo(b[i]);
        return a.Count.CompareTo(b.Count);
    }
    public static bool inside(int i, int j, int h, int w) => i >= 0 && i < h && j >= 0 && j < w;
    static readonly int[] dd = { 0, 1, 0, -1 };
    // static readonly string dstring = "RDLU";
    public static P[] adjacents(int i, int j)
        => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1])).ToArray();
    public static P[] adjacents(int i, int j, int h, int w)
        => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1]))
                                         .Where(p => inside(p.v1, p.v2, h, w)).ToArray();
    public static P[] adjacents(this P p) => adjacents(p.v1, p.v2);
    public static P[] adjacents(this P p, int h, int w) => adjacents(p.v1, p.v2, h, w);
    public static Dictionary<T, int> compress<T>(this IEnumerable<T> a)
        => a.Distinct().OrderBy(v => v).Select((v, i) => new { v, i }).ToDictionary(p => p.v, p => p.i);
    public static Dictionary<T, int> compress<T>(params IEnumerable<T>[] a) => compress(a.Aggregate(Enumerable.Union));
    public static T[] inv<T>(this Dictionary<T, int> dic) {
        var res = new T[dic.Count];
        foreach (var item in dic) res[item.Value] = item.Key;
        return res;
    }
    public static void swap<T>(ref T a, ref T b) where T : struct { var t = a; a = b; b = t; }
    public static void swap<T>(this IList<T> a, int i, int j) where T : struct { var t = a[i]; a[i] = a[j]; a[j] = t; }
    public static T[] copy<T>(this IList<T> a) {
        var ret = new T[a.Count];
        for (int i = 0; i < a.Count; i++) ret[i] = a[i];
        return ret;
    }
    public static void Deconstruct<T>(this IList<T> v, out T a) {
        a = v[0];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b) {
        a = v[0]; b = v[1];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c) {
        a = v[0]; b = v[1]; c = v[2];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c, out T d) {
        a = v[0]; b = v[1]; c = v[2]; d = v[3];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c, out T d, out T e) {
        a = v[0]; b = v[1]; c = v[2]; d = v[3]; e = v[4];
    }
}

class Scan {
    StreamReader sr;
    public Scan() { sr = new StreamReader(Console.OpenStandardInput()); }
    public Scan(string path) { sr = new StreamReader(path); }
    public int Int => int.Parse(Str);
    public long Long => long.Parse(Str);
    public double Double => double.Parse(Str);
    public string Str => sr.ReadLine().Trim();
    public pair<T, U> Pair<T, U>() {
        T a; U b;
        Multi(out a, out b);
        return new pair<T, U>(a, b);
    }
    public P P => Pair<int, int>();
    public int[] IntArr => StrArr.Select(int.Parse).ToArray();
    public long[] LongArr => StrArr.Select(long.Parse).ToArray();
    public double[] DoubleArr => StrArr.Select(double.Parse).ToArray();
    public string[] StrArr => Str.Split(new[]{' '}, StringSplitOptions.RemoveEmptyEntries);
    bool eq<T, U>() => typeof(T).Equals(typeof(U));
    T ct<T, U>(U a) => (T)Convert.ChangeType(a, typeof(T));
    T cv<T>(string s) => eq<T, int>()    ? ct<T, int>(int.Parse(s))
                       : eq<T, long>()   ? ct<T, long>(long.Parse(s))
                       : eq<T, double>() ? ct<T, double>(double.Parse(s))
                       : eq<T, char>()   ? ct<T, char>(s[0])
                                         : ct<T, string>(s);
    public void Multi<T>(out T a) => a = cv<T>(Str);
    public void Multi<T, U>(out T a, out U b) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]);
    }
    public void Multi<T, U, V>(out T a, out U b, out V c) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]);
    }
    public void Multi<T, U, V, W>(out T a, out U b, out V c, out W d) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]);
    }
    public void Multi<T, U, V, W, X>(out T a, out U b, out V c, out W d, out X e) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]); e = cv<X>(ar[4]);
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Threading;
using System.Text;
using System.Text.RegularExpressions;
using System.Diagnostics;
using static util;
using P = pair<int, int>;

class Program {
    static void Main(string[] args) {
        var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
        var solver = new Solver(sw);
        // var t = new Thread(solver.solve, 1 << 26); // 64 MB
        // t.Start();
        // t.Join();
        solver.solve();
        sw.Flush();
    }
}

class Solver {
    StreamWriter sw;
    Scan sc;
    void Prt(string a) => sw.WriteLine(a);
    void Prt<T>(IEnumerable<T> a) => Prt(string.Join(" ", a));
    void Prt(params object[] a) => Prt(string.Join(" ", a));
    public Solver(StreamWriter sw) {
        this.sw = sw;
        this.sc = new Scan();
    }

    public void solve() {
        int T = sc.Int;
        for (int _ = 0; _ < T; _++)
        {
            long h, c, t;
            sc.Multi(out h, out c, out t);
            t -= c;
            h -= c;
            if (h >= t * 2) {
                Prt(2);
                continue;
            }
            int u = 0, l = M;
            while (u + 1 < l) {
                int m = (u + l) / 2;
                if (m * h == t * (m * 2 - 1)) {
                    Prt(m * 2 - 1);
                    goto A;
                }
                if (m * h > t * (m * 2 - 1)) {
                    u = m;
                }
                else {
                    l = m;
                }
            }
            double min = Math.Abs(h / 2.0 - t);
            int ans = 2;
            for (int i = Math.Max(1, u - 5); i <= u + 5; i++)
            {
                double tt = (i * h) / (double)(i * 2 - 1);
                if (min > Math.Abs(tt - t) + 1e-9) {
                    min = Math.Abs(tt - t);
                    ans = i * 2 - 1;
                }
            }
            Prt(ans);
            A: continue;
        }
    }
}

class pair<T, U> : IComparable<pair<T, U>> {
    public T v1;
    public U v2;
    public pair() : this(default(T), default(U)) {}
    public pair(T v1, U v2) { this.v1 = v1; this.v2 = v2; }
    public int CompareTo(pair<T, U> a) {
        int c = Comparer<T>.Default.Compare(v1, a.v1);
        return c != 0 ? c : Comparer<U>.Default.Compare(v2, a.v2);
    }
    public override string ToString() => v1 + " " + v2;
    public void Deconstruct(out T a, out U b) { a = v1; b = v2; }
}
static class util {
    // public static readonly int M = 1000000007;
    public static readonly int M = 998244353;
    public static readonly long LM = 1L << 60;
    public static readonly double eps = 1e-11;
    public static void DBG(string a) => Console.Error.WriteLine(a);
    public static void DBG<T>(IEnumerable<T> a) => DBG(string.Join(" ", a));
    public static void DBG(params object[] a) => DBG(string.Join(" ", a));
    public static void Assert(params bool[] conds) {
        if (conds.Any(x => !x)) throw new Exception();
    }
    public static pair<T, U> make_pair<T, U>(T v1, U v2) => new pair<T, U>(v1, v2);
    public static int CompareList<T>(IList<T> a, IList<T> b) where T : IComparable<T> {
        for (int i = 0; i < a.Count && i < b.Count; i++)
            if (a[i].CompareTo(b[i]) != 0) return a[i].CompareTo(b[i]);
        return a.Count.CompareTo(b.Count);
    }
    public static bool inside(int i, int j, int h, int w) => i >= 0 && i < h && j >= 0 && j < w;
    static readonly int[] dd = { 0, 1, 0, -1 };
    // static readonly string dstring = "RDLU";
    public static P[] adjacents(int i, int j)
        => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1])).ToArray();
    public static P[] adjacents(int i, int j, int h, int w)
        => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1]))
                                         .Where(p => inside(p.v1, p.v2, h, w)).ToArray();
    public static P[] adjacents(this P p) => adjacents(p.v1, p.v2);
    public static P[] adjacents(this P p, int h, int w) => adjacents(p.v1, p.v2, h, w);
    public static Dictionary<T, int> compress<T>(this IEnumerable<T> a)
        => a.Distinct().OrderBy(v => v).Select((v, i) => new { v, i }).ToDictionary(p => p.v, p => p.i);
    public static Dictionary<T, int> compress<T>(params IEnumerable<T>[] a) => compress(a.Aggregate(Enumerable.Union));
    public static T[] inv<T>(this Dictionary<T, int> dic) {
        var res = new T[dic.Count];
        foreach (var item in dic) res[item.Value] = item.Key;
        return res;
    }
    public static void swap<T>(ref T a, ref T b) where T : struct { var t = a; a = b; b = t; }
    public static void swap<T>(this IList<T> a, int i, int j) where T : struct { var t = a[i]; a[i] = a[j]; a[j] = t; }
    public static T[] copy<T>(this IList<T> a) {
        var ret = new T[a.Count];
        for (int i = 0; i < a.Count; i++) ret[i] = a[i];
        return ret;
    }
    public static void Deconstruct<T>(this IList<T> v, out T a) {
        a = v[0];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b) {
        a = v[0]; b = v[1];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c) {
        a = v[0]; b = v[1]; c = v[2];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c, out T d) {
        a = v[0]; b = v[1]; c = v[2]; d = v[3];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c, out T d, out T e) {
        a = v[0]; b = v[1]; c = v[2]; d = v[3]; e = v[4];
    }
}

class Scan {
    StreamReader sr;
    public Scan() { sr = new StreamReader(Console.OpenStandardInput()); }
    public Scan(string path) { sr = new StreamReader(path); }
    public int Int => int.Parse(Str);
    public long Long => long.Parse(Str);
    public double Double => double.Parse(Str);
    public string Str => sr.ReadLine().Trim();
    public pair<T, U> Pair<T, U>() {
        T a; U b;
        Multi(out a, out b);
        return new pair<T, U>(a, b);
    }
    public P P => Pair<int, int>();
    public int[] IntArr => StrArr.Select(int.Parse).ToArray();
    public long[] LongArr => StrArr.Select(long.Parse).ToArray();
    public double[] DoubleArr => StrArr.Select(double.Parse).ToArray();
    public string[] StrArr => Str.Split(new[]{' '}, StringSplitOptions.RemoveEmptyEntries);
    bool eq<T, U>() => typeof(T).Equals(typeof(U));
    T ct<T, U>(U a) => (T)Convert.ChangeType(a, typeof(T));
    T cv<T>(string s) => eq<T, int>()    ? ct<T, int>(int.Parse(s))
                       : eq<T, long>()   ? ct<T, long>(long.Parse(s))
                       : eq<T, double>() ? ct<T, double>(double.Parse(s))
                       : eq<T, char>()   ? ct<T, char>(s[0])
                                         : ct<T, string>(s);
    public void Multi<T>(out T a) => a = cv<T>(Str);
    public void Multi<T, U>(out T a, out U b) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]);
    }
    public void Multi<T, U, V>(out T a, out U b, out V c) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]);
    }
    public void Multi<T, U, V, W>(out T a, out U b, out V c, out W d) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]);
    }
    public void Multi<T, U, V, W, X>(out T a, out U b, out V c, out W d, out X e) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]); e = cv<X>(ar[4]);
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Threading;
using System.Text;
using System.Text.RegularExpressions;
using System.Diagnostics;
using static util;
using P = pair<int, int>;

class Program {
    static void Main(string[] args) {
        var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
        var solver = new Solver(sw);
        // var t = new Thread(solver.solve, 1 << 26); // 64 MB
        // t.Start();
        // t.Join();
        solver.solve();
        sw.Flush();
    }
}

class Solver {
    StreamWriter sw;
    Scan sc;
    void Prt(string a) => sw.WriteLine(a);
    void Prt<T>(IEnumerable<T> a) => Prt(string.Join(" ", a));
    void Prt(params object[] a) => Prt(string.Join(" ", a));
    public Solver(StreamWriter sw) {
        this.sw = sw;
        this.sc = new Scan();
    }

    public void solve() {
        int T = sc.Int;
        for (int _ = 0; _ < T; _++)
        {
            long h, c, t;
            sc.Multi(out h, out c, out t);
            t -= c;
            h -= c;
            if (h >= t * 2) {
                Prt(2);
                continue;
            }
            long u = 0, l = M;
            while (u + 1 < l) {
                long m = (u + l) / 2;
                if (m * h == t * (m * 2 - 1)) {
                    Prt(m * 2 - 1);
                    goto A;
                }
                if (m * h > t * (m * 2 - 1)) {
                    u = m;
                }
                else {
                    l = m;
                }
            }
            double min = Math.Abs(h / 2.0 - t);
            long ans = 2;
            for (long i = Math.Max(1, u - 5); i <= u + 5; i++)
            {
                double tt = (i * h) / (double)(i * 2 - 1);
                if (min > Math.Abs(tt - t) + 1e-9) {
                    min = Math.Abs(tt - t);
                    ans = i * 2 - 1;
                }
            }
            Prt(ans);
            A: continue;
        }
    }
}

class pair<T, U> : IComparable<pair<T, U>> {
    public T v1;
    public U v2;
    public pair() : this(default(T), default(U)) {}
    public pair(T v1, U v2) { this.v1 = v1; this.v2 = v2; }
    public int CompareTo(pair<T, U> a) {
        int c = Comparer<T>.Default.Compare(v1, a.v1);
        return c != 0 ? c : Comparer<U>.Default.Compare(v2, a.v2);
    }
    public override string ToString() => v1 + " " + v2;
    public void Deconstruct(out T a, out U b) { a = v1; b = v2; }
}
static class util {
    public static readonly int M = 1000000007;
    // public static readonly int M = 998244353;
    public static readonly long LM = 1L << 60;
    public static readonly double eps = 1e-11;
    public static void DBG(string a) => Console.Error.WriteLine(a);
    public static void DBG<T>(IEnumerable<T> a) => DBG(string.Join(" ", a));
    public static void DBG(params object[] a) => DBG(string.Join(" ", a));
    public static void Assert(params bool[] conds) {
        if (conds.Any(x => !x)) throw new Exception();
    }
    public static pair<T, U> make_pair<T, U>(T v1, U v2) => new pair<T, U>(v1, v2);
    public static int CompareList<T>(IList<T> a, IList<T> b) where T : IComparable<T> {
        for (int i = 0; i < a.Count && i < b.Count; i++)
            if (a[i].CompareTo(b[i]) != 0) return a[i].CompareTo(b[i]);
        return a.Count.CompareTo(b.Count);
    }
    public static bool inside(int i, int j, int h, int w) => i >= 0 && i < h && j >= 0 && j < w;
    static readonly int[] dd = { 0, 1, 0, -1 };
    // static readonly string dstring = "RDLU";
    public static P[] adjacents(int i, int j)
        => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1])).ToArray();
    public static P[] adjacents(int i, int j, int h, int w)
        => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1]))
                                         .Where(p => inside(p.v1, p.v2, h, w)).ToArray();
    public static P[] adjacents(this P p) => adjacents(p.v1, p.v2);
    public static P[] adjacents(this P p, int h, int w) => adjacents(p.v1, p.v2, h, w);
    public static Dictionary<T, int> compress<T>(this IEnumerable<T> a)
        => a.Distinct().OrderBy(v => v).Select((v, i) => new { v, i }).ToDictionary(p => p.v, p => p.i);
    public static Dictionary<T, int> compress<T>(params IEnumerable<T>[] a) => compress(a.Aggregate(Enumerable.Union));
    public static T[] inv<T>(this Dictionary<T, int> dic) {
        var res = new T[dic.Count];
        foreach (var item in dic) res[item.Value] = item.Key;
        return res;
    }
    public static void swap<T>(ref T a, ref T b) where T : struct { var t = a; a = b; b = t; }
    public static void swap<T>(this IList<T> a, int i, int j) where T : struct { var t = a[i]; a[i] = a[j]; a[j] = t; }
    public static T[] copy<T>(this IList<T> a) {
        var ret = new T[a.Count];
        for (int i = 0; i < a.Count; i++) ret[i] = a[i];
        return ret;
    }
    public static void Deconstruct<T>(this IList<T> v, out T a) {
        a = v[0];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b) {
        a = v[0]; b = v[1];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c) {
        a = v[0]; b = v[1]; c = v[2];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c, out T d) {
        a = v[0]; b = v[1]; c = v[2]; d = v[3];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c, out T d, out T e) {
        a = v[0]; b = v[1]; c = v[2]; d = v[3]; e = v[4];
    }
}

class Scan {
    StreamReader sr;
    public Scan() { sr = new StreamReader(Console.OpenStandardInput()); }
    public Scan(string path) { sr = new StreamReader(path); }
    public int Int => int.Parse(Str);
    public long Long => long.Parse(Str);
    public double Double => double.Parse(Str);
    public string Str => sr.ReadLine().Trim();
    public pair<T, U> Pair<T, U>() {
        T a; U b;
        Multi(out a, out b);
        return new pair<T, U>(a, b);
    }
    public P P => Pair<int, int>();
    public int[] IntArr => StrArr.Select(int.Parse).ToArray();
    public long[] LongArr => StrArr.Select(long.Parse).ToArray();
    public double[] DoubleArr => StrArr.Select(double.Parse).ToArray();
    public string[] StrArr => Str.Split(new[]{' '}, StringSplitOptions.RemoveEmptyEntries);
    bool eq<T, U>() => typeof(T).Equals(typeof(U));
    T ct<T, U>(U a) => (T)Convert.ChangeType(a, typeof(T));
    T cv<T>(string s) => eq<T, int>()    ? ct<T, int>(int.Parse(s))
                       : eq<T, long>()   ? ct<T, long>(long.Parse(s))
                       : eq<T, double>() ? ct<T, double>(double.Parse(s))
                       : eq<T, char>()   ? ct<T, char>(s[0])
                                         : ct<T, string>(s);
    public void Multi<T>(out T a) => a = cv<T>(Str);
    public void Multi<T, U>(out T a, out U b) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]);
    }
    public void Multi<T, U, V>(out T a, out U b, out V c) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]);
    }
    public void Multi<T, U, V, W>(out T a, out U b, out V c, out W d) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]);
    }
    public void Multi<T, U, V, W, X>(out T a, out U b, out V c, out W d, out X e) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]); e = cv<X>(ar[4]);
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Threading;
using System.Text;
using System.Text.RegularExpressions;
using System.Diagnostics;
using static util;
using P = pair<int, int>;

class Program {
    static void Main(string[] args) {
        var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
        var solver = new Solver(sw);
        // var t = new Thread(solver.solve, 1 << 26); // 64 MB
        // t.Start();
        // t.Join();
        solver.solve();
        sw.Flush();
    }
}

class Solver {
    StreamWriter sw;
    Scan sc;
    void Prt(string a) => sw.WriteLine(a);
    void Prt<T>(IEnumerable<T> a) => Prt(string.Join(" ", a));
    void Prt(params object[] a) => Prt(string.Join(" ", a));
    public Solver(StreamWriter sw) {
        this.sw = sw;
        this.sc = new Scan();
    }

    public void solve() {
        int T = sc.Int;
        for (int _ = 0; _ < T; _++)
        {
            long h, c, t;
            sc.Multi(out h, out c, out t);
            t -= c;
            h -= c;
            if (h >= t * 2) {
                Prt(2);
                continue;
            }
            long u = 0, l = M;
            while (u + 1 < l) {
                long m = (u + l) / 2;
                if (m * h == t * (m * 2 - 1)) {
                    Prt(m * 2 - 1);
                    goto A;
                }
                if (m * h > t * (m * 2 - 1)) {
                    u = m;
                }
                else {
                    l = m;
                }
            }
            double min = Math.Abs(h / 2.0 - t);
            long ans = 2;
            for (long i = Math.Max(1, u - 100); i <= u + 100; i++)
            {
                double tt = (i * h) / (double)(i * 2 - 1);
                if (min > Math.Abs(tt - t) + 1e-9) {
                    min = Math.Abs(tt - t);
                    ans = i * 2 - 1;
                }
            }
            Prt(ans);
            A: continue;
        }
    }
}

class pair<T, U> : IComparable<pair<T, U>> {
    public T v1;
    public U v2;
    public pair() : this(default(T), default(U)) {}
    public pair(T v1, U v2) { this.v1 = v1; this.v2 = v2; }
    public int CompareTo(pair<T, U> a) {
        int c = Comparer<T>.Default.Compare(v1, a.v1);
        return c != 0 ? c : Comparer<U>.Default.Compare(v2, a.v2);
    }
    public override string ToString() => v1 + " " + v2;
    public void Deconstruct(out T a, out U b) { a = v1; b = v2; }
}
static class util {
    public static readonly int M = 1000000007;
    // public static readonly int M = 998244353;
    public static readonly long LM = 1L << 60;
    public static readonly double eps = 1e-11;
    public static void DBG(string a) => Console.Error.WriteLine(a);
    public static void DBG<T>(IEnumerable<T> a) => DBG(string.Join(" ", a));
    public static void DBG(params object[] a) => DBG(string.Join(" ", a));
    public static void Assert(params bool[] conds) {
        if (conds.Any(x => !x)) throw new Exception();
    }
    public static pair<T, U> make_pair<T, U>(T v1, U v2) => new pair<T, U>(v1, v2);
    public static int CompareList<T>(IList<T> a, IList<T> b) where T : IComparable<T> {
        for (int i = 0; i < a.Count && i < b.Count; i++)
            if (a[i].CompareTo(b[i]) != 0) return a[i].CompareTo(b[i]);
        return a.Count.CompareTo(b.Count);
    }
    public static bool inside(int i, int j, int h, int w) => i >= 0 && i < h && j >= 0 && j < w;
    static readonly int[] dd = { 0, 1, 0, -1 };
    // static readonly string dstring = "RDLU";
    public static P[] adjacents(int i, int j)
        => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1])).ToArray();
    public static P[] adjacents(int i, int j, int h, int w)
        => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1]))
                                         .Where(p => inside(p.v1, p.v2, h, w)).ToArray();
    public static P[] adjacents(this P p) => adjacents(p.v1, p.v2);
    public static P[] adjacents(this P p, int h, int w) => adjacents(p.v1, p.v2, h, w);
    public static Dictionary<T, int> compress<T>(this IEnumerable<T> a)
        => a.Distinct().OrderBy(v => v).Select((v, i) => new { v, i }).ToDictionary(p => p.v, p => p.i);
    public static Dictionary<T, int> compress<T>(params IEnumerable<T>[] a) => compress(a.Aggregate(Enumerable.Union));
    public static T[] inv<T>(this Dictionary<T, int> dic) {
        var res = new T[dic.Count];
        foreach (var item in dic) res[item.Value] = item.Key;
        return res;
    }
    public static void swap<T>(ref T a, ref T b) where T : struct { var t = a; a = b; b = t; }
    public static void swap<T>(this IList<T> a, int i, int j) where T : struct { var t = a[i]; a[i] = a[j]; a[j] = t; }
    public static T[] copy<T>(this IList<T> a) {
        var ret = new T[a.Count];
        for (int i = 0; i < a.Count; i++) ret[i] = a[i];
        return ret;
    }
    public static void Deconstruct<T>(this IList<T> v, out T a) {
        a = v[0];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b) {
        a = v[0]; b = v[1];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c) {
        a = v[0]; b = v[1]; c = v[2];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c, out T d) {
        a = v[0]; b = v[1]; c = v[2]; d = v[3];
    }
    public static void Deconstruct<T>(this IList<T> v, out T a, out T b, out T c, out T d, out T e) {
        a = v[0]; b = v[1]; c = v[2]; d = v[3]; e = v[4];
    }
}

class Scan {
    StreamReader sr;
    public Scan() { sr = new StreamReader(Console.OpenStandardInput()); }
    public Scan(string path) { sr = new StreamReader(path); }
    public int Int => int.Parse(Str);
    public long Long => long.Parse(Str);
    public double Double => double.Parse(Str);
    public string Str => sr.ReadLine().Trim();
    public pair<T, U> Pair<T, U>() {
        T a; U b;
        Multi(out a, out b);
        return new pair<T, U>(a, b);
    }
    public P P => Pair<int, int>();
    public int[] IntArr => StrArr.Select(int.Parse).ToArray();
    public long[] LongArr => StrArr.Select(long.Parse).ToArray();
    public double[] DoubleArr => StrArr.Select(double.Parse).ToArray();
    public string[] StrArr => Str.Split(new[]{' '}, StringSplitOptions.RemoveEmptyEntries);
    bool eq<T, U>() => typeof(T).Equals(typeof(U));
    T ct<T, U>(U a) => (T)Convert.ChangeType(a, typeof(T));
    T cv<T>(string s) => eq<T, int>()    ? ct<T, int>(int.Parse(s))
                       : eq<T, long>()   ? ct<T, long>(long.Parse(s))
                       : eq<T, double>() ? ct<T, double>(double.Parse(s))
                       : eq<T, char>()   ? ct<T, char>(s[0])
                                         : ct<T, string>(s);
    public void Multi<T>(out T a) => a = cv<T>(Str);
    public void Multi<T, U>(out T a, out U b) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]);
    }
    public void Multi<T, U, V>(out T a, out U b, out V c) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]);
    }
    public void Multi<T, U, V, W>(out T a, out U b, out V c, out W d) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]);
    }
    public void Multi<T, U, V, W, X>(out T a, out U b, out V c, out W d, out X e) {
        var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]); e = cv<X>(ar[4]);
    }
}


using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Text;
using System.Linq;

using E = System.Linq.Enumerable;

internal partial class Solver {
    Fraction GetTemperature(long h, long c, long n) {
        var nc = n / 2;
        var nh = n - nc;
        return new Fraction(nh * h + nc * c, nh + nc);
    }

    public void Run() {
        var T = ni();
        while (T-- > 0) {
            var h = ni();
            var c = ni();
            var t = ni();

            // (h + c) / 2 = mid
            // h
            // (h + c) / 2
            // (2 * h + c) / 3
            // (h + c) / 2
            // (4 * mid + h) / 5
            // (h + c) / 2
            // (6 * mid + h) / 7

            // ((n - 1) * mid + h) / n
            // (n * mid - mid + h) / n
            // mid - mid / n + h / n
            // mid - (mid - h) / n
            // mid + (h - mid) / n -- where n is odd
            // mid + (h - mid) / n ~= t
            // n * mid + (h - mid) ~= n * t
            // n * (mid - t) + (h - mid) ~= 0
            // n * (mid - t) ~= (mid - h)
            // n ~= (mid - h) / (mid - t)
            // n ~= (2*mid - 2*h) / (2*mid - 2*t)
            long ans = 0;
            if (h == t) {
                ans = 1;
            } else if ((h + c) == t * 2) {
                ans = 2;
            } else {
                var mid2 = new Fraction(h + c);
                var h2 = new Fraction(2 * h);
                var t2 = new Fraction(2 * t);
                var n = (long)((mid2 - h2) / (mid2 - t2));
                //((mid2 - h2) / (mid2 - t2)).Dump();
                var cand = new List<long>();
                for (int i = -5; i <= 5; i++) {
                    if (n + i >= 1) {
                        cand.Add(n + i);
                    }
                }
                cand.Add(2);
                cand.Sort();

                ans = cand[0];
                var bestDiff = (GetTemperature(h, c, cand[0]) - t).Abs();

                foreach (var k in cand) {
                    var temp = GetTemperature(h, c, k);
                    var diff = (temp - t).Abs();
                    if (diff < bestDiff) {
                        bestDiff = diff;
                        ans = k;
                    }
                }
            }

            cout.WriteLine(ans);
        }
    }
}

public struct Fraction : IComparable<Fraction>, IEquatable<Fraction> {
    public long Numerator { get; private set; }
    public long Denominator { get; private set; }

    private static long Gcd(long s, long t) {
        return t != 0 ? Gcd(t, s % t) : Math.Abs(s);
    }

    private static long Lcm(long s, long t) {
        return s / Gcd(s, t) * t;
    }

    private void Reduce() {
        if (Denominator < 0) {
            Numerator = -Numerator;
            Denominator = -Denominator;
        }

        if (Numerator == 0) {
            Denominator = 1;
        } else {
            long g = Gcd(Numerator, Denominator);
            Numerator /= g;
            Denominator /= g;
        }
    }

    public Fraction(long a, long b = 1)
        : this() {
        Numerator = a;
        Denominator = b;
        Reduce();
    }

    public Fraction Abs() {
        return new Fraction(Math.Abs(Numerator), Math.Abs(Denominator));
    }

    public static implicit operator Fraction(long r) {
        return new Fraction(r, 1);
    }

    public static explicit operator long(Fraction f) {
        return f.Numerator / f.Denominator;
    }

    public static Fraction operator +(Fraction f1, Fraction f2) {
        long lcm = Lcm(f1.Denominator, f2.Denominator);
        return new Fraction(f1.Numerator * (lcm / f1.Denominator) + f2.Numerator * (lcm / f2.Denominator), lcm);
    }

    public static Fraction operator -(Fraction f1, Fraction f2) {
        long lcm = Lcm(f1.Denominator, f2.Denominator);
        return new Fraction(f1.Numerator * (lcm / f1.Denominator) - f2.Numerator * (lcm / f2.Denominator), lcm);
    }

    public static Fraction operator *(Fraction f1, Fraction f2) {
        return new Fraction(f1.Numerator * f2.Numerator, f1.Denominator * f2.Denominator);
    }

    public static Fraction operator /(Fraction f1, Fraction f2) {
        return new Fraction(f1.Numerator * f2.Denominator, f1.Denominator * f2.Numerator);
    }

    public static Fraction operator -(Fraction f) {
        return new Fraction(-f.Numerator, f.Denominator);
    }

    public int CompareTo(Fraction f) {
        return (Numerator * f.Denominator).CompareTo(f.Numerator * Denominator);
    }

    public static bool operator <(Fraction f1, Fraction f2) { return f1.CompareTo(f2) < 0; }
    public static bool operator <=(Fraction f1, Fraction f2) { return f1.CompareTo(f2) <= 0; }
    public static bool operator ==(Fraction f1, Fraction f2) { return f1.Numerator == f2.Numerator && f1.Denominator == f2.Denominator; }
    public static bool operator >(Fraction f1, Fraction f2) { return f1.CompareTo(f2) > 0; }
    public static bool operator >=(Fraction f1, Fraction f2) { return f1.CompareTo(f2) >= 0; }
    public static bool operator !=(Fraction f1, Fraction f2) { return !(f1 == f2); }

    public override string ToString() {
        return string.Format("{0}/{1}", Numerator, Denominator);
    }

    public override bool Equals(object obj) {
        if (obj == null) {
            return false;
        }

        var instance = (Fraction)obj;
        return this == instance;
    }

    public bool Equals(Fraction other) {
        return this == other;
    }

    public override int GetHashCode() {
        var h1 = Numerator.GetHashCode();
        var h2 = Denominator.GetHashCode();
        return unchecked(((h1 << 5) + h1) ^ h2);
    }
}

// PREWRITEN CODE BEGINS FROM HERE

static public class StringExtensions {
    static public string JoinToString<T>(this IEnumerable<T> source, string separator = " ") {
        return string.Join(separator, source);
    }
}

internal partial class Solver : Scanner {
    public static void Main() {
#if LOCAL
        byte[] inputBuffer = new byte[1000000];
        var inputStream = Console.OpenStandardInput(inputBuffer.Length);
        using (var reader = new StreamReader(inputStream, Console.InputEncoding, false, inputBuffer.Length)) {
            Console.SetIn(reader);
            new Solver(Console.In, Console.Out).Run();
        }
#else
        Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        new Solver(Console.In, Console.Out).Run();
        Console.Out.Flush();
#endif
    }

#pragma warning disable IDE0052
    private readonly TextReader cin;
    private readonly TextWriter cout;
    private readonly TextWriter cerr;
#pragma warning restore IDE0052

    public Solver(TextReader reader, TextWriter writer)
        : base(reader) {
        cin = reader;
        cout = writer;
        cerr = Console.Error;
    }

    public Solver(string input, TextWriter writer)
        : this(new StringReader(input), writer) {
    }

#pragma warning disable IDE1006
#pragma warning disable IDE0051
    private int ni() { return NextInt(); }
    private int[] ni(int n) { return NextIntArray(n); }
    private long nl() { return NextLong(); }
    private long[] nl(int n) { return NextLongArray(n); }
    private double nd() { return NextDouble(); }
    private double[] nd(int n) { return NextDoubleArray(n); }
    private string ns() { return Next(); }
    private string[] ns(int n) { return NextArray(n); }
#pragma warning restore IDE1006
#pragma warning restore IDE0051
}

internal static class LinqPadExtension {
    [Conditional("DEBUG")]
    public static void Dump<T>(this T obj) {
#if DEBUG
        LINQPad.Extensions.Dump(obj);
#endif
    }
}

public class Scanner {
    private readonly TextReader Reader;
    private readonly CultureInfo ci = CultureInfo.InvariantCulture;

    private readonly char[] buffer = new char[2 * 1024];
    private int cursor = 0, length = 0;
    private string Token;
    private readonly StringBuilder sb = new StringBuilder(1024);

    public Scanner()
        : this(Console.In) {
    }

    public Scanner(TextReader reader) {
        Reader = reader;
    }

    public int NextInt() { return checked((int)NextLong()); }
    public long NextLong() {
        var s = Next();
        long r = 0;
        int i = 0;
        bool negative = false;
        if (s[i] == '-') {
            negative = true;
            i++;
        }
        for (; i < s.Length; i++) {
            r = r * 10 + (s[i] - '0');
#if DEBUG
            if (!char.IsDigit(s[i])) throw new FormatException();
#endif
        }
        return negative ? -r : r;
    }
    public double NextDouble() { return double.Parse(Next(), ci); }
    public string[] NextArray(int size) {
        string[] array = new string[size];
        for (int i = 0; i < size; i++) {
            array[i] = Next();
        }

        return array;
    }
    public int[] NextIntArray(int size) {
        int[] array = new int[size];
        for (int i = 0; i < size; i++) {
            array[i] = NextInt();
        }

        return array;
    }

    public long[] NextLongArray(int size) {
        long[] array = new long[size];
        for (int i = 0; i < size; i++) {
            array[i] = NextLong();
        }

        return array;
    }

    public double[] NextDoubleArray(int size) {
        double[] array = new double[size];
        for (int i = 0; i < size; i++) {
            array[i] = NextDouble();
        }

        return array;
    }

    public string Next() {
        if (Token == null) {
            if (!StockToken()) {
                throw new Exception();
            }
        }
        var token = Token;
        Token = null;
        return token;
    }

    public bool HasNext() {
        if (Token != null) {
            return true;
        }

        return StockToken();
    }

    private bool StockToken() {
        while (true) {
            sb.Clear();
            while (true) {
                if (cursor >= length) {
                    cursor = 0;
                    if ((length = Reader.Read(buffer, 0, buffer.Length)) <= 0) {
                        break;
                    }
                }
                var c = buffer[cursor++];
                if (33 <= c && c <= 126) {
                    sb.Append(c);
                } else {
                    if (sb.Length > 0) break;
                }
            }

            if (sb.Length > 0) {
                Token = sb.ToString();
                return true;
            }

            return false;
        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;

namespace Olympo
{

    class Program
    {
        static void Main(string[] args)
        {
            var T = int.Parse(Console.ReadLine());
            for( var tc = 1; tc <= T; tc++)
            {
                var inputs = Console.ReadLine().Split(' ').Select(int.Parse).ToList();
                int h = inputs[0], c = inputs[1], t = inputs[2];
                if (h == t)
                    Console.WriteLine(1);
                else if (h + c >= 2 * t)
                    Console.WriteLine(2);
                else
                {
                    long l = 0, r = 500000;
                    long ind = -1;
                    while(l <= r)
                    {
                        var i = (l + r) / 2;
                        if ((i + 1) * h + i * c <= (2 * i + 1) * t)
                        {
                            long A = (i + 1) * h + i * c, B = 2 * i + 1;
                            long C = i * h + (i - 1) * c, D = 2 * i - 1;
                            double d1 = (t * B - A) / (double)B;
                            double d2 = (C - D * t) / (double)D;
                            ind = d2  <= d1 ? i - 1 : i;
                            r = i - 1;
                        }
                        else
                            l = i + 1;
                    }
                    var res = ind * 2 + 1;
                    Console.WriteLine(res);
                }
            }
        }

    }
}


using System;
using System.Collections.Generic;
using System.Linq;

namespace Olympo
{

    class Program
    {
        static void Main(string[] args)
        {
            var T = int.Parse(Console.ReadLine());
            for( var tc = 1; tc <= T; tc++)
            {
                var inputs = Console.ReadLine().Split(' ').Select(int.Parse).ToList();
                int h = inputs[0], c = inputs[1], t = inputs[2];
                if (h == t)
                    Console.WriteLine(1);
                else if (h + c == 2 * t)
                    Console.WriteLine(2);
                else
                {
                    var lst = new List<double>();
                    var min = double.MaxValue;
                    var mas = new int[] { c, h };
                    double ct = 0.0;
                    var res = 0;
                    for (int m = 1; m < 30 ; m++)
                    {
                        var ch = mas[m % 2];
                        ct = (ch + (m - 1) * ct) / m;
                        if (Math.Abs(ct - t) + 1e-8 < min )
                        {
                            min = Math.Abs(ct - t);
                            res = m;
                        }
                    }
                    Console.WriteLine(res);
                }
            }
        }

    }
}


using System;
using System.Collections.Generic;
using System.Linq;

namespace Olympo
{

    class Program
    {
        static void Main(string[] args)
        {
            var T = int.Parse(Console.ReadLine());
            for( var tc = 1; tc <= T; tc++)
            {
                var inputs = Console.ReadLine().Split(' ').Select(int.Parse).ToList();
                int h = inputs[0], c = inputs[1], t = inputs[2];
                if (h == t)
                    Console.WriteLine(1);
                else if (h + c == 2 * t)
                    Console.WriteLine(2);
                else
                {
                    var lst = new List<double>();
                    var min = double.MaxValue;
                    var mas = new int[] { c, h };
                    double ct = 0.0;
                    var res = 0;
                    for (int m = 1; m < 200 ; m++)
                    {
                        var ch = mas[m % 2];
                        ct = (ch + (m - 1) * ct) / m;
                        if (Math.Abs(ct - t) + 1e-8 < min )
                        {
                            min = Math.Abs(ct - t);
                            res = m;
                        }
                    }
                    Console.WriteLine(res);
                }
            }
        }

    }
}


using System;
using System.Collections.Generic;
using System.Linq;

namespace Olympo
{

    class Program
    {
        static void Main(string[] args)
        {
            var T = int.Parse(Console.ReadLine());
            for( var tc = 1; tc <= T; tc++)
            {
                var inputs = Console.ReadLine().Split(' ').Select(int.Parse).ToList();
                int h = inputs[0], c = inputs[1], t = inputs[2];
                if (h == t)
                    Console.WriteLine(1);
                else if (h + c >= 2 * t)
                    Console.WriteLine(2);
                else
                {
                    long l = 0, r = 500000;
                    long ind = -1;
                    while(l <= r)
                    {
                        var i = (l + r) / 2;
                        if ((i + 1) * h + i * c <= (2 * i + 1) * t)
                        {
                            long A = (i + 1) * h + i * c, B = 2 * i + 1;
                            long C = i * h + (i - 1) * c, D = 2 * i - 1;
                            double d1 = (t * B - A) / (double)B;
                            double d2 = (C - D * t) / (double)D;
                            ind = d2 + 1e-11 < d1 ? i - 1 : i;
                            r = i - 1;
                        }
                        else
                            l = i + 1;
                    }
                    var res = ind * 2 + 1;
                    Console.WriteLine(res);
                }
            }
        }

    }
}


using System;
using System.Collections.Generic;
using System.Linq;

namespace Olympo
{

    class Program
    {
        static void Main(string[] args)
        {
            var T = int.Parse(Console.ReadLine());
            for( var tc = 1; tc <= T; tc++)
            {
                var inputs = Console.ReadLine().Split(' ').Select(int.Parse).ToList();
                int h = inputs[0], c = inputs[1], t = inputs[2];
                if (h == t)
                    Console.WriteLine(1);
                else if (h + c == 2 * t)
                    Console.WriteLine(2);
                else
                {
                    var lst = new List<double>();
                    var min = double.MaxValue;
                    var mas = new int[] { c, h };
                    double ct = 0.0;
                    var res = 0;
                    for (int m = 1; m < 1000 ; m++)
                    {
                        var ch = mas[m % 2];
                        ct = (ch + (m - 1) * ct) / m;
                        if (Math.Abs(ct - t) + 1e-8 < min )
                        {
                            min = Math.Abs(ct - t);
                            res = m;
                        }
                    }
                    Console.WriteLine(res);
                }
            }
        }

    }
}


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
using System.Runtime.InteropServices;

namespace Olympo
{

    class Program
    {
        static void Main(string[] args)
        {
            var T = int.Parse(Console.ReadLine());
            for( var tc = 1; tc <= T; tc++)
            {
                var inputs = Console.ReadLine().Split(' ').Select(int.Parse).ToList();
                int h = inputs[0], c = inputs[1], t = inputs[2];
                if( h == t)
                    Console.WriteLine(1);
                else if( h+c == 2*t  )
                    Console.WriteLine(2);
                else if( h+c < 2 * t)
                {
                    var delta = (h - c);
                    var lst = new List<double>();
                    long b = 1;
                    for (int i = 1; i < 35; i++, b <<= 2)
                    {
                        lst.Add( (double)delta / (double)b);
                    }
                    lst.Sort();
                    double srch = (double)t - (double)(c + h) / 2.0;
                    var ind = lst.BinarySearch(srch);
                    if (ind < 0)
                        ind = ~ind;
                    var min = Math.Abs(lst[ind] - srch);
                    if( ind+ 1 < lst.Count && Math.Abs(lst[ind+1] - srch) < min)
                    {
                        min = Math.Abs(lst[ind+1] - srch);
                        ind++;
                    }
                    ind = lst.Count - ind-1;
                    var res = 2 * ind + 1;
                    Console.WriteLine(res);
                }
                else
                {
                    var delta = (h - c);
                    var lst = new List<double>();
                    long b = 8;
                    for (int i = 1; i < 35; i++, b <<= 2)
                    {
                        lst.Add(-(double)delta / (double)b);
                    }
                    double srch = (double)t - (double)(c + h) / 2.0;
                    var ind = lst.BinarySearch(srch);
                    if (ind < 0)
                        ind = ~ind;
                    var min = Math.Abs(lst[ind] - srch);
                    if (ind + 1 < lst.Count && Math.Abs(lst[ind + 1] - srch) < min)
                    {
                        min = Math.Abs(lst[ind + 1] - srch);
                        ind++;
                    }
                    var res = 2 * ind + 4;
                    Console.WriteLine(res);
                }
            }
        }

    }
}


using System;
using System.Collections.Generic;
using System.Linq;

namespace Olympo
{

    class Program
    {
        static void Main(string[] args)
        {
            var T = int.Parse(Console.ReadLine());
            for( var tc = 1; tc <= T; tc++)
            {
                var inputs = Console.ReadLine().Split(' ').Select(int.Parse).ToList();
                int h = inputs[0], c = inputs[1], t = inputs[2];
                if( h == t)
                    Console.WriteLine(1);
                else if( h+c == 2*t  )
                    Console.WriteLine(2);
                var lst = new List<double>();
                var min = double.MaxValue;
                var mas = new int[] { c,h };
                double ct = 0.0;
                var res = 0;
                for(int m=1; m < 40; m++)
                {
                    var ch = mas[m % 2];
                    ct = (ch + (m - 1) * ct) / m;
                    if( Math.Abs(ct -t) < min)
                    {
                        min = Math.Abs(ct - t);
                        res = m;
                    }
                }
                Console.WriteLine(res);
            }
        }

    }
}


using System;
using System.Collections.Generic;
using System.Linq;

namespace Olympo
{

    class Program
    {
        static void Main(string[] args)
        {
            var T = int.Parse(Console.ReadLine());
            for( var tc = 1; tc <= T; tc++)
            {
                var inputs = Console.ReadLine().Split(' ').Select(int.Parse).ToList();
                int h = inputs[0], c = inputs[1], t = inputs[2];
                if (h == t)
                    Console.WriteLine(1);
                else if (h + c == 2 * t)
                    Console.WriteLine(2);
                else
                {
                    long l = 0, r = 500000;
                    long ind = -1;
                    while(l <= r)
                    {
                        var i = (l + r) / 2;
                        if ((i + 1) * h + i * c <= (2 * i + 1) * t)
                        {
                            long A = (i + 1) * h + i * c, B = 2 * i + 1;
                            long C = i * h + (i - 1) * c, D = 2 * i - 1;
                            double d1 = (t * B - A) / (double)B;
                            double d2 = (C - D * t) / (double)D;
                            ind = d2 + 1e-11 < d1 ? i - 1 : i;
                            r = i - 1;
                        }
                        else
                            l = i + 1;
                    }
                    var res = ind * 2 + 1;
                    Console.WriteLine(res);
                }
            }
        }

    }
}


using System;
using System.Collections.Generic;
using System.Linq;

namespace Olympo
{

    class Program
    {
        static void Main(string[] args)
        {
            var T = int.Parse(Console.ReadLine());
            for( var tc = 1; tc <= T; tc++)
            {
                var inputs = Console.ReadLine().Split(' ').Select(int.Parse).ToList();
                int h = inputs[0], c = inputs[1], t = inputs[2];
                if (h == t)
                    Console.WriteLine(1);
                else if (h + c == 2 * t)
                    Console.WriteLine(2);
                else
                {
                    var lst = new List<double>();
                    var min = double.MaxValue;
                    var mas = new int[] { c, h };
                    double ct = 0.0;
                    var res = 0;
                    for (int m = 1; m < 40; m++)
                    {
                        var ch = mas[m % 2];
                        ct = (ch + (m - 1) * ct) / m;
                        if (Math.Abs(ct - t) < min)
                        {
                            min = Math.Abs(ct - t);
                            res = m;
                        }
                    }
                    Console.WriteLine(res);
                }
            }
        }

    }
}


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
using System.Runtime.InteropServices;

namespace Olympo
{

    class Program
    {
        static void Main(string[] args)
        {
            var T = int.Parse(Console.ReadLine());
            for( var tc = 1; tc <= T; tc++)
            {
                var inputs = Console.ReadLine().Split(' ').Select(int.Parse).ToList();
                int h = inputs[0], c = inputs[1], t = inputs[2];
                if( h == t)
                    Console.WriteLine(1);
                else if( h+c == 2*t  )
                    Console.WriteLine(2);
                else if( h+c < 2 * t)
                {
                    var delta = (h - c);
                    var lst = new List<double>();
                    long b = 1;
                    for (int i = 1; i < 40; i++, b <<= 2)
                    {
                        lst.Add( (double)delta / (double)b);
                    }
                    lst.Sort();
                    double srch = (double)t - (double)(c + h) / 2.0;
                    var ind = lst.BinarySearch(srch);
                    if (ind < 0)
                        ind = ~ind;
                    var min = Math.Abs(lst[ind] - srch);
                    if( ind+ 1 < lst.Count && Math.Abs(lst[ind+1] - srch) < min)
                    {
                        min = Math.Abs(lst[ind+1] - srch);
                        ind++;
                    }
                    ind = lst.Count - ind-1;
                    var res = 2 * ind + 1;
                    Console.WriteLine(res);
                }
                else
                {
                    var delta = (h - c);
                    var lst = new List<double>();
                    long b = 8;
                    for (int i = 1; i < 40; i++, b <<= 2)
                    {
                        lst.Add(-(double)delta / (double)b);
                    }
                    double srch = (double)t - (double)(c + h) / 2.0;
                    var ind = lst.BinarySearch(srch);
                    if (ind < 0)
                        ind = ~ind;
                    var min = Math.Abs(lst[ind] - srch);
                    if (ind + 1 < lst.Count && Math.Abs(lst[ind + 1] - srch) < min)
                    {
                        min = Math.Abs(lst[ind + 1] - srch);
                        ind++;
                    }
                    var res = 2 * ind + 4;
                    Console.WriteLine(res);
                }
            }
        }

    }
}


using System;
using System.Collections.Generic;
using System.Linq;

namespace Olympo
{

    class Program
    {
        static void Main(string[] args)
        {
            var T = int.Parse(Console.ReadLine());
            for( var tc = 1; tc <= T; tc++)
            {
                var inputs = Console.ReadLine().Split(' ').Select(int.Parse).ToList();
                int h = inputs[0], c = inputs[1], t = inputs[2];
                if (h == t)
                    Console.WriteLine(1);
                else if (h + c == 2 * t)
                    Console.WriteLine(2);
                else
                {
                    var lst = new List<double>();
                    var min = double.MaxValue;
                    var mas = new int[] { c, h };
                    double ct = 0.0;
                    var res = 0;
                    for (int m = 1; Math.Abs( (2*ct - (c+h))/2.0 ) > 1e-10 ; m++)
                    {
                        var ch = mas[m % 2];
                        ct = (ch + (m - 1) * ct) / m;
                        if (Math.Abs(ct - t) < min)
                        {
                            min = Math.Abs(ct - t);
                            res = m;
                        }
                    }
                    Console.WriteLine(res);
                }
            }
        }

    }
}


using System;
using static System.Console;
using static System.Int64;

namespace ProblemC
{
    class Program
    {
        private static long T { get; set; }
        static void Main(string[] args)
        {
            T = Parse(ReadLine());

            for (int i = 0; i < T; i++)
            {
                var input = ReadLine().Split(' ');
                var h = Parse(input[0]);
                var c = Parse(input[1]);
                var t = Parse(input[2]);

                long r;
                if (t <= (h + c) / 2)
                    r = 2;
                else
                {
                    var N = (int)((decimal)(t - c) / (2 * t - h - c));

                    var plus = Math.Abs((t - (decimal)((N + 1) * h + N * c) / (2 * N + 1)));
                    var minus = Math.Abs((t - (decimal)(N * h + (N - 1) * c) / (2 * N - 1)));
                    if (plus < minus)
                        r = 2 * (N + 1) - 1;
                    else
                        r = 2* N - 1;
                }

                WriteLine("{0}", r);
            }
        }
    }
}


using System;
using static System.Console;
using static System.Int32;

namespace ProblemC
{
    class Program
    {
        private static int T { get; set; }
        static void Main(string[] args)
        {
            T = Parse(ReadLine());

            for (int i = 0; i < T; i++)
            {
                var input = ReadLine().Split(' ');
                var h = Parse(input[0]);
                var c = Parse(input[1]);
                var t = Parse(input[2]);

                int r;
                if (t <= (double)(h + c) / 2)
                    r = 2;
                else
                {
                    var N = (int)((double)(t - c) / (2 * t - h - c));

                    var plus = Math.Abs((t - (double)((N + 1) * h + N * c) / (2 * N + 1)));
                    var minus = Math.Abs((t - (double)(N * h + (N - 1) * c) / (2 * N - 1)));
                    if (plus < minus)
                        r = 2 * (N + 1) - 1;
                    else
                        r = 2* N - 1;
                }

                WriteLine("{0}", r);
            }
        }
    }
}


using System;
using static System.Console;
using static System.Int64;

namespace ProblemC
{
    class Program
    {
        private static long T { get; set; }
        static void Main(string[] args)
        {
            T = Parse(ReadLine());

            for (int i = 0; i < T; i++)
            {
                var input = ReadLine().Split(' ');
                var h = Parse(input[0]);
                var c = Parse(input[1]);
                var t = Parse(input[2]);

                long r;
                if (t <= (double)(h + c) / 2)
                    r = 2;
                else
                {
                    var N = (int)((double)(t - c) / (2 * t - h - c));

                    var plus = Math.Abs((t - (double)((N + 1) * h + N * c) / (2 * N + 1)));
                    var minus = Math.Abs((t - (double)(N * h + (N - 1) * c) / (2 * N - 1)));
                    if (plus < minus)
                        r = 2 * (N + 1) - 1;
                    else
                        r = 2* N - 1;
                }

                WriteLine("{0}", r);
            }
        }
    }
}


using System;
using static System.Console;
using static System.Int32;

namespace ProblemC
{
    class Program
    {
        private static int T { get; set; }
        static void Main(string[] args)
        {
            T = Parse(ReadLine());

            for (int i = 0; i < T; i++)
            {
                var input = ReadLine().Split(' ');
                var h = Parse(input[0]);
                var c = Parse(input[1]);
                var t = Parse(input[2]);

                int r;
                if (t <= (h + c) / 2)
                    r = 2;
                else
                {
                    var N = (int)((double)(t - c) / (2 * t - h - c));

                    var plus = Math.Abs((t - ((N + 1) * h + N * c) / (double)(2 * N + 1)));
                    var minus = Math.Abs((t - (N * h + (N - 1) * c) / (double)(2 * N - 1)));
                    if (plus < minus)
                        r = 2 * (N + 1) - 1;
                    else
                        r = 2* N - 1;
                }

                WriteLine("{0}", r);
            }
        }
    }
}


using System;
using static System.Console;
using static System.Int32;

namespace ProblemC
{
    class Program
    {
        private static int T { get; set; }
        static void Main(string[] args)
        {
            T = Parse(ReadLine());

            for (int i = 0; i < T; i++)
            {
                var input = ReadLine().Split(' ');
                var h = Parse(input[0]);
                var c = Parse(input[1]);
                var t = Parse(input[2]);

                double N;
                if (t <= (h + c) / 2)
                    N = 2;
                else if (t >= h)
                    N = 1;
                else
                    N = 2 * Math.Round((double)(t - c) / (2 * t - h - c)) - 1;

                WriteLine("{0}", N);
            }
        }
    }
}


using System;
using static System.Console;
using static System.Int32;

namespace ProblemC
{
    class Program
    {
        private static int T { get; set; }
        static void Main(string[] args)
        {
            T = Parse(ReadLine());

            for (int i = 0; i < T; i++)
            {
                var input = ReadLine().Split(' ');
                var h = Parse(input[0]);
                var c = Parse(input[1]);
                var t = Parse(input[2]);

                double N;
                if (t <= (h + c) / 2)
                    N = 2;
                else if (t >= h)
                    N = 1;
                else
                {
                    var d = (double)(t - c) / (2 * t - h - c);
                    if(((int)d) + 0.5 < d)
                        N = 2 * ((int)d) + 1;
                    else
                        N = 2 * ((int)d) - 1;
                }

                WriteLine("{0}", N);
            }
        }
    }
}


using System;
using static System.Console;
using static System.Int32;

namespace ProblemC
{
    class Program
    {
        private static int T { get; set; }
        static void Main(string[] args)
        {
            T = Parse(ReadLine());

            for (int i = 0; i < T; i++)
            {
                var input = ReadLine().Split(' ');
                var h = Parse(input[0]);
                var c = Parse(input[1]);
                var t = Parse(input[2]);

                double N;
                if (t <= (h + c) / 2)
                    N = 2;
                else if (t >= h)
                    N = 1;
                else
                {
                    var d = (double)(t - c) / (2 * t - h - c);
                    if(((int)d) + 0.5 <= d)
                        N = 2 * ((int)d) + 1;
                    else
                        N = 2 * ((int)d) - 1;
                }

                WriteLine("{0}", N);
            }
        }
    }
}