MOD = 10**9 + 7

def fib_fast_doubling(n, f0=0, f1=1):
    """Computes F(n) given F(0)=f0, F(1)=f1 using fast doubling (O(log n))."""
    def _fib(k):
        if k == 0:
            return (0, 1)
        else:
            a, b = _fib(k >> 1)
            c = (a * ((b * 2 - a) % MOD)) % MOD
            d = (a * a + b * b) % MOD
            if k & 1:
                return (d, (c + d) % MOD)
            else:
                return (c, d)
    fn, fn1 = _fib(n)
    # Combine results to support custom f0, f1
    return (fn * f1 + (fn1 - fn) * f0) % MOD

def solve(a, b, n):
    return fib_fast_doubling(n, f0=a, f1=b)

#include <array>
#include <bitset>
#include <cstdint>
#include <iostream>

using u32 = std::uint32_t;
using u64 = std::uint64_t;

struct u64_p
{
    constexpr static u64 P{ 1000000007u };

    constexpr u64_p() = default;
    constexpr u64_p( u64 value ) : m_value { value % P }{}
    constexpr u64_p operator+( u64_p r ) const{ return { m_value + r.m_value }; }
    constexpr u64_p operator*( u64_p r ) const{ return { m_value * r.m_value }; }

    u64 m_value{};
};

constexpr u64_p operator""_p( unsigned long long number )
{
    return u64_p{ static_cast<u64>( number ) };
}

struct Vec
{
    u64_p m_a{};
    u64_p m_b{};
};

struct Matrix
{
    constexpr Matrix operator*( Matrix r ) const
    { 
        return 
        { m_a * r.m_a + m_b * r.m_c
        , m_a * r.m_b + m_b * r.m_d
        , m_c * r.m_a + m_d * r.m_c
        , m_c * r.m_b + m_d * r.m_d };
    }
    constexpr Vec operator*( Vec r ) const
    { 
        return 
        { m_a * r.m_a + m_b * r.m_b
        , m_c * r.m_a + m_d * r.m_b };
    }

    u64_p m_a{};
    u64_p m_b{};
    u64_p m_c{};
    u64_p m_d{};
};

constexpr Matrix IDENTITY{ 1_p, 0_p, 0_p, 1_p };
constexpr Matrix LAMBDA{ 1_p, 1_p, 1_p, 0_p };
constexpr std::size_t U32_BITCOUNT{ 32u };

constexpr auto LAMBDA_POWERS_2_POW_I{
    []() constexpr
    {
        std::array<Matrix, U32_BITCOUNT> matrices{};
        matrices[ 0u ] = LAMBDA;
        for ( std::size_t i{ 1u }; i < U32_BITCOUNT; ++i )
        {
            matrices[ i ] = matrices[ i - 1u ] * matrices[ i - 1u ];
        }
        return matrices;
    }()
};

Matrix pow_lambda( const u32 exponent )
{
    const std::bitset<U32_BITCOUNT> bits{ exponent };
    Matrix result{ IDENTITY };
    for( std::size_t i{}; i < U32_BITCOUNT; i++ )
    {
        if( bits.test( i ) )
        {
            result = result * LAMBDA_POWERS_2_POW_I[ i ];
        }
    }
    return result;
}

u64 solve( const u64 a, const u64 b, const u32 n ) {
    return ( pow_lambda( n - 1 ) * Vec{ b, a } ).m_a.m_value;
}

int main()
{
    std::size_t t{};
    std::cin >> t;
    while( t-- )
    {
        u64 a{}, b{};
        u32 n{};
        std::cin >> a >> b >> n;
        std::cout << solve( a, b, n ) << std::endl;
    }
}