import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class Main {

    /** 入力される数値の数 */
    private static final int NUMBER_OF_ELEMENT = 3;

    /** 配列がそれぞれどの辺に対応するか（X） */
    private static final int INDEX_X = 0;

    /** 配列がそれぞれどの辺に対応するか（Y） */
    private static final int INDEX_Y = 1;

    /** 配列がそれぞれどの辺に対応するか（Z） */
    private static final int INDEX_Z = 2;

    /** 出力文字列のマップ */
    private static final Map<Boolean, String> printMap = new HashMap<Boolean, String>();;
    static {
        printMap.put(true, "YES");
        printMap.put(false, "NO");
    }

    /**
     * 空白区切りの3つの数字を受け取り、
     * その3つの数字を3辺とする三角形が直角三角形であるかどうかを判定する。
     *
     * @param args
     */
    public static void main(String[] args) throws IOException {

        // 入力値を読み込む
        int[][] triangleList = readTriangleList();

        // 入力値の数だけ処理を行い、結果を出力する
        for (int i = 0; i < triangleList.length; i++) {
            boolean isTriangle = isRightTriangle(triangleList[i]);
            System.out.println(printMap.get(isTriangle));
        }

     }

    /**
     * 標準入力から空白区切りの数値を取得し、三角形を表す整数の2次元配列として返却する。
     *
     * @return 三角形を表す整数の2次元配列（3×データ数）
     */
    protected static int[][] readTriangleList() throws IOException {

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        // 最初にデータの個数を取得する
        int numberOfLine = Integer.parseInt(reader.readLine());

        // 1行につき、3データずつ取り込む
        int[][] triangleList = new int[numberOfLine][NUMBER_OF_ELEMENT];
        for (int i = 0; i < triangleList.length; i++) {
            String[] lengthArray = reader.readLine().split(" ");
            for (int j = 0; j < lengthArray.length; j++) {
                triangleList[i][j] = Integer.parseInt(lengthArray[j]);
            }
        }

        if (reader != null) {
            reader.close();
        }

        return triangleList;
    }

    /**
     * 指定された三角形のデータが直角三角形かどうかを判定する。
     *
     * @param triangle 三角形を表す整数配列
     * @return 直角三角形なら true、そうでないなら false
     */
    protected static boolean isRightTriangle(int[] triangle) {

        // 一番長い辺が最後にくるように配列をソートする
        Arrays.sort(triangle);

        // ピタゴラスの定理を用いて判定する
        int xx = (int)Math.pow(triangle[INDEX_X], 2);
        int yy = (int)Math.pow(triangle[INDEX_Y], 2);
        int zz = (int)Math.pow(triangle[INDEX_Z], 2);

        // x^2 + y^2 = z^2 ならば直角三角形
        return ((xx + yy) == zz);
    }
} import java.io.BufferedReader; BufferedReader java.io import java.io.IOException; IOException java.io import java.io.InputStreamReader; InputStreamReader java.io import java.util.Arrays; Arrays java.util import java.util.HashMap; HashMap java.util import java.util.Map; Map java.util public class Main {

    /** 入力される数値の数 */
    private static final int NUMBER_OF_ELEMENT = 3;

    /** 配列がそれぞれどの辺に対応するか（X） */
    private static final int INDEX_X = 0;

    /** 配列がそれぞれどの辺に対応するか（Y） */
    private static final int INDEX_Y = 1;

    /** 配列がそれぞれどの辺に対応するか（Z） */
    private static final int INDEX_Z = 2;

    /** 出力文字列のマップ */
    private static final Map<Boolean, String> printMap = new HashMap<Boolean, String>();;
    static {
        printMap.put(true, "YES");
        printMap.put(false, "NO");
    }

    /**
     * 空白区切りの3つの数字を受け取り、
     * その3つの数字を3辺とする三角形が直角三角形であるかどうかを判定する。
     *
     * @param args
     */
    public static void main(String[] args) throws IOException {

        // 入力値を読み込む
        int[][] triangleList = readTriangleList();

        // 入力値の数だけ処理を行い、結果を出力する
        for (int i = 0; i < triangleList.length; i++) {
            boolean isTriangle = isRightTriangle(triangleList[i]);
            System.out.println(printMap.get(isTriangle));
        }

     }

    /**
     * 標準入力から空白区切りの数値を取得し、三角形を表す整数の2次元配列として返却する。
     *
     * @return 三角形を表す整数の2次元配列（3×データ数）
     */
    protected static int[][] readTriangleList() throws IOException {

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        // 最初にデータの個数を取得する
        int numberOfLine = Integer.parseInt(reader.readLine());

        // 1行につき、3データずつ取り込む
        int[][] triangleList = new int[numberOfLine][NUMBER_OF_ELEMENT];
        for (int i = 0; i < triangleList.length; i++) {
            String[] lengthArray = reader.readLine().split(" ");
            for (int j = 0; j < lengthArray.length; j++) {
                triangleList[i][j] = Integer.parseInt(lengthArray[j]);
            }
        }

        if (reader != null) {
            reader.close();
        }

        return triangleList;
    }

    /**
     * 指定された三角形のデータが直角三角形かどうかを判定する。
     *
     * @param triangle 三角形を表す整数配列
     * @return 直角三角形なら true、そうでないなら false
     */
    protected static boolean isRightTriangle(int[] triangle) {

        // 一番長い辺が最後にくるように配列をソートする
        Arrays.sort(triangle);

        // ピタゴラスの定理を用いて判定する
        int xx = (int)Math.pow(triangle[INDEX_X], 2);
        int yy = (int)Math.pow(triangle[INDEX_Y], 2);
        int zz = (int)Math.pow(triangle[INDEX_Z], 2);

        // x^2 + y^2 = z^2 ならば直角三角形
        return ((xx + yy) == zz);
    }
} Main /** 入力される数値の数 */
    private static final int NUMBER_OF_ELEMENT = 3; NUMBER_OF_ELEMENT 3 /** 配列がそれぞれどの辺に対応するか（X） */
    private static final int INDEX_X = 0; INDEX_X 0 /** 配列がそれぞれどの辺に対応するか（Y） */
    private static final int INDEX_Y = 1; INDEX_Y 1 /** 配列がそれぞれどの辺に対応するか（Z） */
    private static final int INDEX_Z = 2; INDEX_Z 2 /** 出力文字列のマップ */
    private static final Map<Boolean, String> printMap = new HashMap<Boolean, String>(); printMap new HashMap<Boolean, String>() /**
     * 空白区切りの3つの数字を受け取り、
     * その3つの数字を3辺とする三角形が直角三角形であるかどうかを判定する。
     *
     * @param args
     */
    public static void main(String[] args) throws IOException {

        // 入力値を読み込む
        int[][] triangleList = readTriangleList();

        // 入力値の数だけ処理を行い、結果を出力する
        for (int i = 0; i < triangleList.length; i++) {
            boolean isTriangle = isRightTriangle(triangleList[i]);
            System.out.println(printMap.get(isTriangle));
        }

     } main {

        // 入力値を読み込む
        int[][] triangleList = readTriangleList();

        // 入力値の数だけ処理を行い、結果を出力する
        for (int i = 0; i < triangleList.length; i++) {
            boolean isTriangle = isRightTriangle(triangleList[i]);
            System.out.println(printMap.get(isTriangle));
        }

     } int[][] triangleList = readTriangleList(); triangleList readTriangleList() readTriangleList for (int i = 0; i < triangleList.length; i++) {
            boolean isTriangle = isRightTriangle(triangleList[i]);
            System.out.println(printMap.get(isTriangle));
        } int i = 0; int i = 0; i 0 i < triangleList.length i triangleList.length triangleList triangleList.length i++ i++ i {
            boolean isTriangle = isRightTriangle(triangleList[i]);
            System.out.println(printMap.get(isTriangle));
        } {
            boolean isTriangle = isRightTriangle(triangleList[i]);
            System.out.println(printMap.get(isTriangle));
        } boolean isTriangle = isRightTriangle(triangleList[i]); isTriangle isRightTriangle(triangleList[i]) isRightTriangle triangleList[i] triangleList i System.out.println(printMap.get(isTriangle)) System.out.println System.out System System.out printMap.get(isTriangle) printMap.get printMap isTriangle String[] args args /**
     * 標準入力から空白区切りの数値を取得し、三角形を表す整数の2次元配列として返却する。
     *
     * @return 三角形を表す整数の2次元配列（3×データ数）
     */
    protected static int[][] readTriangleList() throws IOException {

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        // 最初にデータの個数を取得する
        int numberOfLine = Integer.parseInt(reader.readLine());

        // 1行につき、3データずつ取り込む
        int[][] triangleList = new int[numberOfLine][NUMBER_OF_ELEMENT];
        for (int i = 0; i < triangleList.length; i++) {
            String[] lengthArray = reader.readLine().split(" ");
            for (int j = 0; j < lengthArray.length; j++) {
                triangleList[i][j] = Integer.parseInt(lengthArray[j]);
            }
        }

        if (reader != null) {
            reader.close();
        }

        return triangleList;
    } readTriangleList {

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        // 最初にデータの個数を取得する
        int numberOfLine = Integer.parseInt(reader.readLine());

        // 1行につき、3データずつ取り込む
        int[][] triangleList = new int[numberOfLine][NUMBER_OF_ELEMENT];
        for (int i = 0; i < triangleList.length; i++) {
            String[] lengthArray = reader.readLine().split(" ");
            for (int j = 0; j < lengthArray.length; j++) {
                triangleList[i][j] = Integer.parseInt(lengthArray[j]);
            }
        }

        if (reader != null) {
            reader.close();
        }

        return triangleList;
    } BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); reader new BufferedReader(new InputStreamReader(System.in)) int numberOfLine = Integer.parseInt(reader.readLine()); numberOfLine Integer.parseInt(reader.readLine()) Integer.parseInt Integer reader.readLine() reader.readLine reader int[][] triangleList = new int[numberOfLine][NUMBER_OF_ELEMENT]; triangleList new int[numberOfLine][NUMBER_OF_ELEMENT] numberOfLine NUMBER_OF_ELEMENT for (int i = 0; i < triangleList.length; i++) {
            String[] lengthArray = reader.readLine().split(" ");
            for (int j = 0; j < lengthArray.length; j++) {
                triangleList[i][j] = Integer.parseInt(lengthArray[j]);
            }
        } int i = 0; int i = 0; i 0 i < triangleList.length i triangleList.length triangleList triangleList.length i++ i++ i {
            String[] lengthArray = reader.readLine().split(" ");
            for (int j = 0; j < lengthArray.length; j++) {
                triangleList[i][j] = Integer.parseInt(lengthArray[j]);
            }
        } {
            String[] lengthArray = reader.readLine().split(" ");
            for (int j = 0; j < lengthArray.length; j++) {
                triangleList[i][j] = Integer.parseInt(lengthArray[j]);
            }
        } String[] lengthArray = reader.readLine().split(" "); lengthArray reader.readLine().split(" ") reader.readLine().split reader.readLine() reader.readLine reader " " for (int j = 0; j < lengthArray.length; j++) {
                triangleList[i][j] = Integer.parseInt(lengthArray[j]);
            } int j = 0; int j = 0; j 0 j < lengthArray.length j lengthArray.length lengthArray lengthArray.length j++ j++ j {
                triangleList[i][j] = Integer.parseInt(lengthArray[j]);
            } {
                triangleList[i][j] = Integer.parseInt(lengthArray[j]);
            } triangleList[i][j] = Integer.parseInt(lengthArray[j]) triangleList[i][j] triangleList[i] triangleList i j Integer.parseInt(lengthArray[j]) Integer.parseInt Integer lengthArray[j] lengthArray j if (reader != null) {
            reader.close();
        } reader != null reader null {
            reader.close();
        } reader.close() reader.close reader return triangleList; triangleList /**
     * 指定された三角形のデータが直角三角形かどうかを判定する。
     *
     * @param triangle 三角形を表す整数配列
     * @return 直角三角形なら true、そうでないなら false
     */
    protected static boolean isRightTriangle(int[] triangle) {

        // 一番長い辺が最後にくるように配列をソートする
        Arrays.sort(triangle);

        // ピタゴラスの定理を用いて判定する
        int xx = (int)Math.pow(triangle[INDEX_X], 2);
        int yy = (int)Math.pow(triangle[INDEX_Y], 2);
        int zz = (int)Math.pow(triangle[INDEX_Z], 2);

        // x^2 + y^2 = z^2 ならば直角三角形
        return ((xx + yy) == zz);
    } isRightTriangle {

        // 一番長い辺が最後にくるように配列をソートする
        Arrays.sort(triangle);

        // ピタゴラスの定理を用いて判定する
        int xx = (int)Math.pow(triangle[INDEX_X], 2);
        int yy = (int)Math.pow(triangle[INDEX_Y], 2);
        int zz = (int)Math.pow(triangle[INDEX_Z], 2);

        // x^2 + y^2 = z^2 ならば直角三角形
        return ((xx + yy) == zz);
    } Arrays.sort(triangle) Arrays.sort Arrays triangle int xx = (int)Math.pow(triangle[INDEX_X], 2); xx (int)Math.pow(triangle[INDEX_X], 2) Math.pow Math triangle[INDEX_X] triangle INDEX_X 2 int yy = (int)Math.pow(triangle[INDEX_Y], 2); yy (int)Math.pow(triangle[INDEX_Y], 2) Math.pow Math triangle[INDEX_Y] triangle INDEX_Y 2 int zz = (int)Math.pow(triangle[INDEX_Z], 2); zz (int)Math.pow(triangle[INDEX_Z], 2) Math.pow Math triangle[INDEX_Z] triangle INDEX_Z 2 return ((xx + yy) == zz); ((xx + yy) == zz) (xx + yy) xx yy zz int[] triangle triangle public class Main {

    /** 入力される数値の数 */
    private static final int NUMBER_OF_ELEMENT = 3;

    /** 配列がそれぞれどの辺に対応するか（X） */
    private static final int INDEX_X = 0;

    /** 配列がそれぞれどの辺に対応するか（Y） */
    private static final int INDEX_Y = 1;

    /** 配列がそれぞれどの辺に対応するか（Z） */
    private static final int INDEX_Z = 2;

    /** 出力文字列のマップ */
    private static final Map<Boolean, String> printMap = new HashMap<Boolean, String>();;
    static {
        printMap.put(true, "YES");
        printMap.put(false, "NO");
    }

    /**
     * 空白区切りの3つの数字を受け取り、
     * その3つの数字を3辺とする三角形が直角三角形であるかどうかを判定する。
     *
     * @param args
     */
    public static void main(String[] args) throws IOException {

        // 入力値を読み込む
        int[][] triangleList = readTriangleList();

        // 入力値の数だけ処理を行い、結果を出力する
        for (int i = 0; i < triangleList.length; i++) {
            boolean isTriangle = isRightTriangle(triangleList[i]);
            System.out.println(printMap.get(isTriangle));
        }

     }

    /**
     * 標準入力から空白区切りの数値を取得し、三角形を表す整数の2次元配列として返却する。
     *
     * @return 三角形を表す整数の2次元配列（3×データ数）
     */
    protected static int[][] readTriangleList() throws IOException {

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        // 最初にデータの個数を取得する
        int numberOfLine = Integer.parseInt(reader.readLine());

        // 1行につき、3データずつ取り込む
        int[][] triangleList = new int[numberOfLine][NUMBER_OF_ELEMENT];
        for (int i = 0; i < triangleList.length; i++) {
            String[] lengthArray = reader.readLine().split(" ");
            for (int j = 0; j < lengthArray.length; j++) {
                triangleList[i][j] = Integer.parseInt(lengthArray[j]);
            }
        }

        if (reader != null) {
            reader.close();
        }

        return triangleList;
    }

    /**
     * 指定された三角形のデータが直角三角形かどうかを判定する。
     *
     * @param triangle 三角形を表す整数配列
     * @return 直角三角形なら true、そうでないなら false
     */
    protected static boolean isRightTriangle(int[] triangle) {

        // 一番長い辺が最後にくるように配列をソートする
        Arrays.sort(triangle);

        // ピタゴラスの定理を用いて判定する
        int xx = (int)Math.pow(triangle[INDEX_X], 2);
        int yy = (int)Math.pow(triangle[INDEX_Y], 2);
        int zz = (int)Math.pow(triangle[INDEX_Z], 2);

        // x^2 + y^2 = z^2 ならば直角三角形
        return ((xx + yy) == zz);
    }
} public class Main {

    /** 入力される数値の数 */
    private static final int NUMBER_OF_ELEMENT = 3;

    /** 配列がそれぞれどの辺に対応するか（X） */
    private static final int INDEX_X = 0;

    /** 配列がそれぞれどの辺に対応するか（Y） */
    private static final int INDEX_Y = 1;

    /** 配列がそれぞれどの辺に対応するか（Z） */
    private static final int INDEX_Z = 2;

    /** 出力文字列のマップ */
    private static final Map<Boolean, String> printMap = new HashMap<Boolean, String>();;
    static {
        printMap.put(true, "YES");
        printMap.put(false, "NO");
    }

    /**
     * 空白区切りの3つの数字を受け取り、
     * その3つの数字を3辺とする三角形が直角三角形であるかどうかを判定する。
     *
     * @param args
     */
    public static void main(String[] args) throws IOException {

        // 入力値を読み込む
        int[][] triangleList = readTriangleList();

        // 入力値の数だけ処理を行い、結果を出力する
        for (int i = 0; i < triangleList.length; i++) {
            boolean isTriangle = isRightTriangle(triangleList[i]);
            System.out.println(printMap.get(isTriangle));
        }

     }

    /**
     * 標準入力から空白区切りの数値を取得し、三角形を表す整数の2次元配列として返却する。
     *
     * @return 三角形を表す整数の2次元配列（3×データ数）
     */
    protected static int[][] readTriangleList() throws IOException {

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        // 最初にデータの個数を取得する
        int numberOfLine = Integer.parseInt(reader.readLine());

        // 1行につき、3データずつ取り込む
        int[][] triangleList = new int[numberOfLine][NUMBER_OF_ELEMENT];
        for (int i = 0; i < triangleList.length; i++) {
            String[] lengthArray = reader.readLine().split(" ");
            for (int j = 0; j < lengthArray.length; j++) {
                triangleList[i][j] = Integer.parseInt(lengthArray[j]);
            }
        }

        if (reader != null) {
            reader.close();
        }

        return triangleList;
    }

    /**
     * 指定された三角形のデータが直角三角形かどうかを判定する。
     *
     * @param triangle 三角形を表す整数配列
     * @return 直角三角形なら true、そうでないなら false
     */
    protected static boolean isRightTriangle(int[] triangle) {

        // 一番長い辺が最後にくるように配列をソートする
        Arrays.sort(triangle);

        // ピタゴラスの定理を用いて判定する
        int xx = (int)Math.pow(triangle[INDEX_X], 2);
        int yy = (int)Math.pow(triangle[INDEX_Y], 2);
        int zz = (int)Math.pow(triangle[INDEX_Z], 2);

        // x^2 + y^2 = z^2 ならば直角三角形
        return ((xx + yy) == zz);
    }
} Main
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class Main {

    /** 入力される数値の数 */
    private static final int NUMBER_OF_ELEMENT = 3;

    /** 配列がそれぞれどの辺に対応するか（X） */
    private static final int INDEX_X = 0;

    /** 配列がそれぞれどの辺に対応するか（Y） */
    private static final int INDEX_Y = 1;

    /** 配列がそれぞれどの辺に対応するか（Z） */
    private static final int INDEX_Z = 2;

    /** 出力文字列のマップ */
    private static final Map<Boolean, String> printMap = new HashMap<Boolean, String>();;
    static {
        printMap.put(true, "YES");
        printMap.put(false, "NO");
    }

    /**
     * 空白区切りの3つの数字を受け取り、
     * その3つの数字を3辺とする三角形が直角三角形であるかどうかを判定する。
     *
     * @param args
     */
    public static void main(String[] args) throws IOException {

        // 入力値を読み込む
        int[][] triangleList = readTriangleList();

        // 入力値の数だけ処理を行い、結果を出力する
        for (int i = 0; i < triangleList.length; i++) {
            boolean isTriangle = isRightTriangle(triangleList[i]);
            System.out.println(printMap.get(isTriangle));
        }

     }

    /**
     * 標準入力から空白区切りの数値を取得し、三角形を表す整数の2次元配列として返却する。
     *
     * @return 三角形を表す整数の2次元配列（3×データ数）
     */
    protected static int[][] readTriangleList() throws IOException {

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        // 最初にデータの個数を取得する
        int numberOfLine = Integer.parseInt(reader.readLine());

        // 1行につき、3データずつ取り込む
        int[][] triangleList = new int[numberOfLine][NUMBER_OF_ELEMENT];
        for (int i = 0; i < triangleList.length; i++) {
            String[] lengthArray = reader.readLine().split(" ");
            for (int j = 0; j < lengthArray.length; j++) {
                triangleList[i][j] = Integer.parseInt(lengthArray[j]);
            }
        }

        if (reader != null) {
            reader.close();
        }

        return triangleList;
    }

    /**
     * 指定された三角形のデータが直角三角形かどうかを判定する。
     *
     * @param triangle 三角形を表す整数配列
     * @return 直角三角形なら true、そうでないなら false
     */
    protected static boolean isRightTriangle(int[] triangle) {

        // 一番長い辺が最後にくるように配列をソートする
        Arrays.sort(triangle);

        // ピタゴラスの定理を用いて判定する
        int xx = (int)Math.pow(triangle[INDEX_X], 2);
        int yy = (int)Math.pow(triangle[INDEX_Y], 2);
        int zz = (int)Math.pow(triangle[INDEX_Z], 2);

        // x^2 + y^2 = z^2 ならば直角三角形
        return ((xx + yy) == zz);
    }
}