#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ printf(char *, double, double, double);
double round(double);
int /*<<< orphan*/ scanf(char *, ...);
double sqrt(double);
int main(void) {
  int n, i;
  double x1, y1, x2, y2, x3, y3, px, py, r;
  scanf("%d", &n);
  for (i = 0; i < n; i++) {
    scanf("%lf %lf %lf %lf %lf %lf", &x1, &y1, &x2, &y2, &x3, &y3);
    px = (x1 * x1 * (y2 - y3) / 2.0 + x2 * x2 * (y3 - y1) / 2.0 +
          x3 * x3 * (y1 - y2) / 2.0 - (y2 - y1) * (y3 - y2) * (y1 - y3)) /
         ((x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1));
    if (y1 != y2) {
      py = -(x2 - x1) * (px - (x1 + x2) / 2.0) / (y2 - y1) + (y1 + y2) / 2.0;
    } else {
      py = -(x3 - x1) * (px - (x1 + x3) / 2.0) / (y3 - y1) + (y1 + y3) / 2.0;
    }
    r = sqrt((px - x1) * (px - x1) + (py - y1) * (py - y1));
    px = round(px);
    py = round(py);
    r = round(r);
    printf("%.3lf %.3lf %.3lf\n", px, py, r);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xeb2(%rip),%rdi
lea    -0x8(%rbp),%rsi
mov    $0x0,%al
call   1040 <scanf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    143d <main+0x2fd>
lea    0xe90(%rip),%rdi
lea    -0x18(%rbp),%rsi
lea    -0x20(%rbp),%rdx
lea    -0x28(%rbp),%rcx
lea    -0x30(%rbp),%r8
lea    -0x38(%rbp),%r9
lea    -0x40(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1040 <scanf@plt>
movsd  -0x18(%rbp),%xmm1
mulsd  -0x18(%rbp),%xmm1
movsd  -0x30(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
mulsd  %xmm0,%xmm1
movsd  0xe42(%rip),%xmm0
divsd  %xmm0,%xmm1
movsd  -0x28(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
subsd  -0x20(%rbp),%xmm2
mulsd  %xmm2,%xmm0
movsd  0xe1e(%rip),%xmm2
divsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
movsd  -0x38(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm2
subsd  -0x30(%rbp),%xmm2
mulsd  %xmm2,%xmm0
movsd  0xdf6(%rip),%xmm2
divsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
movsd  -0x30(%rbp),%xmm0
subsd  -0x20(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
subsd  -0x30(%rbp),%xmm2
mulsd  %xmm2,%xmm0
movsd  -0x20(%rbp),%xmm2
subsd  -0x40(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x28(%rbp),%xmm1
subsd  -0x18(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm3
subsd  -0x20(%rbp),%xmm3
movsd  -0x38(%rbp),%xmm2
subsd  -0x18(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm4
subsd  -0x20(%rbp),%xmm4
mulsd  %xmm4,%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x20(%rbp),%xmm0
ucomisd -0x30(%rbp),%xmm0
jne    12c2 <main+0x182>
jp     12c2 <main+0x182>
jmp    1338 <main+0x1f8>
movsd  -0x28(%rbp),%xmm0
subsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x48(%rbp),%xmm1
movsd  -0x18(%rbp),%xmm2
addsd  -0x28(%rbp),%xmm2
movsd  0xd06(%rip),%xmm3
divsd  %xmm3,%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  -0x30(%rbp),%xmm1
subsd  -0x20(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  -0x20(%rbp),%xmm1
addsd  -0x30(%rbp),%xmm1
movsd  0xcda(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    13a9 <main+0x269>
movsd  -0x38(%rbp),%xmm0
subsd  -0x18(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x48(%rbp),%xmm1
movsd  -0x18(%rbp),%xmm2
addsd  -0x38(%rbp),%xmm2
movsd  0xc90(%rip),%xmm3
divsd  %xmm3,%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  -0x40(%rbp),%xmm1
subsd  -0x20(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  -0x20(%rbp),%xmm1
addsd  -0x40(%rbp),%xmm1
movsd  0xc64(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
subsd  -0x18(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
subsd  -0x18(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
subsd  -0x20(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm3
subsd  -0x20(%rbp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm0
call   1050 <round@plt>
movsd  %xmm0,-0x48(%rbp)
movsd  -0x50(%rbp),%xmm0
call   1050 <round@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x58(%rbp),%xmm0
call   1050 <round@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm2
lea    0xbf9(%rip),%rdi
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1168 <main+0x28>
xor    %eax,%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
lea    0xecb(%rip),%rdi
lea    0x14(%rsp),%rsi
xor    %eax,%eax
call   1040 <scanf@plt>
cmpl   $0x0,0x14(%rsp)
jle    13a3 <main+0x263>
lea    0x48(%rsp),%r12
lea    0x40(%rsp),%r13
lea    0x38(%rsp),%rbx
lea    0x30(%rsp),%rbp
lea    0xeb4(%rip),%r14
xor    %r15d,%r15d
jmp    11f8 <main+0xb8>
nopl   0x0(%rax)
movsd  %xmm6,0x18(%rsp)
call   1060 <sqrt@plt>
movsd  0x18(%rsp),%xmm6
movsd  %xmm0,0x20(%rsp)
movapd %xmm6,%xmm0
call   1050 <round@plt>
movsd  %xmm0,0x18(%rsp)
movsd  0x8(%rsp),%xmm0
call   1050 <round@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x20(%rsp),%xmm0
call   1050 <round@plt>
movaps %xmm0,%xmm2
mov    %r14,%rdi
movsd  0x18(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
call   1030 <printf@plt>
add    $0x1,%r15d
cmp    0x14(%rsp),%r15d
jge    13a3 <main+0x263>
lea    0x28(%rsp),%rax
mov    %rax,(%rsp)
lea    0xe1b(%rip),%rdi
lea    0x50(%rsp),%rsi
mov    %r12,%rdx
mov    %r13,%rcx
mov    %rbx,%r8
mov    %rbp,%r9
xor    %eax,%eax
call   1040 <scanf@plt>
movsd  0x50(%rsp),%xmm9
movsd  0x38(%rsp),%xmm12
movsd  0x28(%rsp),%xmm3
movsd  0x40(%rsp),%xmm4
movsd  0x48(%rsp),%xmm13
movapd %xmm3,%xmm10
subsd  %xmm13,%xmm10
movsd  0x30(%rsp),%xmm7
movapd %xmm12,%xmm11
subsd  %xmm13,%xmm11
movapd %xmm4,%xmm1
subsd  %xmm9,%xmm1
movapd %xmm7,%xmm14
subsd  %xmm9,%xmm14
ucomisd %xmm12,%xmm13
jne    1277 <main+0x137>
jnp    12a0 <main+0x160>
movapd %xmm1,%xmm8
xorpd  0xd8b(%rip),%xmm8
movapd %xmm4,%xmm0
movsd  %xmm11,0x8(%rsp)
movapd %xmm12,%xmm5
jmp    12bd <main+0x17d>
nopw   0x0(%rax,%rax,1)
movapd %xmm14,%xmm8
xorpd  0xd62(%rip),%xmm8
movapd %xmm7,%xmm0
movsd  %xmm10,0x8(%rsp)
movapd %xmm3,%xmm5
movapd %xmm9,%xmm2
mulsd  %xmm9,%xmm2
movapd %xmm12,%xmm6
subsd  %xmm3,%xmm6
mulsd  %xmm2,%xmm6
movsd  0xd23(%rip),%xmm15
mulsd  %xmm15,%xmm6
mulsd  %xmm4,%xmm4
mulsd  %xmm10,%xmm4
mulsd  %xmm15,%xmm4
addsd  %xmm6,%xmm4
mulsd  %xmm7,%xmm7
movapd %xmm13,%xmm6
subsd  %xmm12,%xmm6
mulsd  %xmm7,%xmm6
mulsd  %xmm15,%xmm6
addsd  %xmm4,%xmm6
movapd %xmm13,%xmm2
subsd  %xmm3,%xmm2
subsd  %xmm12,%xmm3
mulsd  %xmm11,%xmm3
mulsd  %xmm2,%xmm3
subsd  %xmm3,%xmm6
mulsd  %xmm11,%xmm14
mulsd  %xmm10,%xmm1
subsd  %xmm14,%xmm1
divsd  %xmm1,%xmm6
addsd  %xmm9,%xmm0
mulsd  %xmm15,%xmm0
movapd %xmm6,%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm8,%xmm1
divsd  0x8(%rsp),%xmm1
addsd  %xmm13,%xmm5
mulsd  %xmm15,%xmm5
addsd  %xmm1,%xmm5
movapd %xmm6,%xmm0
subsd  %xmm9,%xmm0
movapd %xmm5,%xmm1
subsd  %xmm13,%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd 0xc7a(%rip),%xmm0
movsd  %xmm5,0x8(%rsp)
jb     1190 <main+0x50>
sqrtsd %xmm0,%xmm0
jmp    11a1 <main+0x61>
xor    %eax,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"%d\00"
@.str.1 = [24 x i8] c"%lf %lf %lf %lf %lf %lf\00"
@.str.2 = [19 x i8] c"%.3lf %.3lf %.3lf\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca double
%5 = alloca double
%6 = alloca double
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca double
%12 = alloca double
store i32 0, i32* %1
%13 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %2)
store i32 0, i32* %3
br label %14
14: ; preds = %145, %0
%15 = load i32, i32* %3
%16 = load i32, i32* %2
%17 = icmp slt i32 %15, %16
br i1 %17, label %18, label %148
18: ; preds = %14
%19 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.1, i64 0, i64 0), double* %4, double* %5, double* %6, double* %7, double* %8, double* %9)
%20 = load double, double* %4
%21 = load double, double* %4
%22 = fmul double %20, %21
%23 = load double, double* %7
%24 = load double, double* %9
%25 = fsub double %23, %24
%26 = fmul double %22, %25
%27 = fdiv double %26, 2.000000e+00
%28 = load double, double* %6
%29 = load double, double* %6
%30 = fmul double %28, %29
%31 = load double, double* %9
%32 = load double, double* %5
%33 = fsub double %31, %32
%34 = fmul double %30, %33
%35 = fdiv double %34, 2.000000e+00
%36 = fadd double %27, %35
%37 = load double, double* %8
%38 = load double, double* %8
%39 = fmul double %37, %38
%40 = load double, double* %5
%41 = load double, double* %7
%42 = fsub double %40, %41
%43 = fmul double %39, %42
%44 = fdiv double %43, 2.000000e+00
%45 = fadd double %36, %44
%46 = load double, double* %7
%47 = load double, double* %5
%48 = fsub double %46, %47
%49 = load double, double* %9
%50 = load double, double* %7
%51 = fsub double %49, %50
%52 = fmul double %48, %51
%53 = load double, double* %5
%54 = load double, double* %9
%55 = fsub double %53, %54
%56 = fneg double %52
%57 = call double @llvm.fmuladd.f64(double %56, double %55, double %45)
%58 = load double, double* %6
%59 = load double, double* %4
%60 = fsub double %58, %59
%61 = load double, double* %9
%62 = load double, double* %5
%63 = fsub double %61, %62
%64 = load double, double* %8
%65 = load double, double* %4
%66 = fsub double %64, %65
%67 = load double, double* %7
%68 = load double, double* %5
%69 = fsub double %67, %68
%70 = fmul double %66, %69
%71 = fneg double %70
%72 = call double @llvm.fmuladd.f64(double %60, double %63, double %71)
%73 = fdiv double %57, %72
store double %73, double* %10
%74 = load double, double* %5
%75 = load double, double* %7
%76 = fcmp une double %74, %75
br i1 %76, label %77, label %98
77: ; preds = %18
%78 = load double, double* %6
%79 = load double, double* %4
%80 = fsub double %78, %79
%81 = fneg double %80
%82 = load double, double* %10
%83 = load double, double* %4
%84 = load double, double* %6
%85 = fadd double %83, %84
%86 = fdiv double %85, 2.000000e+00
%87 = fsub double %82, %86
%88 = fmul double %81, %87
%89 = load double, double* %7
%90 = load double, double* %5
%91 = fsub double %89, %90
%92 = fdiv double %88, %91
%93 = load double, double* %5
%94 = load double, double* %7
%95 = fadd double %93, %94
%96 = fdiv double %95, 2.000000e+00
%97 = fadd double %92, %96
store double %97, double* %11
br label %119
98: ; preds = %18
%99 = load double, double* %8
%100 = load double, double* %4
%101 = fsub double %99, %100
%102 = fneg double %101
%103 = load double, double* %10
%104 = load double, double* %4
%105 = load double, double* %8
%106 = fadd double %104, %105
%107 = fdiv double %106, 2.000000e+00
%108 = fsub double %103, %107
%109 = fmul double %102, %108
%110 = load double, double* %9
%111 = load double, double* %5
%112 = fsub double %110, %111
%113 = fdiv double %109, %112
%114 = load double, double* %5
%115 = load double, double* %9
%116 = fadd double %114, %115
%117 = fdiv double %116, 2.000000e+00
%118 = fadd double %113, %117
store double %118, double* %11
br label %119
119: ; preds = %98, %77
%120 = load double, double* %10
%121 = load double, double* %4
%122 = fsub double %120, %121
%123 = load double, double* %10
%124 = load double, double* %4
%125 = fsub double %123, %124
%126 = load double, double* %11
%127 = load double, double* %5
%128 = fsub double %126, %127
%129 = load double, double* %11
%130 = load double, double* %5
%131 = fsub double %129, %130
%132 = fmul double %128, %131
%133 = call double @llvm.fmuladd.f64(double %122, double %125, double %132)
%134 = call double @sqrt(double %133)
store double %134, double* %12
%135 = load double, double* %10
%136 = call double @llvm.round.f64(double %135)
store double %136, double* %10
%137 = load double, double* %11
%138 = call double @llvm.round.f64(double %137)
store double %138, double* %11
%139 = load double, double* %12
%140 = call double @llvm.round.f64(double %139)
store double %140, double* %12
%141 = load double, double* %10
%142 = load double, double* %11
%143 = load double, double* %12
%144 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0), double %141, double %142, double %143)
br label %145
145: ; preds = %119
%146 = load i32, i32* %3
%147 = add nsw i32 %146, 1
store i32 %147, i32* %3
br label %14
148: ; preds = %14
ret i32 0
}

LLVM IR (-O2):
@.str = [3 x i8] c"%d\00"
@.str.1 = [24 x i8] c"%lf %lf %lf %lf %lf %lf\00"
@.str.2 = [19 x i8] c"%.3lf %.3lf %.3lf\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca double
%3 = alloca double
%4 = alloca double
%5 = alloca double
%6 = alloca double
%7 = alloca double
%8 = bitcast i32* %1 to i8*
%9 = bitcast double* %2 to i8*
%10 = bitcast double* %3 to i8*
%11 = bitcast double* %4 to i8*
%12 = bitcast double* %5 to i8*
%13 = bitcast double* %6 to i8*
%14 = bitcast double* %7 to i8*
%15 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
%16 = load i32, i32* %1
%17 = icmp sgt i32 %16, 0
br i1 %17, label %18, label %81
18: ; preds = %0, %56
%19 = phi i32 [ %78, %56 ], [ 0, %0 ]
%20 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.1, i64 0, i64 0), double* %2, double* %3, double* %4, double* %5, double* %6, double* %7)
%21 = load double, double* %2
%22 = fmul double %21, %21
%23 = load double, double* %5
%24 = load double, double* %7
%25 = fsub double %23, %24
%26 = fmul double %22, %25
%27 = fmul double %26, 5.000000e-01
%28 = load double, double* %4
%29 = fmul double %28, %28
%30 = load double, double* %3
%31 = fsub double %24, %30
%32 = fmul double %29, %31
%33 = fmul double %32, 5.000000e-01
%34 = fadd double %27, %33
%35 = load double, double* %6
%36 = fmul double %35, %35
%37 = fsub double %30, %23
%38 = fmul double %37, %36
%39 = fmul double %38, 5.000000e-01
%40 = fadd double %34, %39
%41 = fsub double %23, %30
%42 = fsub double %24, %23
%43 = fsub double %30, %24
%44 = fneg double %41
%45 = fmul double %42, %44
%46 = call double @llvm.fmuladd.f64(double %45, double %43, double %40)
%47 = fsub double %28, %21
%48 = fsub double %35, %21
%49 = fneg double %48
%50 = fmul double %41, %49
%51 = call double @llvm.fmuladd.f64(double %47, double %31, double %50)
%52 = fdiv double %46, %51
%53 = fcmp une double %30, %23
br i1 %53, label %54, label %56
54: ; preds = %18
%55 = fneg double %47
br label %56
56: ; preds = %18, %54
%57 = phi double [ %28, %54 ], [ %35, %18 ]
%58 = phi double [ %55, %54 ], [ %49, %18 ]
%59 = phi double [ %41, %54 ], [ %31, %18 ]
%60 = phi double [ %23, %54 ], [ %24, %18 ]
%61 = fadd double %21, %57
%62 = fmul double %61, 5.000000e-01
%63 = fsub double %52, %62
%64 = fmul double %63, %58
%65 = fdiv double %64, %59
%66 = fadd double %60, %30
%67 = fmul double %66, 5.000000e-01
%68 = fadd double %67, %65
%69 = fsub double %52, %21
%70 = fsub double %68, %30
%71 = fmul double %70, %70
%72 = call double @llvm.fmuladd.f64(double %69, double %69, double %71)
%73 = call double @sqrt(double %72)
%74 = call double @llvm.round.f64(double %52)
%75 = call double @llvm.round.f64(double %68)
%76 = call double @llvm.round.f64(double %73)
%77 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0), double %74, double %75, double %76)
%78 = add nuw nsw i32 %19, 1
%79 = load i32, i32* %1
%80 = icmp slt i32 %78, %79
br i1 %80, label %18, label %81
81: ; preds = %56, %0
ret i32 0
}