//
// Created by Vlad Nitu on 05.01.2023.
//

#pragma once
#define NMAX 1001
#define ll long long
#define mkp make_pair
#define mkt make_tuple

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

void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}

template<typename T, typename V, typename W>
void __print(const std::tuple<T, V, W> &x) {cerr << '{'; __print(std::get<0>(x)); cerr << ','; __print(std::get<1>(x)); cerr << ','; __print(std::get<2>(x)); cerr << '}';}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define dbg(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define dbg(x...)
#endif

ifstream f("euclid3.in");
ofstream g("euclid3.out");

struct hash_pair {
    template<class T1, class T2>
    size_t operator()(const pair<T1, T2> &p) const {
        auto hash1 = hash<T1>{}(p.first);
        auto hash2 = hash<T2>{}(p.second);

        if (hash1 != hash2) {
            return hash1 ^ hash2;
        }
        return hash1;
    }

};

struct hash_tuple{
    size_t operator()(const tuple<int,int, int>&x)const{
        return hash<long long>()(((long long)std::get<1>(x)^(((long long)std::get<2>(x))^(long long)std::get<2>(x)))<<32);
    }
};

int gcd (int a, int b) { // Basic Euclid's Algorithm
    if (a == 0)
        return b;
    else
        return gcd(b % a, a);
}

int gcdExtended (int a, int b, int& x, int& y) {
    if (a == 0) // Base case -> 0 * x + 1 * y = b = gcd(a, b)
    {
        x = 0;
        y = 1;
        return b;
    }

    int x_prime, y_prime; // store results of recursive call
    int gcd = gcdExtended(b % a, a, x_prime, y_prime);

    x = y_prime - (b / a) * x_prime;
    y = x_prime;

    return gcd;
}


int T, a, b, c, d;
int x, y;
int main() {
    f >> T;
    while (T -- ) {
        f >> a >> b >> c;

        d = gcdExtended(a, b, x, y);

        if (c % d == 0)
            g << x * (c / d) << ' ' << y * (c / d) << '\n';
        else
            g << 0 <<  ' ' << 0 << '\n';

    }
    return 0;
}