file
stringlengths 18
26
| data
stringlengths 3
1.04M
|
|---|---|
the_stack_data/95450841.c | #include <stdio.h>
typedef struct {
int X, Y;
} ponto;
typedef struct {
int X, Y;
ponto p;
} retangulo;
void main () {
retangulo ret;
float area, comprimento, perimetro;
printf("Retangulo (X, Y): ");
scanf("%i %i", &ret.X, &ret.Y);
printf("Ponto (X, Y): ");
scanf("%i %i", &ret.p.X, &ret.p.Y);
if (ret.X == ret.p.X && ret.Y == ret.p.Y) {
printf("Está dentro do retângulo.\n");
} else {
printf("Não está dentro do retângulo.\n");
}
} |
the_stack_data/3264025.c | #include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <sys/types.h>
#define CLOCKSIZE 8
#define PTE_P 0x001
#define PTE_A 0x020
#define PTE_E 0x200
typedef uint32_t pte_t;
typedef struct clk_node {
int vpn;
pte_t *pte;
} node_t;
// There are many ways of implementing a CLOCK eviction algorithm.
// I'm showing the most classical way:
// A clock struture is composed of a fixed ring buffer and
// an index of the current tail (clock hand).
node_t clk_queue[CLOCKSIZE];
int clk_hand = -1;
//////////////////////////////////////////
// Placeholders for mem encrypt/decrypt //
//////////////////////////////////////////
static void
mencrypt(int vpn, pte_t *pte)
{
if (*pte & PTE_E)
return;
*pte |= PTE_E;
*pte &= (~PTE_P);
// Flip the bits...
}
static void
mdecrypt(int vpn, pte_t *pte)
{
if (!(*pte & PTE_E))
return;
*pte &= (~PTE_E);
*pte |= PTE_P;
// Flip the bits...
}
////////////////////////////
// Clock queue operations //
////////////////////////////
// Insert a page (should be guaranteed not already in queue)
// into the clock queue.
static void
clk_insert(int vpn, pte_t *pte)
{
for (;;) {
// First advance the hand.
clk_hand = (clk_hand + 1) % CLOCKSIZE;
// Found an empty slot.
if (clk_queue[clk_hand].vpn == -1) {
clk_queue[clk_hand].vpn = vpn;
clk_queue[clk_hand].pte = pte;
break;
// Else if the page in this slot does not have its ref
// bit set, evict this one.
} else if (!(*(clk_queue[clk_hand].pte) & PTE_A)) {
// Encrypt the evicted page.
mencrypt(clk_queue[clk_hand].vpn, clk_queue[clk_hand].pte);
// Put in the new page.
clk_queue[clk_hand].vpn = vpn;
clk_queue[clk_hand].pte = pte;
break;
// Else, clear the ref bit of the page in slot.
} else {
*(clk_queue[clk_hand].pte) &= (~PTE_A);
}
}
// Decrypt the new page.
mdecrypt(vpn, pte);
}
// Removing a page forcefully is tricky because you need to
// shift things around.
// This happens at page deallocation.
static void
clk_remove(int vpn)
{
int prev_tail = clk_hand;
int match_idx = -1;
// Search for the matching element.
for (int i = 0; i < CLOCKSIZE; ++i) {
int idx = (clk_hand + i) % CLOCKSIZE;
if (clk_queue[idx].vpn == vpn) {
match_idx = idx;
break;
}
}
if (match_idx == -1)
return;
// Shift everything from match_idx+1 to prev_tail to
// one slot to the left.
for (int idx = match_idx;
idx != prev_tail;
idx = (idx + 1) % CLOCKSIZE) {
int next_idx = (idx + 1) % CLOCKSIZE;
clk_queue[idx].vpn = clk_queue[next_idx].vpn;
clk_queue[idx].pte = clk_queue[next_idx].pte;
}
// Clear the element at prev_tail. Set clk_hand to
// one entry to the left.
clk_queue[prev_tail].vpn = -1;
clk_hand = clk_hand == 0 ? CLOCKSIZE - 1
: clk_hand - 1;
}
// Initialize the clock queue to an empty state.
static void
clk_clear(void)
{
for (int i = 0; i < CLOCKSIZE; ++i)
clk_queue[i].vpn = -1;
clk_hand = -1;
}
// Print the clock queue in head->tail orderr, so starting
// from hand+1.
static void
clk_print(void)
{
int print_idx = clk_hand;
printf("CLK queue: | ");
for (int i = 0; i < CLOCKSIZE; ++i) {
print_idx = (print_idx + 1) % CLOCKSIZE;
if (clk_queue[print_idx].vpn != -1) {
printf("VPN %1X R %1d | ",
clk_queue[print_idx].vpn,
(*(clk_queue[print_idx].pte) & PTE_A) > 0);
}
}
printf("\n\n");
}
// Now, referencing a page (that triggered a page falt) means
// inserting this page into the clock queue, possibly evicting
// another.
static void
do_ref_page(int vpn, pte_t *pte)
{
printf("Ref page %1X\n", vpn);
if (*pte & PTE_P) {
*pte |= PTE_A; // mimick the HW setting ref bit
return; // if has PTE_P, hardware won't trigger page fault
}
clk_insert(vpn, pte);
*pte |= PTE_A; // mimick the HW setting ref bit
}
// Removing a page gets tricky and may involve shifting things
// in the queue.
static void
do_remove_page(int vpn)
{
printf("Remove page %1X\n", vpn);
clk_remove(vpn);
}
static inline void
wait_for_enter(void)
{
printf("Hit [Enter] to print...");
getchar();
}
int
main(void) {
// Mimick a pgtable.
// I omitted the physical frame number in the PTEs.
// A page starts with PTE_E set (encrypted), and so
// PTE_P is not set.
pte_t pgtable[12] = {0};
for (int i = 0; i < 12; ++i)
pgtable[i] |= PTE_E;
// Make sure a process initially has an empty clock queue.
clk_clear();
do_ref_page(0, &pgtable[0]);
do_ref_page(3, &pgtable[3]);
do_ref_page(1, &pgtable[1]);
do_ref_page(2, &pgtable[2]);
clk_print();
do_ref_page(9, &pgtable[9]);
do_ref_page(7, &pgtable[7]);
do_ref_page(4, &pgtable[4]);
do_ref_page(6, &pgtable[6]);
wait_for_enter();
clk_print();
do_ref_page(2, &pgtable[2]);
wait_for_enter();
clk_print();
do_ref_page(10, &pgtable[10]);
wait_for_enter();
clk_print();
do_ref_page(1, &pgtable[1]);
do_ref_page(2, &pgtable[2]);
do_ref_page(3, &pgtable[3]);
wait_for_enter();
clk_print();
do_ref_page(11, &pgtable[11]);
wait_for_enter();
clk_print();
do_remove_page(10);
do_remove_page(11);
wait_for_enter();
clk_print();
}
|
the_stack_data/139849.c | /* vim: tabstop=4 shiftwidth=4 noexpandtab
* This file is part of ToaruOS and is released under the terms
* of the NCSA / University of Illinois License - see LICENSE.md
* Copyright (C) 2014-2018 K. Lange
*
* mount
*
* Mount a filesystem.
*/
#include <stdio.h>
#include <errno.h>
#include <sys/mount.h>
int main(int argc, char ** argv) {
if (argc < 4) {
fprintf(stderr, "Usage: %s type device mountpoint\n", argv[0]);
return 1;
}
int ret = mount(argv[2], argv[3], argv[1], 0, NULL);
if (ret < 0) {
fprintf(stderr, "%s: %s\n", argv[0], strerror(errno));
return ret;
}
return 0;
}
|
the_stack_data/125141662.c | #include <stdlib.h>
int __attribute__((noinline)) sub(int a, int b)
{
return a - b;
}
int __attribute__((noinline)) foo(int a, int b)
{
if(a > b)
return sub(a, b);
else
return sub(b, a);
}
int main(void)
{
if(sub(8,5) != 3)
abort();
exit(0);
}
|
the_stack_data/863591.c | // RUN: %clang -target i386-unknown-linux -masm=intel -S %s -### 2>&1 | FileCheck --check-prefix=CHECK-INTEL %s
// RUN: %clang -target i386-unknown-linux -masm=att -S %s -### 2>&1 | FileCheck --check-prefix=CHECK-ATT %s
// RUN: %clang -target i386-unknown-linux -S -masm=somerequired %s -### 2>&1 | FileCheck --check-prefix=CHECK-SOMEREQUIRED %s
// RUN: %clang -target arm-unknown-eabi -S -masm=intel %s -### 2>&1 | FileCheck --check-prefix=CHECK-ARM %s
// RUN: %clang_cl --target=x86_64 /FA -### -- %s 2>&1 | FileCheck --check-prefix=CHECK-CL %s
int f() {
// CHECK-INTEL: -x86-asm-syntax=intel
// CHECK-INTEL: -inline-asm=intel
// CHECK-ATT: -x86-asm-syntax=att
// CHECK-ATT: -inline-asm=att
// CHECK-SOMEREQUIRED: error: unsupported argument 'somerequired' to option 'masm='
// CHECK-ARM: warning: argument unused during compilation: '-masm=intel'
// CHECK-CL: -x86-asm-syntax=intel
// CHECK-CL-NOT: -inline-asm=intel
return 0;
}
|
the_stack_data/757575.c | extern void __VERIFIER_error() __attribute__ ((__noreturn__));
void __VERIFIER_assert(int expression) { if (!expression) { ERROR: __VERIFIER_error(); }; return; }
int __global_lock;
void __VERIFIER_atomic_begin() { __VERIFIER_assume(__global_lock==0); __global_lock=1; return; }
void __VERIFIER_atomic_end() { __VERIFIER_assume(__global_lock==1); __global_lock=0; return; }
#include <assert.h>
#include <pthread.h>
#ifndef TRUE
#define TRUE (_Bool)1
#endif
#ifndef FALSE
#define FALSE (_Bool)0
#endif
#ifndef NULL
#define NULL ((void*)0)
#endif
#ifndef FENCE
#define FENCE(x) ((void)0)
#endif
#ifndef IEEE_FLOAT_EQUAL
#define IEEE_FLOAT_EQUAL(x,y) (x==y)
#endif
#ifndef IEEE_FLOAT_NOTEQUAL
#define IEEE_FLOAT_NOTEQUAL(x,y) (x!=y)
#endif
void * P0(void *arg);
void * P1(void *arg);
void fence();
void isync();
void lwfence();
int __unbuffered_cnt;
int __unbuffered_cnt = 0;
int __unbuffered_p1_EAX;
int __unbuffered_p1_EAX = 0;
int __unbuffered_p1_EBX;
int __unbuffered_p1_EBX = 0;
_Bool main$tmp_guard0;
_Bool main$tmp_guard1;
int x;
int x = 0;
_Bool x$flush_delayed;
int x$mem_tmp;
_Bool x$r_buff0_thd0;
_Bool x$r_buff0_thd1;
_Bool x$r_buff0_thd2;
_Bool x$r_buff1_thd0;
_Bool x$r_buff1_thd1;
_Bool x$r_buff1_thd2;
_Bool x$read_delayed;
int *x$read_delayed_var;
int x$w_buff0;
_Bool x$w_buff0_used;
int x$w_buff1;
_Bool x$w_buff1_used;
int y;
int y = 0;
int z;
int z = 0;
_Bool weak$$choice0;
_Bool weak$$choice2;
void * P0(void *arg)
{
__VERIFIER_atomic_begin();
x$w_buff1 = x$w_buff0;
x$w_buff0 = 1;
x$w_buff1_used = x$w_buff0_used;
x$w_buff0_used = TRUE;
__VERIFIER_assert(!(x$w_buff1_used && x$w_buff0_used));
x$r_buff1_thd0 = x$r_buff0_thd0;
x$r_buff1_thd1 = x$r_buff0_thd1;
x$r_buff1_thd2 = x$r_buff0_thd2;
x$r_buff0_thd1 = TRUE;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
y = 1;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
x = x$w_buff0_used && x$r_buff0_thd1 ? x$w_buff0 : (x$w_buff1_used && x$r_buff1_thd1 ? x$w_buff1 : x);
x$w_buff0_used = x$w_buff0_used && x$r_buff0_thd1 ? FALSE : x$w_buff0_used;
x$w_buff1_used = x$w_buff0_used && x$r_buff0_thd1 || x$w_buff1_used && x$r_buff1_thd1 ? FALSE : x$w_buff1_used;
x$r_buff0_thd1 = x$w_buff0_used && x$r_buff0_thd1 ? FALSE : x$r_buff0_thd1;
x$r_buff1_thd1 = x$w_buff0_used && x$r_buff0_thd1 || x$w_buff1_used && x$r_buff1_thd1 ? FALSE : x$r_buff1_thd1;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
__unbuffered_cnt = __unbuffered_cnt + 1;
__VERIFIER_atomic_end();
return nondet_0();
}
void * P1(void *arg)
{
__VERIFIER_atomic_begin();
y = 2;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
z = 1;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
__unbuffered_p1_EAX = z;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
weak$$choice0 = nondet_1();
weak$$choice2 = nondet_1();
x$flush_delayed = weak$$choice2;
x$mem_tmp = x;
x = !x$w_buff0_used || !x$r_buff0_thd2 && !x$w_buff1_used || !x$r_buff0_thd2 && !x$r_buff1_thd2 ? x : (x$w_buff0_used && x$r_buff0_thd2 ? x$w_buff0 : x$w_buff1);
x$w_buff0 = weak$$choice2 ? x$w_buff0 : (!x$w_buff0_used || !x$r_buff0_thd2 && !x$w_buff1_used || !x$r_buff0_thd2 && !x$r_buff1_thd2 ? x$w_buff0 : (x$w_buff0_used && x$r_buff0_thd2 ? x$w_buff0 : x$w_buff0));
x$w_buff1 = weak$$choice2 ? x$w_buff1 : (!x$w_buff0_used || !x$r_buff0_thd2 && !x$w_buff1_used || !x$r_buff0_thd2 && !x$r_buff1_thd2 ? x$w_buff1 : (x$w_buff0_used && x$r_buff0_thd2 ? x$w_buff1 : x$w_buff1));
x$w_buff0_used = weak$$choice2 ? x$w_buff0_used : (!x$w_buff0_used || !x$r_buff0_thd2 && !x$w_buff1_used || !x$r_buff0_thd2 && !x$r_buff1_thd2 ? x$w_buff0_used : (x$w_buff0_used && x$r_buff0_thd2 ? FALSE : x$w_buff0_used));
x$w_buff1_used = weak$$choice2 ? x$w_buff1_used : (!x$w_buff0_used || !x$r_buff0_thd2 && !x$w_buff1_used || !x$r_buff0_thd2 && !x$r_buff1_thd2 ? x$w_buff1_used : (x$w_buff0_used && x$r_buff0_thd2 ? FALSE : FALSE));
x$r_buff0_thd2 = weak$$choice2 ? x$r_buff0_thd2 : (!x$w_buff0_used || !x$r_buff0_thd2 && !x$w_buff1_used || !x$r_buff0_thd2 && !x$r_buff1_thd2 ? x$r_buff0_thd2 : (x$w_buff0_used && x$r_buff0_thd2 ? FALSE : x$r_buff0_thd2));
x$r_buff1_thd2 = weak$$choice2 ? x$r_buff1_thd2 : (!x$w_buff0_used || !x$r_buff0_thd2 && !x$w_buff1_used || !x$r_buff0_thd2 && !x$r_buff1_thd2 ? x$r_buff1_thd2 : (x$w_buff0_used && x$r_buff0_thd2 ? FALSE : FALSE));
__unbuffered_p1_EBX = x;
x = x$flush_delayed ? x$mem_tmp : x;
x$flush_delayed = FALSE;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
x = x$w_buff0_used && x$r_buff0_thd2 ? x$w_buff0 : (x$w_buff1_used && x$r_buff1_thd2 ? x$w_buff1 : x);
x$w_buff0_used = x$w_buff0_used && x$r_buff0_thd2 ? FALSE : x$w_buff0_used;
x$w_buff1_used = x$w_buff0_used && x$r_buff0_thd2 || x$w_buff1_used && x$r_buff1_thd2 ? FALSE : x$w_buff1_used;
x$r_buff0_thd2 = x$w_buff0_used && x$r_buff0_thd2 ? FALSE : x$r_buff0_thd2;
x$r_buff1_thd2 = x$w_buff0_used && x$r_buff0_thd2 || x$w_buff1_used && x$r_buff1_thd2 ? FALSE : x$r_buff1_thd2;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
__unbuffered_cnt = __unbuffered_cnt + 1;
__VERIFIER_atomic_end();
return nondet_0();
}
void fence()
{
}
void isync()
{
}
void lwfence()
{
}
int main()
{
pthread_create(NULL, NULL, P0, NULL);
pthread_create(NULL, NULL, P1, NULL);
__VERIFIER_atomic_begin();
main$tmp_guard0 = __unbuffered_cnt == 2;
__VERIFIER_atomic_end();
__VERIFIER_assume(main$tmp_guard0);
__VERIFIER_atomic_begin();
x = x$w_buff0_used && x$r_buff0_thd0 ? x$w_buff0 : (x$w_buff1_used && x$r_buff1_thd0 ? x$w_buff1 : x);
x$w_buff0_used = x$w_buff0_used && x$r_buff0_thd0 ? FALSE : x$w_buff0_used;
x$w_buff1_used = x$w_buff0_used && x$r_buff0_thd0 || x$w_buff1_used && x$r_buff1_thd0 ? FALSE : x$w_buff1_used;
x$r_buff0_thd0 = x$w_buff0_used && x$r_buff0_thd0 ? FALSE : x$r_buff0_thd0;
x$r_buff1_thd0 = x$w_buff0_used && x$r_buff0_thd0 || x$w_buff1_used && x$r_buff1_thd0 ? FALSE : x$r_buff1_thd0;
__VERIFIER_atomic_end();
__VERIFIER_atomic_begin();
/* Program proven to be relaxed for X86, model checker says YES. */
main$tmp_guard1 = !(y == 2 && __unbuffered_p1_EAX == 1 && __unbuffered_p1_EBX == 0);
__VERIFIER_atomic_end();
/* Program proven to be relaxed for X86, model checker says YES. */
__VERIFIER_assert(main$tmp_guard1);
return 0;
}
|
the_stack_data/517727.c | #include <stdio.h>
#include <math.h>
int main()
{
float a,b,c,x,x0,x1,x2;
printf("Equation: ax^2 + bx + c = 0\n"); /* Quadratic Equation ax^2 + bx + c = 0 */
printf("a =");
scanf("%f",&a); /* coefficient a */
printf("b =");
scanf("%f",&b); /* coefficient b */
printf("c =");
scanf("%f",&c); /* coefficient c */
printf("Enter first guess =");
scanf("%f",&x0); /* x0 (i.e. first guess) */
x = x0; /* x contains the first guess */
x1 = -c / ((a*x0) + b);
while (x0 != x1) {
x0 = x1; /* x_k is changed to x_k+1 */
x1 = -c / ((a*x0) + b); /* since x_k is changed x_k+1 is also changed untill x_k = x_k+1 */
}
printf("root1 = %f\n",x1); /* prints the first root */
x2 = (-c / (a*x)) -(b/a) ;
while (x != x2) {
x = x2; /* x_k is changed to x_k+1 */
x2 = (-c / (a*x)) -(b/a) ; /* since x_k is changed x_k+1 is also changed untill x_k = x_k+1 */
}
printf("root2 = %f\n",x2); /* prints the second root */
}
/*
K Pranav Bharadwaj
Roll no:17MCME06
IM.tech 3rd sem
*/
|
the_stack_data/17936.c | //===-- X86IntelInstPrinter.cpp - Intel assembly instruction printing -----===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file includes code for rendering MCInst instances as Intel-style
// assembly.
//
//===----------------------------------------------------------------------===//
/* Capstone Disassembly Engine */
/* By Nguyen Anh Quynh <[email protected]>, 2013-2015 */
#ifdef CAPSTONE_HAS_X86
#if defined (WIN32) || defined (WIN64) || defined (_WIN32) || defined (_WIN64)
#pragma warning(disable:4996) // disable MSVC's warning on strncpy()
#pragma warning(disable:28719) // disable MSVC's warning on strncpy()
#endif
#if !defined(CAPSTONE_HAS_OSXKERNEL)
#include <ctype.h>
#endif
#include <capstone/platform.h>
#if defined(CAPSTONE_HAS_OSXKERNEL)
#include <Availability.h>
#include <libkern/libkern.h>
#else
#include <stdio.h>
#include <stdlib.h>
#endif
#include <string.h>
#include "../../utils.h"
#include "../../MCInst.h"
#include "../../SStream.h"
#include "../../MCRegisterInfo.h"
#include "X86InstPrinter.h"
#include "X86Mapping.h"
#define GET_INSTRINFO_ENUM
#ifdef CAPSTONE_X86_REDUCE
#include "X86GenInstrInfo_reduce.inc"
#else
#include "X86GenInstrInfo.inc"
#endif
#include "X86BaseInfo.h"
static void printMemReference(MCInst *MI, unsigned Op, SStream *O);
static void printOperand(MCInst *MI, unsigned OpNo, SStream *O);
static void set_mem_access(MCInst *MI, bool status)
{
if (MI->csh->detail != CS_OPT_ON)
return;
MI->csh->doing_mem = status;
if (!status)
// done, create the next operand slot
MI->flat_insn->detail->x86.op_count++;
}
static void printopaquemem(MCInst *MI, unsigned OpNo, SStream *O)
{
// FIXME: do this with autogen
// printf(">>> ID = %u\n", MI->flat_insn->id);
switch(MI->flat_insn->id) {
default:
SStream_concat0(O, "ptr ");
break;
case X86_INS_SGDT:
case X86_INS_SIDT:
case X86_INS_LGDT:
case X86_INS_LIDT:
case X86_INS_FXRSTOR:
case X86_INS_FXSAVE:
case X86_INS_LJMP:
case X86_INS_LCALL:
// do not print "ptr"
break;
}
switch(MI->csh->mode) {
case CS_MODE_16:
switch(MI->flat_insn->id) {
default:
MI->x86opsize = 2;
break;
case X86_INS_LJMP:
case X86_INS_LCALL:
MI->x86opsize = 4;
break;
case X86_INS_SGDT:
case X86_INS_SIDT:
case X86_INS_LGDT:
case X86_INS_LIDT:
MI->x86opsize = 6;
break;
}
break;
case CS_MODE_32:
switch(MI->flat_insn->id) {
default:
MI->x86opsize = 4;
break;
case X86_INS_LJMP:
case X86_INS_LCALL:
case X86_INS_SGDT:
case X86_INS_SIDT:
case X86_INS_LGDT:
case X86_INS_LIDT:
MI->x86opsize = 6;
break;
}
break;
case CS_MODE_64:
switch(MI->flat_insn->id) {
default:
MI->x86opsize = 8;
break;
case X86_INS_LJMP:
case X86_INS_LCALL:
case X86_INS_SGDT:
case X86_INS_SIDT:
case X86_INS_LGDT:
case X86_INS_LIDT:
MI->x86opsize = 10;
break;
}
break;
default: // never reach
break;
}
printMemReference(MI, OpNo, O);
}
static void printi8mem(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "byte ptr ");
MI->x86opsize = 1;
printMemReference(MI, OpNo, O);
}
static void printi16mem(MCInst *MI, unsigned OpNo, SStream *O)
{
MI->x86opsize = 2;
SStream_concat0(O, "word ptr ");
printMemReference(MI, OpNo, O);
}
static void printi32mem(MCInst *MI, unsigned OpNo, SStream *O)
{
MI->x86opsize = 4;
SStream_concat0(O, "dword ptr ");
printMemReference(MI, OpNo, O);
}
static void printi64mem(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "qword ptr ");
MI->x86opsize = 8;
printMemReference(MI, OpNo, O);
}
static void printi128mem(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "xmmword ptr ");
MI->x86opsize = 16;
printMemReference(MI, OpNo, O);
}
#ifndef CAPSTONE_X86_REDUCE
static void printi256mem(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "ymmword ptr ");
MI->x86opsize = 32;
printMemReference(MI, OpNo, O);
}
static void printi512mem(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "zmmword ptr ");
MI->x86opsize = 64;
printMemReference(MI, OpNo, O);
}
static void printf32mem(MCInst *MI, unsigned OpNo, SStream *O)
{
switch(MCInst_getOpcode(MI)) {
default:
SStream_concat0(O, "dword ptr ");
MI->x86opsize = 4;
break;
case X86_FBSTPm:
case X86_FBLDm:
// TODO: fix this in tablegen instead
SStream_concat0(O, "tbyte ptr ");
MI->x86opsize = 10;
break;
case X86_FSTENVm:
case X86_FLDENVm:
// TODO: fix this in tablegen instead
switch(MI->csh->mode) {
default: // never reach
break;
case CS_MODE_16:
MI->x86opsize = 14;
break;
case CS_MODE_32:
case CS_MODE_64:
MI->x86opsize = 28;
break;
}
break;
}
printMemReference(MI, OpNo, O);
}
static void printf64mem(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "qword ptr ");
MI->x86opsize = 8;
printMemReference(MI, OpNo, O);
}
static void printf80mem(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "xword ptr ");
MI->x86opsize = 10;
printMemReference(MI, OpNo, O);
}
static void printf128mem(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "xmmword ptr ");
MI->x86opsize = 16;
printMemReference(MI, OpNo, O);
}
static void printf256mem(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "ymmword ptr ");
MI->x86opsize = 32;
printMemReference(MI, OpNo, O);
}
static void printf512mem(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "zmmword ptr ");
MI->x86opsize = 64;
printMemReference(MI, OpNo, O);
}
static void printSSECC(MCInst *MI, unsigned Op, SStream *OS)
{
uint8_t Imm = (uint8_t)(MCOperand_getImm(MCInst_getOperand(MI, Op)) & 7);
switch (Imm) {
default: break; // never reach
case 0: SStream_concat0(OS, "eq"); op_addSseCC(MI, X86_SSE_CC_EQ); break;
case 1: SStream_concat0(OS, "lt"); op_addSseCC(MI, X86_SSE_CC_LT); break;
case 2: SStream_concat0(OS, "le"); op_addSseCC(MI, X86_SSE_CC_LE); break;
case 3: SStream_concat0(OS, "unord"); op_addSseCC(MI, X86_SSE_CC_UNORD); break;
case 4: SStream_concat0(OS, "neq"); op_addSseCC(MI, X86_SSE_CC_NEQ); break;
case 5: SStream_concat0(OS, "nlt"); op_addSseCC(MI, X86_SSE_CC_NLT); break;
case 6: SStream_concat0(OS, "nle"); op_addSseCC(MI, X86_SSE_CC_NLE); break;
case 7: SStream_concat0(OS, "ord"); op_addSseCC(MI, X86_SSE_CC_ORD); break;
}
MI->popcode_adjust = Imm + 1;
}
static void printAVXCC(MCInst *MI, unsigned Op, SStream *O)
{
uint8_t Imm = (uint8_t)(MCOperand_getImm(MCInst_getOperand(MI, Op)) & 0x1f);
switch (Imm) {
default: break;//printf("Invalid avxcc argument!\n"); break;
case 0: SStream_concat0(O, "eq"); op_addAvxCC(MI, X86_AVX_CC_EQ); break;
case 1: SStream_concat0(O, "lt"); op_addAvxCC(MI, X86_AVX_CC_LT); break;
case 2: SStream_concat0(O, "le"); op_addAvxCC(MI, X86_AVX_CC_LE); break;
case 3: SStream_concat0(O, "unord"); op_addAvxCC(MI, X86_AVX_CC_UNORD); break;
case 4: SStream_concat0(O, "neq"); op_addAvxCC(MI, X86_AVX_CC_NEQ); break;
case 5: SStream_concat0(O, "nlt"); op_addAvxCC(MI, X86_AVX_CC_NLT); break;
case 6: SStream_concat0(O, "nle"); op_addAvxCC(MI, X86_AVX_CC_NLE); break;
case 7: SStream_concat0(O, "ord"); op_addAvxCC(MI, X86_AVX_CC_ORD); break;
case 8: SStream_concat0(O, "eq_uq"); op_addAvxCC(MI, X86_AVX_CC_EQ_UQ); break;
case 9: SStream_concat0(O, "nge"); op_addAvxCC(MI, X86_AVX_CC_NGE); break;
case 0xa: SStream_concat0(O, "ngt"); op_addAvxCC(MI, X86_AVX_CC_NGT); break;
case 0xb: SStream_concat0(O, "false"); op_addAvxCC(MI, X86_AVX_CC_FALSE); break;
case 0xc: SStream_concat0(O, "neq_oq"); op_addAvxCC(MI, X86_AVX_CC_NEQ_OQ); break;
case 0xd: SStream_concat0(O, "ge"); op_addAvxCC(MI, X86_AVX_CC_GE); break;
case 0xe: SStream_concat0(O, "gt"); op_addAvxCC(MI, X86_AVX_CC_GT); break;
case 0xf: SStream_concat0(O, "true"); op_addAvxCC(MI, X86_AVX_CC_TRUE); break;
case 0x10: SStream_concat0(O, "eq_os"); op_addAvxCC(MI, X86_AVX_CC_EQ_OS); break;
case 0x11: SStream_concat0(O, "lt_oq"); op_addAvxCC(MI, X86_AVX_CC_LT_OQ); break;
case 0x12: SStream_concat0(O, "le_oq"); op_addAvxCC(MI, X86_AVX_CC_LE_OQ); break;
case 0x13: SStream_concat0(O, "unord_s"); op_addAvxCC(MI, X86_AVX_CC_UNORD_S); break;
case 0x14: SStream_concat0(O, "neq_us"); op_addAvxCC(MI, X86_AVX_CC_NEQ_US); break;
case 0x15: SStream_concat0(O, "nlt_uq"); op_addAvxCC(MI, X86_AVX_CC_NLT_UQ); break;
case 0x16: SStream_concat0(O, "nle_uq"); op_addAvxCC(MI, X86_AVX_CC_NLE_UQ); break;
case 0x17: SStream_concat0(O, "ord_s"); op_addAvxCC(MI, X86_AVX_CC_ORD_S); break;
case 0x18: SStream_concat0(O, "eq_us"); op_addAvxCC(MI, X86_AVX_CC_EQ_US); break;
case 0x19: SStream_concat0(O, "nge_uq"); op_addAvxCC(MI, X86_AVX_CC_NGE_UQ); break;
case 0x1a: SStream_concat0(O, "ngt_uq"); op_addAvxCC(MI, X86_AVX_CC_NGT_UQ); break;
case 0x1b: SStream_concat0(O, "false_os"); op_addAvxCC(MI, X86_AVX_CC_FALSE_OS); break;
case 0x1c: SStream_concat0(O, "neq_os"); op_addAvxCC(MI, X86_AVX_CC_NEQ_OS); break;
case 0x1d: SStream_concat0(O, "ge_oq"); op_addAvxCC(MI, X86_AVX_CC_GE_OQ); break;
case 0x1e: SStream_concat0(O, "gt_oq"); op_addAvxCC(MI, X86_AVX_CC_GT_OQ); break;
case 0x1f: SStream_concat0(O, "true_us"); op_addAvxCC(MI, X86_AVX_CC_TRUE_US); break;
}
MI->popcode_adjust = Imm + 1;
}
static void printXOPCC(MCInst *MI, unsigned Op, SStream *O)
{
int64_t Imm = MCOperand_getImm(MCInst_getOperand(MI, Op));
switch (Imm) {
default: // llvm_unreachable("Invalid xopcc argument!");
case 0: SStream_concat0(O, "lt"); op_addXopCC(MI, X86_XOP_CC_LT); break;
case 1: SStream_concat0(O, "le"); op_addXopCC(MI, X86_XOP_CC_LE); break;
case 2: SStream_concat0(O, "gt"); op_addXopCC(MI, X86_XOP_CC_GT); break;
case 3: SStream_concat0(O, "ge"); op_addXopCC(MI, X86_XOP_CC_GE); break;
case 4: SStream_concat0(O, "eq"); op_addXopCC(MI, X86_XOP_CC_EQ); break;
case 5: SStream_concat0(O, "neq"); op_addXopCC(MI, X86_XOP_CC_NEQ); break;
case 6: SStream_concat0(O, "false"); op_addXopCC(MI, X86_XOP_CC_FALSE); break;
case 7: SStream_concat0(O, "true"); op_addXopCC(MI, X86_XOP_CC_TRUE); break;
}
}
static void printRoundingControl(MCInst *MI, unsigned Op, SStream *O)
{
int64_t Imm = MCOperand_getImm(MCInst_getOperand(MI, Op)) & 0x3;
switch (Imm) {
case 0: SStream_concat0(O, "{rn-sae}"); op_addAvxSae(MI); op_addAvxRoundingMode(MI, X86_AVX_RM_RN); break;
case 1: SStream_concat0(O, "{rd-sae}"); op_addAvxSae(MI); op_addAvxRoundingMode(MI, X86_AVX_RM_RD); break;
case 2: SStream_concat0(O, "{ru-sae}"); op_addAvxSae(MI); op_addAvxRoundingMode(MI, X86_AVX_RM_RU); break;
case 3: SStream_concat0(O, "{rz-sae}"); op_addAvxSae(MI); op_addAvxRoundingMode(MI, X86_AVX_RM_RZ); break;
default: break; // never reach
}
}
#endif
static const char *getRegisterName(unsigned RegNo);
static void printRegName(SStream *OS, unsigned RegNo)
{
SStream_concat0(OS, getRegisterName(RegNo));
}
// for MASM syntax, 0x123 = 123h, 0xA123 = 0A123h
// this function tell us if we need to have prefix 0 in front of a number
static bool need_zero_prefix(uint64_t imm)
{
// find the first hex letter representing imm
while(imm >= 0x10)
imm >>= 4;
if (imm < 0xa)
return false;
else // this need 0 prefix
return true;
}
static void printImm(MCInst *MI, SStream *O, int64_t imm, bool positive)
{
if (positive) {
// always print this number in positive form
if (MI->csh->syntax == CS_OPT_SYNTAX_MASM) {
if (imm < 0) {
if (MI->op1_size) {
switch(MI->op1_size) {
default:
break;
case 1:
imm &= 0xff;
break;
case 2:
imm &= 0xffff;
break;
case 4:
imm &= 0xffffffff;
break;
}
}
if (imm == 0x8000000000000000LL) // imm == -imm
SStream_concat0(O, "8000000000000000h");
else if (need_zero_prefix(imm))
SStream_concat(O, "0%"PRIx64"h", imm);
else
SStream_concat(O, "%"PRIx64"h", imm);
} else {
if (imm > HEX_THRESHOLD) {
if (need_zero_prefix(imm))
SStream_concat(O, "0%"PRIx64"h", imm);
else
SStream_concat(O, "%"PRIx64"h", imm);
} else
SStream_concat(O, "%"PRIu64, imm);
}
} else { // Intel syntax
if (imm < 0) {
if (MI->op1_size) {
switch(MI->op1_size) {
default:
break;
case 1:
imm &= 0xff;
break;
case 2:
imm &= 0xffff;
break;
case 4:
imm &= 0xffffffff;
break;
}
}
SStream_concat(O, "0x%"PRIx64, imm);
} else {
if (imm > HEX_THRESHOLD)
SStream_concat(O, "0x%"PRIx64, imm);
else
SStream_concat(O, "%"PRIu64, imm);
}
}
} else {
if (MI->csh->syntax == CS_OPT_SYNTAX_MASM) {
if (imm < 0) {
if (imm == 0x8000000000000000LL) // imm == -imm
SStream_concat0(O, "8000000000000000h");
else if (imm < -HEX_THRESHOLD) {
if (need_zero_prefix(imm))
SStream_concat(O, "-0%"PRIx64"h", -imm);
else
SStream_concat(O, "-%"PRIx64"h", -imm);
} else
SStream_concat(O, "-%"PRIu64, -imm);
} else {
if (imm > HEX_THRESHOLD) {
if (need_zero_prefix(imm))
SStream_concat(O, "0%"PRIx64"h", imm);
else
SStream_concat(O, "%"PRIx64"h", imm);
} else
SStream_concat(O, "%"PRIu64, imm);
}
} else { // Intel syntax
if (imm < 0) {
if (imm == 0x8000000000000000LL) // imm == -imm
SStream_concat0(O, "0x8000000000000000");
else if (imm < -HEX_THRESHOLD)
SStream_concat(O, "-0x%"PRIx64, -imm);
else
SStream_concat(O, "-%"PRIu64, -imm);
} else {
if (imm > HEX_THRESHOLD)
SStream_concat(O, "0x%"PRIx64, imm);
else
SStream_concat(O, "%"PRIu64, imm);
}
}
}
}
// local printOperand, without updating public operands
static void _printOperand(MCInst *MI, unsigned OpNo, SStream *O)
{
MCOperand *Op = MCInst_getOperand(MI, OpNo);
if (MCOperand_isReg(Op)) {
printRegName(O, MCOperand_getReg(Op));
} else if (MCOperand_isImm(Op)) {
int64_t imm = MCOperand_getImm(Op);
printImm(MI, O, imm, MI->csh->imm_unsigned);
}
}
#ifndef CAPSTONE_DIET
// copy & normalize access info
static void get_op_access(cs_struct *h, unsigned int id, uint8_t *access, uint64_t *eflags)
{
#ifndef CAPSTONE_DIET
uint8_t i;
uint8_t *arr = X86_get_op_access(h, id, eflags);
if (!arr) {
access[0] = 0;
return;
}
// copy to access but zero out CS_AC_IGNORE
for(i = 0; arr[i]; i++) {
if (arr[i] != CS_AC_IGNORE)
access[i] = arr[i];
else
access[i] = 0;
}
// mark the end of array
access[i] = 0;
#endif
}
#endif
static void printSrcIdx(MCInst *MI, unsigned Op, SStream *O)
{
MCOperand *SegReg;
int reg;
if (MI->csh->detail) {
#ifndef CAPSTONE_DIET
uint8_t access[6];
#endif
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_MEM;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->x86opsize;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = X86_REG_INVALID;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.base = X86_REG_INVALID;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.index = X86_REG_INVALID;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.scale = 1;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.disp = 0;
#ifndef CAPSTONE_DIET
get_op_access(MI->csh, MCInst_getOpcode(MI), access, &MI->flat_insn->detail->x86.eflags);
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].access = access[MI->flat_insn->detail->x86.op_count];
#endif
}
SegReg = MCInst_getOperand(MI, Op+1);
reg = MCOperand_getReg(SegReg);
// If this has a segment register, print it.
if (reg) {
_printOperand(MI, Op+1, O);
if (MI->csh->detail) {
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = reg;
}
SStream_concat0(O, ":");
}
SStream_concat0(O, "[");
set_mem_access(MI, true);
printOperand(MI, Op, O);
SStream_concat0(O, "]");
set_mem_access(MI, false);
}
static void printDstIdx(MCInst *MI, unsigned Op, SStream *O)
{
if (MI->csh->detail) {
#ifndef CAPSTONE_DIET
uint8_t access[6];
#endif
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_MEM;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->x86opsize;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = X86_REG_INVALID;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.base = X86_REG_INVALID;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.index = X86_REG_INVALID;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.scale = 1;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.disp = 0;
#ifndef CAPSTONE_DIET
get_op_access(MI->csh, MCInst_getOpcode(MI), access, &MI->flat_insn->detail->x86.eflags);
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].access = access[MI->flat_insn->detail->x86.op_count];
#endif
}
// DI accesses are always ES-based on non-64bit mode
if (MI->csh->mode != CS_MODE_64) {
SStream_concat(O, "es:[");
if (MI->csh->detail) {
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = X86_REG_ES;
}
} else
SStream_concat(O, "[");
set_mem_access(MI, true);
printOperand(MI, Op, O);
SStream_concat0(O, "]");
set_mem_access(MI, false);
}
static void printSrcIdx8(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "byte ptr ");
MI->x86opsize = 1;
printSrcIdx(MI, OpNo, O);
}
static void printSrcIdx16(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "word ptr ");
MI->x86opsize = 2;
printSrcIdx(MI, OpNo, O);
}
static void printSrcIdx32(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "dword ptr ");
MI->x86opsize = 4;
printSrcIdx(MI, OpNo, O);
}
static void printSrcIdx64(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "qword ptr ");
MI->x86opsize = 8;
printSrcIdx(MI, OpNo, O);
}
static void printDstIdx8(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "byte ptr ");
MI->x86opsize = 1;
printDstIdx(MI, OpNo, O);
}
static void printDstIdx16(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "word ptr ");
MI->x86opsize = 2;
printDstIdx(MI, OpNo, O);
}
static void printDstIdx32(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "dword ptr ");
MI->x86opsize = 4;
printDstIdx(MI, OpNo, O);
}
static void printDstIdx64(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "qword ptr ");
MI->x86opsize = 8;
printDstIdx(MI, OpNo, O);
}
static void printMemOffset(MCInst *MI, unsigned Op, SStream *O)
{
MCOperand *DispSpec = MCInst_getOperand(MI, Op);
MCOperand *SegReg = MCInst_getOperand(MI, Op + 1);
int reg;
if (MI->csh->detail) {
#ifndef CAPSTONE_DIET
uint8_t access[6];
#endif
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_MEM;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->x86opsize;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = X86_REG_INVALID;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.base = X86_REG_INVALID;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.index = X86_REG_INVALID;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.scale = 1;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.disp = 0;
#ifndef CAPSTONE_DIET
get_op_access(MI->csh, MCInst_getOpcode(MI), access, &MI->flat_insn->detail->x86.eflags);
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].access = access[MI->flat_insn->detail->x86.op_count];
#endif
}
// If this has a segment register, print it.
reg = MCOperand_getReg(SegReg);
if (reg) {
_printOperand(MI, Op + 1, O);
SStream_concat0(O, ":");
if (MI->csh->detail) {
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = reg;
}
}
SStream_concat0(O, "[");
if (MCOperand_isImm(DispSpec)) {
int64_t imm = MCOperand_getImm(DispSpec);
if (MI->csh->detail)
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.disp = imm;
if (imm < 0)
printImm(MI, O, arch_masks[MI->csh->mode] & imm, true);
else
printImm(MI, O, imm, true);
}
SStream_concat0(O, "]");
if (MI->csh->detail)
MI->flat_insn->detail->x86.op_count++;
if (MI->op1_size == 0)
MI->op1_size = MI->x86opsize;
}
#ifndef CAPSTONE_X86_REDUCE
static void printU8Imm(MCInst *MI, unsigned Op, SStream *O)
{
uint8_t val = MCOperand_getImm(MCInst_getOperand(MI, Op)) & 0xff;
printImm(MI, O, val, true);
if (MI->csh->detail) {
#ifndef CAPSTONE_DIET
uint8_t access[6];
#endif
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_IMM;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].imm = val;
#ifndef CAPSTONE_DIET
get_op_access(MI->csh, MCInst_getOpcode(MI), access, &MI->flat_insn->detail->x86.eflags);
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].access = access[MI->flat_insn->detail->x86.op_count];
#endif
MI->flat_insn->detail->x86.op_count++;
}
}
#endif
static void printMemOffs8(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "byte ptr ");
MI->x86opsize = 1;
printMemOffset(MI, OpNo, O);
}
static void printMemOffs16(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "word ptr ");
MI->x86opsize = 2;
printMemOffset(MI, OpNo, O);
}
static void printMemOffs32(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "dword ptr ");
MI->x86opsize = 4;
printMemOffset(MI, OpNo, O);
}
static void printMemOffs64(MCInst *MI, unsigned OpNo, SStream *O)
{
SStream_concat0(O, "qword ptr ");
MI->x86opsize = 8;
printMemOffset(MI, OpNo, O);
}
#ifndef CAPSTONE_DIET
static char *printAliasInstr(MCInst *MI, SStream *OS, void *info);
#endif
static void printInstruction(MCInst *MI, SStream *O, MCRegisterInfo *MRI);
void X86_Intel_printInst(MCInst *MI, SStream *O, void *Info)
{
#ifndef CAPSTONE_DIET
char *mnem;
#endif
x86_reg reg, reg2;
enum cs_ac_type access1, access2;
// perhaps this instruction does not need printer
if (MI->assembly[0]) {
strncpy(O->buffer, MI->assembly, sizeof(O->buffer));
return;
}
#ifndef CAPSTONE_DIET
// Try to print any aliases first.
mnem = printAliasInstr(MI, O, Info);
if (mnem)
cs_mem_free(mnem);
else
#endif
printInstruction(MI, O, Info);
reg = X86_insn_reg_intel(MCInst_getOpcode(MI), &access1);
if (MI->csh->detail) {
#ifndef CAPSTONE_DIET
uint8_t access[6] = {0};
#endif
// first op can be embedded in the asm by llvm.
// so we have to add the missing register as the first operand
if (reg) {
// shift all the ops right to leave 1st slot for this new register op
memmove(&(MI->flat_insn->detail->x86.operands[1]), &(MI->flat_insn->detail->x86.operands[0]),
sizeof(MI->flat_insn->detail->x86.operands[0]) * (ARR_SIZE(MI->flat_insn->detail->x86.operands) - 1));
MI->flat_insn->detail->x86.operands[0].type = X86_OP_REG;
MI->flat_insn->detail->x86.operands[0].reg = reg;
MI->flat_insn->detail->x86.operands[0].size = MI->csh->regsize_map[reg];
MI->flat_insn->detail->x86.operands[0].access = access1;
MI->flat_insn->detail->x86.op_count++;
} else {
if (X86_insn_reg_intel2(MCInst_getOpcode(MI), ®, &access1, ®2, &access2)) {
MI->flat_insn->detail->x86.operands[0].type = X86_OP_REG;
MI->flat_insn->detail->x86.operands[0].reg = reg;
MI->flat_insn->detail->x86.operands[0].size = MI->csh->regsize_map[reg];
MI->flat_insn->detail->x86.operands[0].access = access1;
MI->flat_insn->detail->x86.operands[1].type = X86_OP_REG;
MI->flat_insn->detail->x86.operands[1].reg = reg2;
MI->flat_insn->detail->x86.operands[1].size = MI->csh->regsize_map[reg2];
MI->flat_insn->detail->x86.operands[1].access = access2;
MI->flat_insn->detail->x86.op_count = 2;
}
}
#ifndef CAPSTONE_DIET
get_op_access(MI->csh, MCInst_getOpcode(MI), access, &MI->flat_insn->detail->x86.eflags);
MI->flat_insn->detail->x86.operands[0].access = access[0];
MI->flat_insn->detail->x86.operands[1].access = access[1];
#endif
}
if (MI->op1_size == 0 && reg)
MI->op1_size = MI->csh->regsize_map[reg];
}
/// printPCRelImm - This is used to print an immediate value that ends up
/// being encoded as a pc-relative value.
static void printPCRelImm(MCInst *MI, unsigned OpNo, SStream *O)
{
MCOperand *Op = MCInst_getOperand(MI, OpNo);
if (MCOperand_isImm(Op)) {
int64_t imm = MCOperand_getImm(Op) + MI->flat_insn->size + MI->address;
uint8_t opsize = X86_immediate_size(MI->Opcode, NULL);
// truncat imm for non-64bit
if (MI->csh->mode != CS_MODE_64) {
imm = imm & 0xffffffff;
}
if (MI->csh->mode == CS_MODE_16 &&
(MI->Opcode != X86_JMP_4 && MI->Opcode != X86_CALLpcrel32))
imm = imm & 0xffff;
// Hack: X86 16bit with opcode X86_JMP_4
if (MI->csh->mode == CS_MODE_16 &&
(MI->Opcode == X86_JMP_4 && MI->x86_prefix[2] != 0x66))
imm = imm & 0xffff;
// CALL/JMP rel16 is special
if (MI->Opcode == X86_CALLpcrel16 || MI->Opcode == X86_JMP_2)
imm = imm & 0xffff;
printImm(MI, O, imm, true);
if (MI->csh->detail) {
#ifndef CAPSTONE_DIET
uint8_t access[6];
#endif
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_IMM;
// if op_count > 0, then this operand's size is taken from the destination op
if (MI->flat_insn->detail->x86.op_count > 0)
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->flat_insn->detail->x86.operands[0].size;
else if (opsize > 0)
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = opsize;
else
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->imm_size;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].imm = imm;
#ifndef CAPSTONE_DIET
get_op_access(MI->csh, MCInst_getOpcode(MI), access, &MI->flat_insn->detail->x86.eflags);
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].access = access[MI->flat_insn->detail->x86.op_count];
#endif
MI->flat_insn->detail->x86.op_count++;
}
if (MI->op1_size == 0)
MI->op1_size = MI->imm_size;
}
}
static void printOperand(MCInst *MI, unsigned OpNo, SStream *O)
{
MCOperand *Op = MCInst_getOperand(MI, OpNo);
if (MCOperand_isReg(Op)) {
unsigned int reg = MCOperand_getReg(Op);
printRegName(O, reg);
if (MI->csh->detail) {
if (MI->csh->doing_mem) {
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.base = reg;
} else {
#ifndef CAPSTONE_DIET
uint8_t access[6];
#endif
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_REG;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].reg = reg;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->csh->regsize_map[reg];
#ifndef CAPSTONE_DIET
get_op_access(MI->csh, MCInst_getOpcode(MI), access, &MI->flat_insn->detail->x86.eflags);
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].access = access[MI->flat_insn->detail->x86.op_count];
#endif
MI->flat_insn->detail->x86.op_count++;
}
}
if (MI->op1_size == 0)
MI->op1_size = MI->csh->regsize_map[reg];
} else if (MCOperand_isImm(Op)) {
uint8_t encsize;
int64_t imm = MCOperand_getImm(Op);
uint8_t opsize = X86_immediate_size(MCInst_getOpcode(MI), &encsize);
if (opsize == 1) // print 1 byte immediate in positive form
imm = imm & 0xff;
// printf(">>> id = %u\n", MI->flat_insn->id);
switch(MI->flat_insn->id) {
default:
printImm(MI, O, imm, MI->csh->imm_unsigned);
break;
case X86_INS_MOVABS:
// do not print number in negative form
printImm(MI, O, imm, true);
break;
case X86_INS_IN:
case X86_INS_OUT:
case X86_INS_INT:
// do not print number in negative form
imm = imm & 0xff;
printImm(MI, O, imm, true);
break;
case X86_INS_LCALL:
case X86_INS_LJMP:
// always print address in positive form
if (OpNo == 1) { // ptr16 part
imm = imm & 0xffff;
opsize = 2;
}
printImm(MI, O, imm, true);
break;
case X86_INS_AND:
case X86_INS_OR:
case X86_INS_XOR:
// do not print number in negative form
if (imm >= 0 && imm <= HEX_THRESHOLD)
printImm(MI, O, imm, true);
else {
imm = arch_masks[opsize? opsize : MI->imm_size] & imm;
printImm(MI, O, imm, true);
}
break;
case X86_INS_RET:
case X86_INS_RETF:
// RET imm16
if (imm >= 0 && imm <= HEX_THRESHOLD)
printImm(MI, O, imm, true);
else {
imm = 0xffff & imm;
printImm(MI, O, imm, true);
}
break;
}
if (MI->csh->detail) {
if (MI->csh->doing_mem) {
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.disp = imm;
} else {
#ifndef CAPSTONE_DIET
uint8_t access[6];
#endif
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_IMM;
if (opsize > 0) {
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = opsize;
MI->flat_insn->detail->x86.encoding.imm_size = encsize;
} else if (MI->flat_insn->detail->x86.op_count > 0) {
if (MI->flat_insn->id != X86_INS_LCALL && MI->flat_insn->id != X86_INS_LJMP) {
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size =
MI->flat_insn->detail->x86.operands[0].size;
} else
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->imm_size;
} else
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->imm_size;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].imm = imm;
#ifndef CAPSTONE_DIET
get_op_access(MI->csh, MCInst_getOpcode(MI), access, &MI->flat_insn->detail->x86.eflags);
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].access = access[MI->flat_insn->detail->x86.op_count];
#endif
MI->flat_insn->detail->x86.op_count++;
}
}
}
}
static void printMemReference(MCInst *MI, unsigned Op, SStream *O)
{
bool NeedPlus = false;
MCOperand *BaseReg = MCInst_getOperand(MI, Op + X86_AddrBaseReg);
uint64_t ScaleVal = MCOperand_getImm(MCInst_getOperand(MI, Op + X86_AddrScaleAmt));
MCOperand *IndexReg = MCInst_getOperand(MI, Op + X86_AddrIndexReg);
MCOperand *DispSpec = MCInst_getOperand(MI, Op + X86_AddrDisp);
MCOperand *SegReg = MCInst_getOperand(MI, Op + X86_AddrSegmentReg);
int reg;
if (MI->csh->detail) {
#ifndef CAPSTONE_DIET
uint8_t access[6];
#endif
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_MEM;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->x86opsize;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = X86_REG_INVALID;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.base = MCOperand_getReg(BaseReg);
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.index = MCOperand_getReg(IndexReg);
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.scale = (int)ScaleVal;
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.disp = 0;
#ifndef CAPSTONE_DIET
get_op_access(MI->csh, MCInst_getOpcode(MI), access, &MI->flat_insn->detail->x86.eflags);
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].access = access[MI->flat_insn->detail->x86.op_count];
#endif
}
// If this has a segment register, print it.
reg = MCOperand_getReg(SegReg);
if (reg) {
_printOperand(MI, Op + X86_AddrSegmentReg, O);
if (MI->csh->detail) {
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = reg;
}
SStream_concat0(O, ":");
}
SStream_concat0(O, "[");
if (MCOperand_getReg(BaseReg)) {
_printOperand(MI, Op + X86_AddrBaseReg, O);
NeedPlus = true;
}
if (MCOperand_getReg(IndexReg)) {
if (NeedPlus) SStream_concat0(O, " + ");
_printOperand(MI, Op + X86_AddrIndexReg, O);
if (ScaleVal != 1)
SStream_concat(O, "*%u", ScaleVal);
NeedPlus = true;
}
if (MCOperand_isImm(DispSpec)) {
int64_t DispVal = MCOperand_getImm(DispSpec);
if (MI->csh->detail)
MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.disp = DispVal;
if (DispVal) {
if (NeedPlus) {
if (DispVal < 0) {
SStream_concat0(O, " - ");
printImm(MI, O, -DispVal, true);
} else {
SStream_concat0(O, " + ");
printImm(MI, O, DispVal, true);
}
} else {
// memory reference to an immediate address
if (DispVal < 0) {
printImm(MI, O, arch_masks[MI->csh->mode] & DispVal, true);
} else {
printImm(MI, O, DispVal, true);
}
}
} else {
// DispVal = 0
if (!NeedPlus) // [0]
SStream_concat0(O, "0");
}
}
SStream_concat0(O, "]");
if (MI->csh->detail)
MI->flat_insn->detail->x86.op_count++;
if (MI->op1_size == 0)
MI->op1_size = MI->x86opsize;
}
static void printanymem(MCInst *MI, unsigned OpNo, SStream *O)
{
switch(MI->Opcode) {
default: break;
case X86_LEA16r:
MI->x86opsize = 2;
break;
case X86_LEA32r:
case X86_LEA64_32r:
MI->x86opsize = 4;
break;
case X86_LEA64r:
MI->x86opsize = 8;
break;
}
printMemReference(MI, OpNo, O);
}
#define GET_REGINFO_ENUM
#include "X86GenRegisterInfo.inc"
#define PRINT_ALIAS_INSTR
#ifdef CAPSTONE_X86_REDUCE
#include "X86GenAsmWriter1_reduce.inc"
#else
#include "X86GenAsmWriter1.inc"
#endif
#endif
|
the_stack_data/154830164.c | int add_two(int x, int y){
return x + y;
}
|
the_stack_data/93887230.c | /***************************************************************************/
/*
** UNECM - Decoder for ECM (Error Code Modeler) format.
** Version 1.0
** Copyright (C) 2002 Neill Corlett
**
** This program is free software; you can redistribute it and/or
** modify it under the terms of the GNU General Public License
** as published by the Free Software Foundation; either version 2
** of the License, or (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/***************************************************************************/
/*
** Portability notes:
**
** - Assumes a 32-bit or higher integer size
** - No assumptions about byte order
** - No assumptions about struct packing
** - No unaligned memory access
*/
/***************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/***************************************************************************/
void banner(void) {
fprintf(stderr,
"UNECM - Decoder for Error Code Modeler format v1.0\n"
"Copyright (C) 2002 Neill Corlett\n\n"
);
}
/***************************************************************************/
/* Data types */
#define ecc_uint8 unsigned char
#define ecc_uint16 unsigned short
#define ecc_uint32 unsigned
/* LUTs used for computing ECC/EDC */
static ecc_uint8 ecc_f_lut[256];
static ecc_uint8 ecc_b_lut[256];
static ecc_uint32 edc_lut[256];
/* Init routine */
static void eccedc_init(void) {
ecc_uint32 i, j, edc;
for(i = 0; i < 256; i++) {
j = (i << 1) ^ (i & 0x80 ? 0x11D : 0);
ecc_f_lut[i] = j;
ecc_b_lut[i ^ j] = i;
edc = i;
for(j = 0; j < 8; j++) edc = (edc >> 1) ^ (edc & 1 ? 0xD8018001 : 0);
edc_lut[i] = edc;
}
}
/***************************************************************************/
/*
** Compute EDC for a block
*/
ecc_uint32 edc_partial_computeblock(
ecc_uint32 edc,
const ecc_uint8 *src,
ecc_uint16 size
) {
while(size--) edc = (edc >> 8) ^ edc_lut[(edc ^ (*src++)) & 0xFF];
return edc;
}
void edc_computeblock(
const ecc_uint8 *src,
ecc_uint16 size,
ecc_uint8 *dest
) {
ecc_uint32 edc = edc_partial_computeblock(0, src, size);
dest[0] = (edc >> 0) & 0xFF;
dest[1] = (edc >> 8) & 0xFF;
dest[2] = (edc >> 16) & 0xFF;
dest[3] = (edc >> 24) & 0xFF;
}
/***************************************************************************/
/*
** Compute ECC for a block (can do either P or Q)
*/
static void ecc_computeblock(
ecc_uint8 *src,
ecc_uint32 major_count,
ecc_uint32 minor_count,
ecc_uint32 major_mult,
ecc_uint32 minor_inc,
ecc_uint8 *dest
) {
ecc_uint32 size = major_count * minor_count;
ecc_uint32 major, minor;
for(major = 0; major < major_count; major++) {
ecc_uint32 index = (major >> 1) * major_mult + (major & 1);
ecc_uint8 ecc_a = 0;
ecc_uint8 ecc_b = 0;
for(minor = 0; minor < minor_count; minor++) {
ecc_uint8 temp = src[index];
index += minor_inc;
if(index >= size) index -= size;
ecc_a ^= temp;
ecc_b ^= temp;
ecc_a = ecc_f_lut[ecc_a];
}
ecc_a = ecc_b_lut[ecc_f_lut[ecc_a] ^ ecc_b];
dest[major ] = ecc_a;
dest[major + major_count] = ecc_a ^ ecc_b;
}
}
/*
** Generate ECC P and Q codes for a block
*/
static void ecc_generate(
ecc_uint8 *sector,
int zeroaddress
) {
ecc_uint8 address[4], i;
/* Save the address and zero it out */
if(zeroaddress) for(i = 0; i < 4; i++) {
address[i] = sector[12 + i];
sector[12 + i] = 0;
}
/* Compute ECC P code */
ecc_computeblock(sector + 0xC, 86, 24, 2, 86, sector + 0x81C);
/* Compute ECC Q code */
ecc_computeblock(sector + 0xC, 52, 43, 86, 88, sector + 0x8C8);
/* Restore the address */
if(zeroaddress) for(i = 0; i < 4; i++) sector[12 + i] = address[i];
}
/***************************************************************************/
/*
** Generate ECC/EDC information for a sector (must be 2352 = 0x930 bytes)
** Returns 0 on success
*/
void eccedc_generate(ecc_uint8 *sector, int type) {
ecc_uint32 i;
switch(type) {
case 1: /* Mode 1 */
/* Compute EDC */
edc_computeblock(sector + 0x00, 0x810, sector + 0x810);
/* Write out zero bytes */
for(i = 0; i < 8; i++) sector[0x814 + i] = 0;
/* Generate ECC P/Q codes */
ecc_generate(sector, 0);
break;
case 2: /* Mode 2 form 1 */
/* Compute EDC */
edc_computeblock(sector + 0x10, 0x808, sector + 0x818);
/* Generate ECC P/Q codes */
ecc_generate(sector, 1);
break;
case 3: /* Mode 2 form 2 */
/* Compute EDC */
edc_computeblock(sector + 0x10, 0x91C, sector + 0x92C);
break;
}
}
/***************************************************************************/
unsigned mycounter;
unsigned mycounter_total;
void resetcounter(unsigned total) {
mycounter = 0;
mycounter_total = total;
}
void setcounter(unsigned n) {
if((n >> 20) != (mycounter >> 20)) {
unsigned a = (n+64)/128;
unsigned d = (mycounter_total+64)/128;
if(!d) d = 1;
fprintf(stderr, "Decoding (%02d%%)\r", (100*a) / d);
}
mycounter = n;
}
int unecmify(
FILE *in,
FILE *out
) {
unsigned checkedc = 0;
unsigned char sector[2352];
unsigned type;
unsigned num;
fseek(in, 0, SEEK_END);
resetcounter(ftell(in));
fseek(in, 0, SEEK_SET);
if(
(fgetc(in) != 'E') ||
(fgetc(in) != 'C') ||
(fgetc(in) != 'M') ||
(fgetc(in) != 0x00)
) {
fprintf(stderr, "Header not found!\n");
goto corrupt;
}
for(;;) {
int c = fgetc(in);
int bits = 5;
if(c == EOF) goto uneof;
type = c & 3;
num = (c >> 2) & 0x1F;
while(c & 0x80) {
c = fgetc(in);
if(c == EOF) goto uneof;
num |= ((unsigned)(c & 0x7F)) << bits;
bits += 7;
}
if(num == 0xFFFFFFFF) break;
num++;
if(num >= 0x80000000) goto corrupt;
if(!type) {
while(num) {
int b = num;
if(b > 2352) b = 2352;
if(fread(sector, 1, b, in) != b) goto uneof;
checkedc = edc_partial_computeblock(checkedc, sector, b);
fwrite(sector, 1, b, out);
num -= b;
setcounter(ftell(in));
}
} else {
while(num--) {
memset(sector, 0, sizeof(sector));
memset(sector + 1, 0xFF, 10);
switch(type) {
case 1:
sector[0x0F] = 0x01;
if(fread(sector + 0x00C, 1, 0x003, in) != 0x003) goto uneof;
if(fread(sector + 0x010, 1, 0x800, in) != 0x800) goto uneof;
eccedc_generate(sector, 1);
checkedc = edc_partial_computeblock(checkedc, sector, 2352);
fwrite(sector, 2352, 1, out);
setcounter(ftell(in));
break;
case 2:
sector[0x0F] = 0x02;
if(fread(sector + 0x014, 1, 0x804, in) != 0x804) goto uneof;
sector[0x10] = sector[0x14];
sector[0x11] = sector[0x15];
sector[0x12] = sector[0x16];
sector[0x13] = sector[0x17];
eccedc_generate(sector, 2);
checkedc = edc_partial_computeblock(checkedc, sector + 0x10, 2336);
fwrite(sector + 0x10, 2336, 1, out);
setcounter(ftell(in));
break;
case 3:
sector[0x0F] = 0x02;
if(fread(sector + 0x014, 1, 0x918, in) != 0x918) goto uneof;
sector[0x10] = sector[0x14];
sector[0x11] = sector[0x15];
sector[0x12] = sector[0x16];
sector[0x13] = sector[0x17];
eccedc_generate(sector, 3);
checkedc = edc_partial_computeblock(checkedc, sector + 0x10, 2336);
fwrite(sector + 0x10, 2336, 1, out);
setcounter(ftell(in));
break;
}
}
}
}
if(fread(sector, 1, 4, in) != 4) goto uneof;
fprintf(stderr, "Decoded %ld bytes -> %ld bytes\n", ftell(in), ftell(out));
if(
(sector[0] != ((checkedc >> 0) & 0xFF)) ||
(sector[1] != ((checkedc >> 8) & 0xFF)) ||
(sector[2] != ((checkedc >> 16) & 0xFF)) ||
(sector[3] != ((checkedc >> 24) & 0xFF))
) {
fprintf(stderr, "EDC error (%08X, should be %02X%02X%02X%02X)\n",
checkedc,
sector[3],
sector[2],
sector[1],
sector[0]
);
goto corrupt;
}
fprintf(stderr, "Done; file is OK\n");
return 0;
uneof:
fprintf(stderr, "Unexpected EOF!\n");
corrupt:
fprintf(stderr, "Corrupt ECM file!\n");
return 1;
}
/***************************************************************************/
int main(int argc, char **argv) {
FILE *fin, *fout;
char *infilename;
char *outfilename;
banner();
/*
** Initialize the ECC/EDC tables
*/
eccedc_init();
/*
** Check command line
*/
if((argc != 2) && (argc != 3)) {
fprintf(stderr, "usage: %s ecmfile [outputfile]\n", argv[0]);
return 1;
}
/*
** Verify that the input filename is valid
*/
infilename = argv[1];
if(strlen(infilename) < 5) {
fprintf(stderr, "filename '%s' is too short\n", infilename);
return 1;
}
if(strcasecmp(infilename + strlen(infilename) - 4, ".ecm")) {
fprintf(stderr, "filename must end in .ecm\n");
return 1;
}
/*
** Figure out what the output filename should be
*/
if(argc == 3) {
outfilename = argv[2];
} else {
outfilename = malloc(strlen(infilename) - 3);
if(!outfilename) abort();
memcpy(outfilename, infilename, strlen(infilename) - 4);
outfilename[strlen(infilename) - 4] = 0;
}
fprintf(stderr, "Decoding %s to %s.\n", infilename, outfilename);
/*
** Open both files
*/
fin = fopen(infilename, "rb");
if(!fin) {
perror(infilename);
return 1;
}
fout = fopen(outfilename, "wb");
if(!fout) {
perror(outfilename);
fclose(fin);
return 1;
}
/*
** Decode
*/
unecmify(fin, fout);
/*
** Close everything
*/
fclose(fout);
fclose(fin);
return 0;
}
|
the_stack_data/187642059.c | #include <stdio.h>
int main(void) {
printf("Hello !\n");
return 0;
}
|
the_stack_data/242329895.c | /*BEGIN_LEGAL
Intel Open Source License
Copyright (c) 2002-2015 Intel Corporation. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer. Redistributions
in binary form must reproduce the above copyright notice, this list of
conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution. Neither the name of
the Intel Corporation nor the names of its contributors may be used to
endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR
ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
END_LEGAL */
// This little application tests calling application functions.
//
#include <stdio.h>
#include <limits.h>
#if defined (TARGET_WINDOWS)
#define EXPORT_SYM __declspec( dllexport )
#define FAST_CALL __fastcall
#define STD_CALL __stdcall
#else
#define EXPORT_SYM extern
#define FAST_CALL
#define STD_CALL
#endif
EXPORT_SYM void Bar()
{
printf(" Hello from Bar!\n ");
}
EXPORT_SYM void Blue()
{
printf(" Hello from Blue!\n");
}
EXPORT_SYM void Bar1( int one )
{
printf(" Hello from Bar1: one = %d!\n ", one );
}
EXPORT_SYM int Bar2( int one, int two )
{
printf(" Hello from Bar2: one = %d, two = %d!\n ", one, two );
return one+two;
}
EXPORT_SYM long Bar3( long one, long two )
{
printf(" Hello from Bar3: one = %d, two = %d!\n ", one, two );
return one+two;
}
EXPORT_SYM void Blue1( int one )
{
printf(" Hello from Blue1: one = %d!\n ", one );
}
EXPORT_SYM int Blue2( int one, int two )
{
printf(" Hello from Blue2: one = %d, two = %d!\n ", one, two );
return one+two;
}
EXPORT_SYM long Blue3( long one, long two )
{
printf(" Hello from Blue3: one = %d, two = %d!\n ", one, two );
return one+two;
}
EXPORT_SYM int Blue6( int one, int two )
{
printf("Hello from Blue6: one = %d, two = %d!\n ", one, two );
return one+two;
}
EXPORT_SYM int Bar6( int one, int two )
{
int sum=0;
printf(" Hello from Bar6: one = %d, two = %d!\n ", one, two );
sum = Blue6( one, two );
return sum;
}
EXPORT_SYM int Blue7( int one, int two );
EXPORT_SYM int Bar7( int one, int two, int stop )
{
int sum=0;
if ( stop == 0 )
{
printf(" Bar7: once\n" );
sum = Blue7( one, two );
}
else
{
printf(" Bar7: twice\n" );
sum = one+two;
}
return sum;
}
EXPORT_SYM int Blue7( int one, int two )
{
int sum = 0;
printf(" Blue7: once\n" );
sum = Bar7( one, two, 1 );
printf(" Blue7: twice\n" );
return sum;
}
EXPORT_SYM int Bar8( int one, int two, int stop )
{
int sum=0;
if ( stop == 0 )
{
printf(" Bar8: once\n" );
sum = Bar8( one, two, 1 );
}
else if ( stop == 1 )
{
printf(" Bar8: twice\n" );
sum = Bar8( one, two, 2 );
}
else
{
printf(" Bar8: thrice\n" );
sum = one+two;
}
return sum;
}
EXPORT_SYM int Bar10( int one, int two, int three, int four, int five,
int six, int seven, int eight, int nine, int zero )
{
int sum=0;
printf(" Hello from Bar10: one = %d, two = %d\n ", one, two );
printf(" three = %d, four = %d, five = %d, six = %d\n ", three, four, five, six );
printf(" seven = %d, eight = %d, nine = %d, zero = %d\n ", seven, eight, nine, zero );
sum = one + two + three + four + five + six + seven + eight + nine + zero;
printf(" sum = %d\n", sum );
return sum;
}
EXPORT_SYM int Blue10( int one, int two, int three, int four, int five,
int six, int seven, int eight, int nine, int zero )
{
int sum=0;
printf(" Hello from Blue10: one = %d, two = %d\n ", one, two );
printf(" three = %d, four = %d, five = %d, six = %d\n ", three, four, five, six );
printf(" seven = %d, eight = %d, nine = %d, zero = %d\n ", seven, eight, nine, zero );
sum = one + two + three + four + five + six + seven + eight + nine + zero;
printf(" sum = %d\n", sum );
return sum;
}
#if defined (TARGET_WINDOWS) && defined (TARGET_IA32)
extern __declspec( dllexport ) int FAST_CALL FastBar10(
int one, int two, int three, int four, int five,
int six, int seven, int eight, int nine, int zero )
{
int sum;
printf(" Hello from FastBar10: one = %d, two = %d\n ", one, two );
printf(" three = %d, four = %d, five = %d, six = %d\n ", three, four, five, six );
printf(" seven = %d, eight = %d, nine = %d, zero = %d\n ", seven, eight, nine, zero );
sum = one + two + three + four + five + six + seven + eight + nine + zero;
printf(" sum = %d\n", sum );
return sum;
}
extern __declspec( dllexport ) int FAST_CALL FastBlue10(
int one, int two, int three, int four, int five,
int six, int seven, int eight, int nine, int zero )
{
int sum=0;
printf(" Hello from FastBlue10: one = %d, two = %d\n ", one, two );
printf(" three = %d, four = %d, five = %d, six = %d\n ", three, four, five, six );
printf(" seven = %d, eight = %d, nine = %d, zero = %d\n ", seven, eight, nine, zero );
sum = one + two + three + four + five + six + seven + eight + nine + zero;
printf(" sum = %d\n", sum );
return sum;
}
extern __declspec( dllexport ) int STD_CALL StdBar10(
int one, int two, int three, int four, int five,
int six, int seven, int eight, int nine, int zero )
{
int sum;
printf(" Hello from StdBar10: one = %d, two = %d\n ", one, two );
printf(" three = %d, four = %d, five = %d, six = %d\n ", three, four, five, six );
printf(" seven = %d, eight = %d, nine = %d, zero = %d\n ", seven, eight, nine, zero );
sum = one + two + three + four + five + six + seven + eight + nine + zero;
printf(" sum = %d\n", sum );
return sum;
}
extern __declspec( dllexport ) int STD_CALL StdBlue10(
int one, int two, int three, int four, int five,
int six, int seven, int eight, int nine, int zero )
{
int sum=0;
printf(" Hello from StdBlue10: one = %d, two = %d\n ", one, two );
printf(" three = %d, four = %d, five = %d, six = %d\n ", three, four, five, six );
printf(" seven = %d, eight = %d, nine = %d, zero = %d\n ", seven, eight, nine, zero );
sum = one + two + three + four + five + six + seven + eight + nine + zero;
printf(" sum = %d\n", sum );
return sum;
}
#endif
EXPORT_SYM char Bar12( int i1, int i2, unsigned int ui1,
signed char c1, signed char c2, unsigned char uc1,
int i3, int i4, unsigned int ui2,
signed char c3, signed char c4, unsigned char uc2 )
{
printf(" Hello from Bar12: \n");
printf(" i1 = %d, i2 = %d, ui1 = %d\n ", i1, i2, ui1 );
printf(" c1 = %c, c2 = %c, uc1 = %c\n ", c1, c2, uc1 );
printf(" i3 = %d, i4 = %d, ui2 = %d\n ", i3, i4, ui2 );
printf(" c1 = %c, c2 = %c, uc1 = %c\n ", c3, c4, uc2 );
return '1';
}
EXPORT_SYM char Green12( int i1, int i2, unsigned int ui1,
signed char c1, signed char c2, unsigned char uc1,
int i3, int i4, unsigned int ui2,
signed char c3, signed char c4, unsigned char uc2 )
{
printf(" Green12: ");
if ( i1 == INT_MIN &&
i2 == INT_MAX &&
ui1 == UINT_MAX &&
c1 == SCHAR_MIN &&
c2 == SCHAR_MAX &&
uc1 == UCHAR_MAX &&
i3 == INT_MIN &&
i4 == INT_MAX &&
ui2 == UINT_MAX &&
c3 == SCHAR_MIN &&
c4 == SCHAR_MAX &&
uc2 == UCHAR_MAX )
{
printf(" Test passed\n" );
return '1';
}
else
{
printf(" Test failed\n" );
if ( i1 != INT_MIN )
printf (" i1 != INT_MIN\n");
if ( i2 != INT_MAX )
printf(" i1 != INT_MIN\n");
if ( ui1 != UINT_MAX )
printf(" ui1 != UINT_MAX\n");
if ( c1 != SCHAR_MIN )
printf(" c1 != SCHAR_MIN\n");
if ( c2 != SCHAR_MAX )
printf(" c2 != SCHAR_MAX\n");
if ( uc1 != UCHAR_MAX )
printf(" uc1 == UCHAR_MAX\n");
if ( i3 != INT_MIN )
printf(" i3 != INT_MIN\n");
if ( i4 != INT_MAX )
printf(" i4 != INT_MAX\n");
if ( ui2 != UINT_MAX )
printf(" ui2 != UINT_MAX\n");
if ( c3 != SCHAR_MIN )
printf(" c3 != SCHAR_MIN\n");
if ( c4 != SCHAR_MAX )
printf(" c4 != SCHAR_MAX\n");
if ( uc2 != UCHAR_MAX )
printf(" uc2 != UCHAR_MAX\n");
}
return '1';
}
|
the_stack_data/60238.c | #include<stdio.h>
int N(int,int);
int M(int,int);
int H(int,int);
int max(int,int);
int min(int,int);
int a[10001]={0};
int n;
int main()
{
int K;
int l[101]={0};
int r[101]={0};
int i=0;
scanf("%d%d",&n,&K);
while(i<n)
{
scanf(" %d",&a[i]);
i++;
}
i=0;
while(i<K)
{
scanf(" %d%d",&l[i],&r[i]);
i++;
}
i=0;
while(i<K)
{
printf("%d\n",H(min(N(l[i],r[i]),M(l[i],r[i])),max(N(l[i],r[i]),M(l[i],r[i]))));
i++;
}
return 0;
}
int N(int x,int y)
{
int jieguo=0;
int j;
j=x;
while(j<=y)
{
jieguo=jieguo+a[j]%n;
j++;
}
jieguo=jieguo%n;
return jieguo;
}
int M(int x,int y)
{
int jieguo=1;
int j;
j=x;
while(j<=y)
{
jieguo=jieguo*a[j]%n;
j++;
}
jieguo=jieguo%n;
return jieguo;
}
int H(int x,int y)
{
int jieguo;
int j;
j=x+1;
jieguo=a[x];
while(j<=y)
{
jieguo=jieguo^a[j];
j++;
}
return jieguo;
}
int max(int x,int y)
{
if(x<y)
{
return y;
}
else
return x;
}
int min(int x ,int y)
{
if(x<y)
{
return x;
}
else
return y;
} |
the_stack_data/107951707.c | #include <stdio.h>
//Pretvoranje od dekaden vo bilo koja osnova <= 9, rekurzivno
int BaseN(int dec, int base)
{
static int b = 0;
if(dec == 0) return 0;
BaseN(dec/base, base);
b = b * 10 + dec % base;
return b;
}
int main(void)
{
printf("%d", BaseN(79, 7));
}
|
the_stack_data/126905.c | /*
* Copyright (c) 2019 volpol, Urban Wallasch <[email protected]>
*
* Licensed under the terms of the 0BSD ("Zero-clause BSD") license.
* See LICENSE file for details.
*
* Changes 2019 by irrwahn:
* - renamed wsp.c to riffx.c
* - replaced mkdir_p with mkdirp
* - refactoring, reformatting
* - some minor changes and optimizations
*
* Traverse input file(s) and dump anything that looks remotely like a
* RIFF data stream into separate output files, named using extracted
* labels, if applicable. Useful e.g. for extracting audio streams from
* game files like Borderlands2 *.pck.
*
* NOTE: The extracted raw RIFF streams most likely will need some form
* of post-processing to be useful. E.g. for the Audiokinetic Wwise
* RIFF/RIFX sound format you should:
*
* 1. Run each dumped file through the ww2ogg converter.
* [ See https://github.com/hcs64/ww2ogg ]
*
* 2. Fix up the resulting Ogg vorbis file with revorb.
* [ See https://github.com/jonboydell/revorb-nix ]
*
* Porting:
*
* - Replace open/mmap/creat/write with functions from stdio (fopen,
* fread, fwrite) while taking extra care of splitting on buffer
* boundaries.
*
* - Port mkdirp.
*
*/
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#define LOG(...) fprintf(stderr, __VA_ARGS__)
/* mkdirp
* Create a directory and missing parents.
*/
static inline int mkdirp(const char *pathname, mode_t mode) {
if (!pathname || !*pathname) {
errno = ENOENT;
return -1;
}
int err = 0;
char *p;
char path[strlen(pathname) + 1];
struct stat sb;
if (stat(pathname, &sb) == 0 && S_ISDIR(sb.st_mode))
return 0;
mode |= S_IRWXU;
strcpy(path, pathname);
p = path + 1;
do {
p = strchr(p, '/');
if (p)
*p = '\0';
if (stat(path, &sb) != 0 || !S_ISDIR(sb.st_mode))
err = mkdir(path, mode);
if (p)
*p++ = '/';
} while (!err && p && *p);
return err;
}
/* mem_mem
* Locate needle of length nlen in haystack of length hlen.
* Returns a pointer to the first occurrence of needle in haystack, or
* haystack for a needle of zero length, or NULL if needle was not found
* in haystack.
*
* Uses the Boyer-Moore-Horspool search algorithm, see
* https://en.wikipedia.org/wiki/Boyer–Moore–Horspool_algorithm
*
* For our tiny needles and non-pathologic haystacks this borders on
* overkill, but meh.
*/
static inline void *mem_mem(const void *haystack, size_t hlen,
const void *needle, size_t nlen) {
size_t k, skip[256];
const uint8_t *hst = (const uint8_t *)haystack;
const uint8_t *ndl = (const uint8_t *)needle;
if (nlen == 0)
return (void *)haystack;
/* Set up the finite state machine we use. */
for (k = 0; k < 256; ++k)
skip[k] = nlen;
for (k = 0; k < nlen - 1; ++k)
skip[ndl[k]] = nlen - k - 1;
/* Do the search. */
for (k = nlen - 1; k < hlen; k += skip[hst[k]]) {
int i, j;
for (j = nlen - 1, i = k; j >= 0 && hst[i] == ndl[j]; j--)
i--;
if (j == -1)
return (void *)(hst + i + 1);
}
return NULL;
}
/*
* use_basename:
* 0: retain directory structure: a/b/foo.in -> output/a/b/foo/042.riff
* 1: create flat output directory: a/b/foo.in -> output/001_foo_042.riff
*
* use_label:
* 0: create output filename from stream index number only
* 1: scan for label in stream and use it for output filename
*
* guess_length:
* 0: read the stream length from the RIFF header size field
* 1: assume the stream ends at the beginning of the next (or EOF)
*/
static struct {
int use_basename;
int use_label;
int guess_length;
int verbose;
int endianess; /* No cmd line option for this, we figure it out. */
} cfg = {
0,
0,
0,
0,
0,
};
static inline void usage(const char *argv0) {
LOG("Usage: %s [-b] [-g] [-l] [-v] infile ... [outdir]\n"
" -b : create flat output directory\n"
" -g : ignore size fields, guess stream length (imprecise!)\n"
" -l : use extracted labels in filenames (unreliable!)\n"
" -v : be more verbose\n"
, argv0);
exit(EXIT_FAILURE);
}
static inline int config(int argc, char *argv[]) {
int opt;
while ((opt = getopt(argc, argv, "+:bglv")) != -1) {
switch (opt) {
case 'b':
cfg.use_basename = 1;
break;
case 'g':
cfg.guess_length = 1;
break;
case 'l':
cfg.use_label = 1;
break;
case 'v':
cfg.verbose = 1;
break;
default: /* '?' || ':' */
usage(argv[0]);
break;
}
}
return optind;
}
static inline uint32_t get_ui32(const void *p) {
const uint8_t *b = p;
if (!cfg.endianess) /* Little Endian byte order (RIFF) */
return b[0] | b[1] << 8 | b[2] << 16 | b[3] << 24;
/* Big Endian byte order (RIFX) */
return b[3] | b[2] << 8 | b[1] << 16 | b[0] << 24;
}
/*
* Try to find a suitable "labl" chunk.
* We should really parse the RIFF structure. Instead, we are satisfied
* with the first null-terminated label string with length > 0.
*/
static inline const char *labl(const void *p, size_t len) {
static char lab[201] = "";
const uint8_t *b;
size_t l, ll;
*lab = '\0';
b = p;
l = len;
while (l > 8 && NULL != (b = mem_mem(b, l, "labl", 4))) {
b += 4; /* skip 'labl' */
l = len - (b - (uint8_t *)p);
ll = get_ui32(b);
if (ll > l - 4)
ll = l - 4;
/* The label we want? 200 is a magic number, 6 isn't (ID + 1 + '\0').
* We want it null terminated and start with a printable character! */
if (ll <= 200 && ll >= 6 && isprint(b[8]) && b[ll+4-1] == '\0') {
strcpy(lab, (const char *)(b + 8)); /* skip label size and ID */
break;
}
}
/* Sanitize label */
for (char *p = lab; *p; ++p) {
if (!isprint((unsigned char)*p) || strchr("/\\ ", *p))
*p = '_';
}
return lab;
}
/*
* Dump RIFF stream.
* Write a data blob of length len starting at b to a file whose name is
* constructed from prefix, an optional label, a numeric id and a suffix.
*/
static inline int dump(const char *prefix, size_t id, const void *b, size_t len) {
int fd;
const char *suffix[] = {"riff", "rifx"}; /* dump filename suffix */
char of[strlen(prefix) + 255];
const char *lab;
/* Construct file name from prefix and label or id: */
lab = cfg.use_label ? labl(b, len) : "";
snprintf(of, sizeof of, "%s%s%s%06zu.%s",
prefix, lab, *lab?"_":"", id, suffix[cfg.endianess]);
if (cfg.verbose)
LOG(": %8zu -> %s\n", len, of);
/* Caveat: This will overwrite any existing file with the same name! */
fd = creat(of, 0644);
if (0 > fd){
LOG("Failed to create %s: %s\n", of, strerror(errno));
return -1;
} else {
write(fd, b, len);
close(fd);
}
return 0;
}
/*
* Traverse file fd and dump anything that looks like a RIFF stream.
*/
int extract(int fd, const char *pfx) {
const char *RIF_[] = {"RIFF", "RIFX"};
size_t id, rsize;
off_t fsize, remsize;
const uint8_t *riff, *mfile;
fsize = lseek(fd, 0, SEEK_END);
lseek(fd, 0, SEEK_SET);
mfile = mmap(NULL, fsize, PROT_READ, MAP_PRIVATE, fd, 0);
if (mfile == MAP_FAILED) {
LOG("mmap failed: %s\n", strerror(errno));
return -1;
}
id = 0;
/* Where there's no RIFF, there might be a RIFX ... */
for (cfg.endianess = 0; cfg.endianess < 2; ++cfg.endianess )
if (NULL != (riff = mem_mem(mfile, fsize, RIF_[cfg.endianess], 4)))
break;
if (!riff) /* ... or nothing at all. */
return 0;
remsize = fsize - (riff - mfile);
while (remsize > 8 && NULL != riff) {
const uint8_t *next;
next = mem_mem(riff + 4, remsize - 4, RIF_[cfg.endianess], 4);
/* Read length info or guess stream length: */
if (cfg.guess_length) {
rsize = next ? next - riff : remsize;
}
else {
rsize = get_ui32(riff + 4) + 8; /* size + 'RIFF' + uint32 */
if ((off_t)rsize > remsize)
rsize = remsize;
}
/* Dump RIFF stream: */
LOG("%sEntry %5zu", cfg.verbose?"":"\r", id);
dump(pfx, id, riff, rsize);
/* Skip to next segment: */
++id;
riff = next;
remsize = riff ? fsize - (riff - mfile) : 0;
}
munmap((void *)mfile, fsize);
return id;
}
int main(int argc, char *argv[]) {
int i, total, argidx = 1;
const char *odir;
struct stat st;
argidx = config(argc, argv);
if (argc - argidx < 1)
usage(argv[0]);
/* If the last argument does not designate an existing file, we
* attempt to interpret it as the name of the output directory: */
if (0 != stat(argv[argc - 1], &st) || S_ISDIR(st.st_mode)) {
odir = argv[--argc];
if (argc - argidx < 1)
usage(argv[0]);
}
else
odir = "output";
LOG("Using \"%s\" as output directory\n", odir);
i = stat(odir, &st);
if (0 != i) {
LOG("Creating \"%s\"\n", odir);
mkdirp(odir, 0755);
i = stat(odir, &st);
}
if (0 != i || !S_ISDIR(st.st_mode)) {
LOG("%s is not a valid output directory\n", odir);
exit(EXIT_FAILURE);
}
/* Loop over remaining arguments as input files: */
for (total = 0, i = argidx; i < argc; i++) {
int fd, cnt, n;
char fpfx[PATH_MAX], tfn[PATH_MAX], *x;
fd = -1;
if (0 == stat(argv[i], &st)) {
if (S_ISREG(st.st_mode))
fd = open(argv[i], O_RDONLY);
else
errno = ENOTSUP;
}
if (fd < 0){
LOG("Skipping %s (failed to open: %s)\n", argv[i], strerror(errno));
continue;
}
LOG("Processing %s\n", argv[i]);
strcpy(tfn, argv[i]);
if ( NULL != (x = strrchr(tfn, '.')))
*x = 0;
if (cfg.use_basename) {
x = strrchr(tfn, '/');
x = x ? x + 1 : tfn;
n = snprintf(fpfx, sizeof fpfx, "%s/%03d_%s_", odir, i - argidx, x);
}
else {
n = snprintf(fpfx, sizeof fpfx, "%s/%s/", odir, tfn);
}
if ( (size_t)n >= sizeof fpfx ) {
LOG("output directory path truncated: '%s'\n", fpfx);
exit(EXIT_FAILURE);
}
if (!cfg.use_basename)
mkdirp(fpfx, 0755);
LOG("Dumping to %s...\n", fpfx);
cnt = extract(fd, fpfx);
close(fd);
LOG("%sDumped %d entries \n", cfg.verbose?"":"\r", cnt);
total += cnt;
}
LOG("\rDumped a total of %d entries.\n", total);
exit(EXIT_SUCCESS);
}
|
the_stack_data/1130096.c | int main() {
#pragma omp sections
{
}
#pragma omp sections
{
#pragma omp section
{
int x;
}
}
#pragma omp sections
{
#pragma omp section
{
}
#pragma omp section
{
}
}
#pragma omp sections
{
#pragma omp section
{
}
}
#pragma omp sections
{
#pragma omp section
{
int x;
}
#pragma omp section
{
}
#pragma omp section
{
int x;
}
}
#pragma omp sections
{
#pragma omp section
{
int x;
}
#pragma omp section
{
int x;
}
}
}
|
the_stack_data/211081028.c | /*
Write a TCP concurrent client server program where server accepts integer array
from client and sorts it and returns it to the client along with process id.
*/
// TCP client side
#include <unistd.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <string.h>
#include <sys/socket.h>
#define MAX 5
#define PORT 10200
#define SA struct sockaddr
void clifunc(int sockfd)
{
int buff[MAX];
int n;
bzero(buff, sizeof(buff));
printf("Enter the array : ");
for(int i=0;i<MAX;i++) scanf("%d",&buff[i]);
n = 0;
n=write(sockfd, buff, sizeof(buff));
if(n==sizeof(buff))
{
printf("Sent array succesfully:\n");
}
bzero(buff, sizeof(buff));
n=read(sockfd, buff, sizeof(buff));
if(n==sizeof(buff))
{
printf("Received sorted array succesfully:");
for(int i=0;i<MAX;i++) printf("%d ",buff[i]);
}
}
int main()
{
int sockfd, connfd;
struct sockaddr_in servaddr, cli;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == -1) {
printf("socket creation failed...\n");
exit(0);
}
else
printf("Socket successfully created..\n");
bzero(&servaddr, sizeof(servaddr));
// assign IP, PORT
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(PORT);
// connect the client socket to server socket
if (connect(sockfd, (SA*)&servaddr, sizeof(servaddr)) != 0) {
printf("connection with the server failed...\n");
exit(0);
}
else
printf("connected to the server..\n");
// function for client
clifunc(sockfd);
// close the socket
close(sockfd);
} |
the_stack_data/145452828.c |
void foo() { }
|
the_stack_data/92324967.c | #include<stdio.h>
int main()
{
int n,a,b;
n=0;
a=0;
b=0;
scanf ("%d", &n);
do
{
scanf ("%d", &a);
if (a<=0)
b=b+1;
n=n-1;
}
while (n!=0);
printf("%d\n", b);
return 0;
}
|
the_stack_data/126703213.c | #include <ctype.h>
#include <stdbool.h>
#include <stdlib.h>
long long atoll(const char* str)
{
long long val = 0;
bool neg = false;
while(isspace(*str))
{
str++;
}
switch(*str)
{
case '-':
neg = true;
// Intentional fallthrough
case '+':
str++;
default:
// Intentional fallthrough
;
}
while(isdigit(*str))
{
val = (10 * val) + (*str++ - '0');
}
return neg ? -val : val;
}
|
the_stack_data/100140905.c | /****************************************************************************
* Copyright 2020 Thomas E. Dickey *
* Copyright 1998-2014,2016 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
* "Software"), to deal in the Software without restriction, including *
* without limitation the rights to use, copy, modify, merge, publish, *
* distribute, distribute with modifications, sublicense, and/or sell *
* copies of the Software, and to permit persons to whom the Software is *
* furnished to do so, subject to the following conditions: *
* *
* The above copyright notice and this permission notice shall be included *
* in all copies or substantial portions of the Software. *
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS *
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF *
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. *
* IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR *
* THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
* *
* Except as contained in this notice, the name(s) of the above copyright *
* holders shall not be used in advertising or otherwise to promote the *
* sale, use or other dealings in this Software without prior written *
* authorization. *
****************************************************************************/
/****************************************************************************
* Author: Juergen Pfeifer, 1996 *
* and: Thomas E. Dickey, 1998 *
* and: Nicolas Boulenguez, 2011 *
****************************************************************************/
/*
Version Control
$Id: gen.c,v 1.77 2020/08/16 18:05:05 tom Exp $
--------------------------------------------------------------------------*/
/*
This program prints on its standard output the source for the
Terminal_Interface.Curses_Constants Ada package specification. This pure
package only exports C constants to the Ada compiler.
*/
#ifdef HAVE_CONFIG_H
#include <ncurses_cfg.h>
#else
#include <ncurses.h>
#endif
#include <stdlib.h>
#include <string.h>
#include <menu.h>
#include <form.h>
#undef UCHAR
#undef UINT
#undef ULONG
typedef unsigned char UCHAR;
typedef unsigned int UINT;
typedef unsigned long ULONG;
/* These global variables will be set by main () */
static int little_endian;
static const char *my_program_invocation_name = NULL;
static void
my_error(const char *message)
{
fprintf(stderr, "%s: %s\n", my_program_invocation_name, message);
exit(EXIT_FAILURE);
}
static void
print_constant(FILE * fp,
const char *name,
UINT value)
{
fprintf(fp, " %-28s : constant := %u;\n", name, value);
}
static void
print_long_val(FILE * fp,
const char *name,
long value)
{
fprintf(fp, " %-28s : constant := %ld;\n", name, value);
}
static void
print_size_of(FILE * fp,
const char *name,
size_t value)
{
fprintf(fp, " %-28s : constant := %lu;\n", name, value);
}
#define PRINT_NAMED_CONSTANT(name) \
print_long_val (fp, #name, name)
static void
print_comment(FILE * fp, const char *message)
{
fprintf(fp, "\n -- %s\n\n", message);
}
/*
* Make sure that KEY_MIN and KEY_MAX are defined.
* main () will protest if KEY_MIN == 256
*/
#ifndef KEY_MAX
# define KEY_MAX 0777
#endif
#ifndef KEY_MIN
# define KEY_MIN 0401
#endif
static UCHAR
bit_is_set(const UCHAR * const data,
const UINT offset)
{
const UCHAR byte = data[offset >> 3];
UINT bit;
if (little_endian)
bit = offset; /* offset */
else /* or */
bit = ~offset; /* 7 - offset */
bit &= 7; /* modulo 8 */
return (UCHAR) (byte & (1 << bit));
}
/* Find lowest and highest used offset in a byte array. */
/* Returns 0 if and only if all bits are unset. */
static int
find_pos(const UCHAR * const data,
const UINT sizeof_data,
UINT * const low,
UINT * const high)
{
const UINT last = (sizeof_data << 3) - 1;
UINT offset;
for (offset = last; !bit_is_set(data, offset); offset--)
if (!offset) /* All bits are 0. */
return 0;
*high = offset;
for (offset = 0; !bit_is_set(data, offset); offset++)
{
}
*low = offset;
return -1;
}
#define PRINT_BITMASK(c_type, ada_name, mask_macro) \
{ \
UINT first, last; \
c_type mask = (mask_macro); \
if (!find_pos ((UCHAR *)&mask, sizeof (mask), &first, &last)) \
my_error ("failed to locate " ada_name); \
print_constant (fp, ada_name "_First", first); \
print_constant (fp, ada_name "_Last", last); \
}
#define PRINT_NAMED_BITMASK(c_type, mask_macro) \
PRINT_BITMASK (c_type, #mask_macro, mask_macro)
#define STRUCT_OFFSET(record, field) \
{ \
UINT first, last; \
record mask; \
memset (&mask, 0, sizeof (mask)); \
memset (&mask.field, 0xff, sizeof(mask.field)); \
if (!find_pos ((UCHAR *)&mask, sizeof (mask), &first, &last)) \
my_error ("failed to locate" #record "_" #field); \
print_constant (fp, #record "_" #field "_First", first); \
print_constant (fp, #record "_" #field "_Last", last); \
}
/*--------------------*/
/* Start of main (). */
/*--------------------*/
int
main(int argc, const char *argv[])
{
FILE *fp = 0;
const int x = 0x12345678;
little_endian = (*((const char *)&x) == 0x78);
my_program_invocation_name = argv[0];
if (KEY_MIN == 256)
my_error("unexpected value for KEY_MIN: 256");
if (argc == 3)
{
fp = fopen(argv[2], "wb");
}
else if (argc == 2)
{
fp = stdout;
}
else
{
my_error("Only one or two arguments expected (DFT_ARG_SUFFIX)");
}
if ((strlen(argv[0]) + strlen(__FILE__)) > 25)
{
fprintf(fp, "-- Generated by the C program %.40s.\n",
my_program_invocation_name);
}
else
{
fprintf(fp, "-- Generated by the C program %s (source %s).\n",
my_program_invocation_name,
__FILE__);
}
fprintf(fp, "-- Do not edit this file directly.\n");
fprintf(fp, "-- The values provided here may vary on your system.\n");
fprintf(fp, "\n");
fprintf(fp, "with System;\n");
fprintf(fp, "package Terminal_Interface.Curses_Constants is\n");
fprintf(fp, " pragma Pure;\n");
fprintf(fp, "\n");
fprintf(fp, " DFT_ARG_SUFFIX : constant String := \"%s\";\n", argv[1]);
fprintf(fp,
" Bit_Order : constant System.Bit_Order := System.%s_Order_First;\n",
little_endian ? "Low" : "High");
print_size_of(fp, "Sizeof_Bool", 8 * sizeof(bool));
PRINT_NAMED_CONSTANT(OK);
PRINT_NAMED_CONSTANT(ERR);
fprintf(fp,
" pragma Warnings (Off); -- redefinition of Standard.True and False\n");
PRINT_NAMED_CONSTANT(TRUE);
PRINT_NAMED_CONSTANT(FALSE);
fprintf(fp, " pragma Warnings (On);\n");
print_comment(fp, "Version of the ncurses library from extensions(3NCURSES)");
PRINT_NAMED_CONSTANT(NCURSES_VERSION_MAJOR);
PRINT_NAMED_CONSTANT(NCURSES_VERSION_MINOR);
fprintf(fp, " Version : constant String := \"%d.%d\";\n",
NCURSES_VERSION_MAJOR, NCURSES_VERSION_MINOR);
print_comment(fp, "Character non-color attributes from attr(3NCURSES)");
fprintf(fp, " -- attr_t and chtype may be signed in C.\n");
fprintf(fp, " type attr_t is mod 2 ** %lu;\n", (long unsigned)(8 * sizeof(attr_t)));
PRINT_NAMED_BITMASK(attr_t, A_CHARTEXT);
PRINT_NAMED_BITMASK(attr_t, A_COLOR);
PRINT_BITMASK(attr_t, "Attr", A_ATTRIBUTES & ~A_COLOR);
PRINT_NAMED_BITMASK(attr_t, A_STANDOUT);
PRINT_NAMED_BITMASK(attr_t, A_UNDERLINE);
PRINT_NAMED_BITMASK(attr_t, A_REVERSE);
PRINT_NAMED_BITMASK(attr_t, A_BLINK);
PRINT_NAMED_BITMASK(attr_t, A_DIM);
PRINT_NAMED_BITMASK(attr_t, A_BOLD);
PRINT_NAMED_BITMASK(attr_t, A_PROTECT);
PRINT_NAMED_BITMASK(attr_t, A_INVIS);
PRINT_NAMED_BITMASK(attr_t, A_ALTCHARSET);
PRINT_NAMED_BITMASK(attr_t, A_HORIZONTAL);
PRINT_NAMED_BITMASK(attr_t, A_LEFT);
PRINT_NAMED_BITMASK(attr_t, A_LOW);
PRINT_NAMED_BITMASK(attr_t, A_RIGHT);
PRINT_NAMED_BITMASK(attr_t, A_TOP);
PRINT_NAMED_BITMASK(attr_t, A_VERTICAL);
print_size_of(fp, "chtype_Size", 8 * sizeof(chtype));
print_comment(fp, "predefined color numbers from color(3NCURSES)");
PRINT_NAMED_CONSTANT(COLOR_BLACK);
PRINT_NAMED_CONSTANT(COLOR_RED);
PRINT_NAMED_CONSTANT(COLOR_GREEN);
PRINT_NAMED_CONSTANT(COLOR_YELLOW);
PRINT_NAMED_CONSTANT(COLOR_BLUE);
PRINT_NAMED_CONSTANT(COLOR_MAGENTA);
PRINT_NAMED_CONSTANT(COLOR_CYAN);
PRINT_NAMED_CONSTANT(COLOR_WHITE);
print_comment(fp, "ETI return codes from ncurses.h");
PRINT_NAMED_CONSTANT(E_OK);
PRINT_NAMED_CONSTANT(E_SYSTEM_ERROR);
PRINT_NAMED_CONSTANT(E_BAD_ARGUMENT);
PRINT_NAMED_CONSTANT(E_POSTED);
PRINT_NAMED_CONSTANT(E_CONNECTED);
PRINT_NAMED_CONSTANT(E_BAD_STATE);
PRINT_NAMED_CONSTANT(E_NO_ROOM);
PRINT_NAMED_CONSTANT(E_NOT_POSTED);
PRINT_NAMED_CONSTANT(E_UNKNOWN_COMMAND);
PRINT_NAMED_CONSTANT(E_NO_MATCH);
PRINT_NAMED_CONSTANT(E_NOT_SELECTABLE);
PRINT_NAMED_CONSTANT(E_NOT_CONNECTED);
PRINT_NAMED_CONSTANT(E_REQUEST_DENIED);
PRINT_NAMED_CONSTANT(E_INVALID_FIELD);
PRINT_NAMED_CONSTANT(E_CURRENT);
print_comment(fp, "Input key codes not defined in any ncurses manpage");
PRINT_NAMED_CONSTANT(KEY_MIN);
PRINT_NAMED_CONSTANT(KEY_MAX);
#ifdef KEY_CODE_YES
PRINT_NAMED_CONSTANT(KEY_CODE_YES);
#endif
print_comment(fp, "Input key codes from getch(3NCURSES)");
PRINT_NAMED_CONSTANT(KEY_BREAK);
PRINT_NAMED_CONSTANT(KEY_DOWN);
PRINT_NAMED_CONSTANT(KEY_UP);
PRINT_NAMED_CONSTANT(KEY_LEFT);
PRINT_NAMED_CONSTANT(KEY_RIGHT);
PRINT_NAMED_CONSTANT(KEY_HOME);
PRINT_NAMED_CONSTANT(KEY_BACKSPACE);
PRINT_NAMED_CONSTANT(KEY_F0);
#define PRINT_NAMED_FUNC_KEY(name) print_constant(fp, "KEY_F"#name, KEY_F(name))
PRINT_NAMED_FUNC_KEY(1);
PRINT_NAMED_FUNC_KEY(2);
PRINT_NAMED_FUNC_KEY(3);
PRINT_NAMED_FUNC_KEY(4);
PRINT_NAMED_FUNC_KEY(5);
PRINT_NAMED_FUNC_KEY(6);
PRINT_NAMED_FUNC_KEY(7);
PRINT_NAMED_FUNC_KEY(8);
PRINT_NAMED_FUNC_KEY(9);
PRINT_NAMED_FUNC_KEY(10);
PRINT_NAMED_FUNC_KEY(11);
PRINT_NAMED_FUNC_KEY(12);
PRINT_NAMED_FUNC_KEY(13);
PRINT_NAMED_FUNC_KEY(14);
PRINT_NAMED_FUNC_KEY(15);
PRINT_NAMED_FUNC_KEY(16);
PRINT_NAMED_FUNC_KEY(17);
PRINT_NAMED_FUNC_KEY(18);
PRINT_NAMED_FUNC_KEY(19);
PRINT_NAMED_FUNC_KEY(20);
PRINT_NAMED_FUNC_KEY(21);
PRINT_NAMED_FUNC_KEY(22);
PRINT_NAMED_FUNC_KEY(23);
PRINT_NAMED_FUNC_KEY(24);
PRINT_NAMED_CONSTANT(KEY_DL);
PRINT_NAMED_CONSTANT(KEY_IL);
PRINT_NAMED_CONSTANT(KEY_DC);
PRINT_NAMED_CONSTANT(KEY_IC);
PRINT_NAMED_CONSTANT(KEY_EIC);
PRINT_NAMED_CONSTANT(KEY_CLEAR);
PRINT_NAMED_CONSTANT(KEY_EOS);
PRINT_NAMED_CONSTANT(KEY_EOL);
PRINT_NAMED_CONSTANT(KEY_SF);
PRINT_NAMED_CONSTANT(KEY_SR);
PRINT_NAMED_CONSTANT(KEY_NPAGE);
PRINT_NAMED_CONSTANT(KEY_PPAGE);
PRINT_NAMED_CONSTANT(KEY_STAB);
PRINT_NAMED_CONSTANT(KEY_CTAB);
PRINT_NAMED_CONSTANT(KEY_CATAB);
PRINT_NAMED_CONSTANT(KEY_ENTER);
PRINT_NAMED_CONSTANT(KEY_SRESET);
PRINT_NAMED_CONSTANT(KEY_RESET);
PRINT_NAMED_CONSTANT(KEY_PRINT);
PRINT_NAMED_CONSTANT(KEY_LL);
PRINT_NAMED_CONSTANT(KEY_A1);
PRINT_NAMED_CONSTANT(KEY_A3);
PRINT_NAMED_CONSTANT(KEY_B2);
PRINT_NAMED_CONSTANT(KEY_C1);
PRINT_NAMED_CONSTANT(KEY_C3);
PRINT_NAMED_CONSTANT(KEY_BTAB);
PRINT_NAMED_CONSTANT(KEY_BEG);
PRINT_NAMED_CONSTANT(KEY_CANCEL);
PRINT_NAMED_CONSTANT(KEY_CLOSE);
PRINT_NAMED_CONSTANT(KEY_COMMAND);
PRINT_NAMED_CONSTANT(KEY_COPY);
PRINT_NAMED_CONSTANT(KEY_CREATE);
PRINT_NAMED_CONSTANT(KEY_END);
PRINT_NAMED_CONSTANT(KEY_EXIT);
PRINT_NAMED_CONSTANT(KEY_FIND);
PRINT_NAMED_CONSTANT(KEY_HELP);
PRINT_NAMED_CONSTANT(KEY_MARK);
PRINT_NAMED_CONSTANT(KEY_MESSAGE);
PRINT_NAMED_CONSTANT(KEY_MOVE);
PRINT_NAMED_CONSTANT(KEY_NEXT);
PRINT_NAMED_CONSTANT(KEY_OPEN);
PRINT_NAMED_CONSTANT(KEY_OPTIONS);
PRINT_NAMED_CONSTANT(KEY_PREVIOUS);
PRINT_NAMED_CONSTANT(KEY_REDO);
PRINT_NAMED_CONSTANT(KEY_REFERENCE);
PRINT_NAMED_CONSTANT(KEY_REFRESH);
PRINT_NAMED_CONSTANT(KEY_REPLACE);
PRINT_NAMED_CONSTANT(KEY_RESTART);
PRINT_NAMED_CONSTANT(KEY_RESUME);
PRINT_NAMED_CONSTANT(KEY_SAVE);
PRINT_NAMED_CONSTANT(KEY_SBEG);
PRINT_NAMED_CONSTANT(KEY_SCANCEL);
PRINT_NAMED_CONSTANT(KEY_SCOMMAND);
PRINT_NAMED_CONSTANT(KEY_SCOPY);
PRINT_NAMED_CONSTANT(KEY_SCREATE);
PRINT_NAMED_CONSTANT(KEY_SDC);
PRINT_NAMED_CONSTANT(KEY_SDL);
PRINT_NAMED_CONSTANT(KEY_SELECT);
PRINT_NAMED_CONSTANT(KEY_SEND);
PRINT_NAMED_CONSTANT(KEY_SEOL);
PRINT_NAMED_CONSTANT(KEY_SEXIT);
PRINT_NAMED_CONSTANT(KEY_SFIND);
PRINT_NAMED_CONSTANT(KEY_SHELP);
PRINT_NAMED_CONSTANT(KEY_SHOME);
PRINT_NAMED_CONSTANT(KEY_SIC);
PRINT_NAMED_CONSTANT(KEY_SLEFT);
PRINT_NAMED_CONSTANT(KEY_SMESSAGE);
PRINT_NAMED_CONSTANT(KEY_SMOVE);
PRINT_NAMED_CONSTANT(KEY_SNEXT);
PRINT_NAMED_CONSTANT(KEY_SOPTIONS);
PRINT_NAMED_CONSTANT(KEY_SPREVIOUS);
PRINT_NAMED_CONSTANT(KEY_SPRINT);
PRINT_NAMED_CONSTANT(KEY_SREDO);
PRINT_NAMED_CONSTANT(KEY_SREPLACE);
PRINT_NAMED_CONSTANT(KEY_SRIGHT);
PRINT_NAMED_CONSTANT(KEY_SRSUME);
PRINT_NAMED_CONSTANT(KEY_SSAVE);
PRINT_NAMED_CONSTANT(KEY_SSUSPEND);
PRINT_NAMED_CONSTANT(KEY_SUNDO);
PRINT_NAMED_CONSTANT(KEY_SUSPEND);
PRINT_NAMED_CONSTANT(KEY_UNDO);
PRINT_NAMED_CONSTANT(KEY_MOUSE);
PRINT_NAMED_CONSTANT(KEY_RESIZE);
print_comment(fp, "alternate character codes (ACS) from addch(3NCURSES)");
#define PRINT_ACS(name) print_size_of (fp, #name, (size_t)(&name - &acs_map[0]))
PRINT_ACS(ACS_ULCORNER);
PRINT_ACS(ACS_LLCORNER);
PRINT_ACS(ACS_URCORNER);
PRINT_ACS(ACS_LRCORNER);
PRINT_ACS(ACS_LTEE);
PRINT_ACS(ACS_RTEE);
PRINT_ACS(ACS_BTEE);
PRINT_ACS(ACS_TTEE);
PRINT_ACS(ACS_HLINE);
PRINT_ACS(ACS_VLINE);
PRINT_ACS(ACS_PLUS);
PRINT_ACS(ACS_S1);
PRINT_ACS(ACS_S9);
PRINT_ACS(ACS_DIAMOND);
PRINT_ACS(ACS_CKBOARD);
PRINT_ACS(ACS_DEGREE);
PRINT_ACS(ACS_PLMINUS);
PRINT_ACS(ACS_BULLET);
PRINT_ACS(ACS_LARROW);
PRINT_ACS(ACS_RARROW);
PRINT_ACS(ACS_DARROW);
PRINT_ACS(ACS_UARROW);
PRINT_ACS(ACS_BOARD);
PRINT_ACS(ACS_LANTERN);
PRINT_ACS(ACS_BLOCK);
PRINT_ACS(ACS_S3);
PRINT_ACS(ACS_S7);
PRINT_ACS(ACS_LEQUAL);
PRINT_ACS(ACS_GEQUAL);
PRINT_ACS(ACS_PI);
PRINT_ACS(ACS_NEQUAL);
PRINT_ACS(ACS_STERLING);
print_comment(fp, "Menu_Options from opts(3MENU)");
PRINT_NAMED_BITMASK(Menu_Options, O_ONEVALUE);
PRINT_NAMED_BITMASK(Menu_Options, O_SHOWDESC);
PRINT_NAMED_BITMASK(Menu_Options, O_ROWMAJOR);
PRINT_NAMED_BITMASK(Menu_Options, O_IGNORECASE);
PRINT_NAMED_BITMASK(Menu_Options, O_SHOWMATCH);
PRINT_NAMED_BITMASK(Menu_Options, O_NONCYCLIC);
print_size_of(fp, "Menu_Options_Size", 8 * sizeof(Menu_Options));
print_comment(fp, "Item_Options from menu_opts(3MENU)");
PRINT_NAMED_BITMASK(Item_Options, O_SELECTABLE);
print_size_of(fp, "Item_Options_Size", 8 * sizeof(Item_Options));
print_comment(fp, "Field_Options from field_opts(3FORM)");
PRINT_NAMED_BITMASK(Field_Options, O_VISIBLE);
PRINT_NAMED_BITMASK(Field_Options, O_ACTIVE);
PRINT_NAMED_BITMASK(Field_Options, O_PUBLIC);
PRINT_NAMED_BITMASK(Field_Options, O_EDIT);
PRINT_NAMED_BITMASK(Field_Options, O_WRAP);
PRINT_NAMED_BITMASK(Field_Options, O_BLANK);
PRINT_NAMED_BITMASK(Field_Options, O_AUTOSKIP);
PRINT_NAMED_BITMASK(Field_Options, O_NULLOK);
PRINT_NAMED_BITMASK(Field_Options, O_PASSOK);
PRINT_NAMED_BITMASK(Field_Options, O_STATIC);
print_size_of(fp, "Field_Options_Size", 8 * sizeof(Field_Options));
print_comment(fp, "Field_Options from opts(3FORM)");
PRINT_NAMED_BITMASK(Field_Options, O_NL_OVERLOAD);
PRINT_NAMED_BITMASK(Field_Options, O_BS_OVERLOAD);
/* Field_Options_Size is defined below */
print_comment(fp, "MEVENT structure from mouse(3NCURSES)");
STRUCT_OFFSET(MEVENT, id);
STRUCT_OFFSET(MEVENT, x);
STRUCT_OFFSET(MEVENT, y);
STRUCT_OFFSET(MEVENT, z);
STRUCT_OFFSET(MEVENT, bstate);
print_size_of(fp, "MEVENT_Size", 8 * sizeof(MEVENT));
print_comment(fp, "mouse events from mouse(3NCURSES)");
{
mmask_t all_events;
#define PRINT_MOUSE_EVENT(event) \
print_constant (fp, #event, event); \
all_events |= event
all_events = 0;
PRINT_MOUSE_EVENT(BUTTON1_RELEASED);
PRINT_MOUSE_EVENT(BUTTON1_PRESSED);
PRINT_MOUSE_EVENT(BUTTON1_CLICKED);
PRINT_MOUSE_EVENT(BUTTON1_DOUBLE_CLICKED);
PRINT_MOUSE_EVENT(BUTTON1_TRIPLE_CLICKED);
#ifdef BUTTON1_RESERVED_EVENT
PRINT_MOUSE_EVENT(BUTTON1_RESERVED_EVENT);
#endif
print_constant(fp, "all_events_button_1", (UINT) all_events);
all_events = 0;
PRINT_MOUSE_EVENT(BUTTON2_RELEASED);
PRINT_MOUSE_EVENT(BUTTON2_PRESSED);
PRINT_MOUSE_EVENT(BUTTON2_CLICKED);
PRINT_MOUSE_EVENT(BUTTON2_DOUBLE_CLICKED);
PRINT_MOUSE_EVENT(BUTTON2_TRIPLE_CLICKED);
#ifdef BUTTON2_RESERVED_EVENT
PRINT_MOUSE_EVENT(BUTTON2_RESERVED_EVENT);
#endif
print_constant(fp, "all_events_button_2", (UINT) all_events);
all_events = 0;
PRINT_MOUSE_EVENT(BUTTON3_RELEASED);
PRINT_MOUSE_EVENT(BUTTON3_PRESSED);
PRINT_MOUSE_EVENT(BUTTON3_CLICKED);
PRINT_MOUSE_EVENT(BUTTON3_DOUBLE_CLICKED);
PRINT_MOUSE_EVENT(BUTTON3_TRIPLE_CLICKED);
#ifdef BUTTON3_RESERVED_EVENT
PRINT_MOUSE_EVENT(BUTTON3_RESERVED_EVENT);
#endif
print_constant(fp, "all_events_button_3", (UINT) all_events);
all_events = 0;
PRINT_MOUSE_EVENT(BUTTON4_RELEASED);
PRINT_MOUSE_EVENT(BUTTON4_PRESSED);
PRINT_MOUSE_EVENT(BUTTON4_CLICKED);
PRINT_MOUSE_EVENT(BUTTON4_DOUBLE_CLICKED);
PRINT_MOUSE_EVENT(BUTTON4_TRIPLE_CLICKED);
#ifdef BUTTON4_RESERVED_EVENT
PRINT_MOUSE_EVENT(BUTTON4_RESERVED_EVENT);
#endif
print_constant(fp, "all_events_button_4", (UINT) all_events);
}
PRINT_NAMED_CONSTANT(BUTTON_CTRL);
PRINT_NAMED_CONSTANT(BUTTON_SHIFT);
PRINT_NAMED_CONSTANT(BUTTON_ALT);
PRINT_NAMED_CONSTANT(REPORT_MOUSE_POSITION);
PRINT_NAMED_CONSTANT(ALL_MOUSE_EVENTS);
print_comment(fp, "trace selection from trace(3NCURSES)");
PRINT_NAMED_BITMASK(UINT, TRACE_TIMES);
PRINT_NAMED_BITMASK(UINT, TRACE_TPUTS);
PRINT_NAMED_BITMASK(UINT, TRACE_UPDATE);
PRINT_NAMED_BITMASK(UINT, TRACE_MOVE);
PRINT_NAMED_BITMASK(UINT, TRACE_CHARPUT);
PRINT_NAMED_BITMASK(UINT, TRACE_CALLS);
PRINT_NAMED_BITMASK(UINT, TRACE_VIRTPUT);
PRINT_NAMED_BITMASK(UINT, TRACE_IEVENT);
PRINT_NAMED_BITMASK(UINT, TRACE_BITS);
PRINT_NAMED_BITMASK(UINT, TRACE_ICALLS);
PRINT_NAMED_BITMASK(UINT, TRACE_CCALLS);
PRINT_NAMED_BITMASK(UINT, TRACE_DATABASE);
PRINT_NAMED_BITMASK(UINT, TRACE_ATTRS);
print_size_of(fp, "Trace_Size", 8 * sizeof(UINT));
fprintf(fp, "end Terminal_Interface.Curses_Constants;\n");
exit(EXIT_SUCCESS);
}
|
the_stack_data/103310.c | #include<stdio.h>
int ciclo(int n);
int main(void){
int n;
scanf("%d", &n);
printf("%d\n", ciclo(n));
return 0;
}
int ciclo(int n){
if (n==1)
return 1;
else {
if(n%2==0)
n = n/2;
else
n = n*3+1;
return 1+ciclo(n);
}
}
|
the_stack_data/162642456.c | #if defined(_WIN32) || defined(__CYGWIN__)
#define testLib3_EXPORT __declspec(dllexport)
#define testLib3Imp_IMPORT __declspec(dllimport)
#else
#define testLib3_EXPORT
#define testLib3Imp_IMPORT
#endif
testLib3Imp_IMPORT int testLib3Imp(void);
testLib3_EXPORT int testLib3(void)
{
return testLib3Imp();
}
|
the_stack_data/90763148.c | void
update_path ()
{
const char *key;
// In the macro expansion, CONST_CAST(char *, key) will expand to:
// char* nonconst_key = ((__extension__(union {const char * _q; char * _nq;})((key)))._nq);
// char* nonconst_key = CONST_CAST (char *, key);
// Working with the expanded version of the macro for simplicity.
char* nonconst_key = ((__extension__(union {const char * _q; char * _nq;})((key)))._nq);
// This works in the case of a function argument (but fails for initializer case above).
int status;
foobar1((__extension__ (((union { int __in; int __i; }) { .__in = (status) }).__i)));
}
|
the_stack_data/37639136.c | /* This testcase is part of GDB, the GNU debugger.
Copyright 2004-2015 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include <signal.h>
#include <stdlib.h>
#include <string.h>
extern void
keeper (int sig)
{
}
volatile long v1 = 0;
volatile long v2 = 0;
volatile long v3 = 0;
extern long
bowler (void)
{
/* Try to read address zero. Do it in a slightly convoluted way so
that more than one instruction is used. */
return *(char *) (v1 + v2 + v3);
}
int
main ()
{
static volatile int i;
struct sigaction act;
memset (&act, 0, sizeof act);
act.sa_handler = keeper;
sigaction (SIGSEGV, &act, NULL);
sigaction (SIGBUS, &act, NULL);
bowler ();
return 0;
}
|
the_stack_data/124456.c | /**Programador: Allan Pimentel
***Professor: Prof. Silvana Rossetto
***Disciplina: Computação concorrente.
***Data: 20/10/2019
**Ultima alteração: 31/10/2019
***Descrição: Esse programa calcula a a integral, por aproximação retangular, de uma função indicada no
*** código.
***Entrada: Passada pelos args são 4: o valor inicial do intervalo, o valor final do intervalo,
*** o valor do erro máximo e o numero de threads.
*** Passadas por DEFINE: ID da função como IDFUNCAO.
***Saida: O valor aproximado da integral, bem como o tempo de execução em segundos.
*/
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<math.h>
#include<pthread.h>
#define DEBUG 0 //Se debug for diferente de zero, será exibido no console prints com informações do processo.
#define IDFUNCAO 0
double resultado = 0, erroMaximo;
int countTarefas = 0;
pthread_mutex_t mutex;
typedef struct Intervalo
{
double inicio;
double fim;
} INTERVALO;
typedef struct Argumentos
{
int idThread;
INTERVALO Intervalo;
} ARGS;
void AddResult(double result)
{
pthread_mutex_lock(&mutex);
resultado += result;
pthread_mutex_unlock(&mutex);
}
double CalculaArea(INTERVALO base, double altura)
{
double tamBase = fabs(base.fim - base.inicio);
double area = tamBase * altura;
if(DEBUG) printf("\t\tTamBase: %lf, altura: %lf, Area: %lf.\n", tamBase, altura, area);
return area;
}
double CalculaFuncao(int idFuncao, double valorX)
{
switch (idFuncao)
{
case 0:
return (1 + valorX);
break;
case 1:
return sqrt(1.0 - pow(valorX, 2));
break;
case 2:
return sqrt(1.0 + pow(valorX, 4));
break;
case 3:
return sin(pow(valorX, 2));
break;
case 4:
return cos(pow(M_E, - valorX));
break;
case 5:
return cos(pow(M_E, - valorX)) * valorX;
break;
case 6:
return cos(pow(M_E, - valorX)) * (0.005 * pow(valorX, 3) + 1);
break;
default:
printf("\t\tERRO: id da função não localizado. ID = %d\n", idFuncao);
return INFINITY;
break;
}
}
double CalculaIntervaloTempo(clock_t tInicio, clock_t tFim)
{
return (double)(tFim - tInicio)/ CLOCKS_PER_SEC;
}
void *CalculaIntegral(void *argumentoGenerico)
{
clock_t tempoInicio, tempoFim;
ARGS *meuArgumento = (ARGS *) argumentoGenerico;
tempoInicio = clock();
double xMeio = (meuArgumento->Intervalo.fim + meuArgumento->Intervalo.inicio) / 2;
if(DEBUG)
{
printf("Thread %d: calculando integral...\n\tIntervalo: [%f %f]\n\tMeio: %f\n",
meuArgumento->idThread, meuArgumento->Intervalo.inicio,
meuArgumento->Intervalo.fim, xMeio);
}
if(meuArgumento->Intervalo.inicio * meuArgumento->Intervalo.fim < 0)
{
INTERVALO am, mb, inicial;
am.inicio = meuArgumento->Intervalo.inicio; am.fim = 0.0;
mb.inicio = 0.0; mb.fim = meuArgumento->Intervalo.fim;
if(DEBUG) printf("Thread %d: Intervalos com sinais diferentes, separando em [%f %f] e [%f %f].\n",
meuArgumento->idThread, am.inicio, am.fim, mb.inicio, mb.fim);
inicial = meuArgumento->Intervalo;
meuArgumento->Intervalo = am;
CalculaIntegral(meuArgumento);
meuArgumento->Intervalo = mb;
CalculaIntegral(meuArgumento);
meuArgumento->Intervalo = inicial;
tempoFim = clock();
if(DEBUG) printf("Thread %d calculou a integral do intervalo [%f %f] em %f segundos.\n",
meuArgumento->idThread, meuArgumento->Intervalo.inicio, meuArgumento->Intervalo.fim,
CalculaIntervaloTempo(tempoInicio, tempoFim));
return NULL;
}
double yInicio = CalculaFuncao(IDFUNCAO, meuArgumento->Intervalo.inicio);
double yMeio = CalculaFuncao(IDFUNCAO, xMeio);
double yFim = CalculaFuncao(IDFUNCAO, meuArgumento->Intervalo.fim);
if(yInicio == INFINITY || yMeio == INFINITY || yFim == INFINITY)
{
printf("Thread %d: ERRO ao calcular valores de função: yInicio = %lf, yMeio = %lf, yFim = %lf",
meuArgumento->idThread, yInicio, yMeio, yFim);
pthread_exit(NULL);
}
double areaInicio = CalculaArea(meuArgumento->Intervalo, yInicio);
double areaMeio = CalculaArea(meuArgumento->Intervalo, yMeio);
double areaFim = CalculaArea(meuArgumento->Intervalo, yFim);
if(areaInicio == INFINITY || areaMeio == INFINITY || areaFim == INFINITY)
{
printf("Thread %d: ERRO ao calcular valores de area: areaInicio = %lf, areaMeio = %lf, areaFim = %lf",
meuArgumento->idThread, areaInicio, areaMeio, areaFim);
pthread_exit(NULL);
}
double erroLocal = INFINITY;
int maiorFlag = -1;
if(DEBUG)
{
printf("Thread %d: Valores de Y: %lf %lf %lf \tArea: %lf %lf %lf \n",
meuArgumento->idThread, yInicio, yMeio, yFim, areaInicio, areaMeio, areaFim);
}
if(areaFim >= areaInicio && areaFim >= areaMeio)
{
erroLocal = fabs((areaFim) - (areaInicio + areaMeio));
maiorFlag = 0;
}
else if(areaMeio >= areaInicio && areaMeio >= areaFim)
{
erroLocal = fabs((areaMeio) - (areaInicio + areaFim));
maiorFlag = 1;
}
else if(areaInicio >= areaMeio && areaInicio >= areaFim)
{
erroLocal = fabs((areaInicio) - (areaFim + areaMeio));
maiorFlag = 2;
}
else
{
printf("Thread %d: Erro ao calcular integral: Tentando achar erro local. Intervalo [%f %f].\n",
meuArgumento->idThread, meuArgumento->Intervalo.inicio, meuArgumento->Intervalo.fim);
return NULL;
}
if(erroLocal > erroMaximo)
{
INTERVALO am, mb, inicial;
if(DEBUG) printf("Thread %d: Erro local é maior do que o permitido. Dividindo intervalo...\n",
meuArgumento->idThread);
am.inicio = meuArgumento->Intervalo.inicio; am.fim = xMeio;
mb.inicio = xMeio; mb.fim = meuArgumento->Intervalo.fim;
inicial = meuArgumento->Intervalo;
meuArgumento->Intervalo = am;
CalculaIntegral(meuArgumento);
meuArgumento->Intervalo = mb;
CalculaIntegral(meuArgumento);
meuArgumento->Intervalo = inicial;
tempoFim = clock();
if(DEBUG) printf("Thread %d calculou a integral do intervalo [%f %f] em %f segundos.\n",
meuArgumento->idThread, meuArgumento->Intervalo.inicio, meuArgumento->Intervalo.fim,
CalculaIntervaloTempo(tempoInicio, tempoFim));
return NULL;
}
else
{
double valorIntegral = INFINITY;
if(DEBUG) printf("Thread %d: Erro local dentro do permitido pelo usuário.\n",
meuArgumento->idThread);
switch (maiorFlag)
{
case 0:
valorIntegral = areaFim;
break;
case 1:
valorIntegral = areaMeio;
break;
case 2:
valorIntegral = areaInicio;
break;
default:
printf("Thread %d: ERRO ao calcular integral: Flag invalida ao retornar: %d.\n",
meuArgumento->idThread, maiorFlag);
pthread_exit(NULL);
break;
}
tempoFim = clock();
if(DEBUG) printf("Thread %d calculou a integral do intervalo [%f %f] em %f segundos.\n",
meuArgumento->idThread, meuArgumento->Intervalo.inicio, meuArgumento->Intervalo.fim,
CalculaIntervaloTempo(tempoInicio, tempoFim));
AddResult(valorIntegral);
return NULL;
}
}
int main(int argc, char** argv)
{
INTERVALO intFuncao; //Intervalos iniciais do problema.
clock_t tempoInicio, tempoFim;
int index, nThreads;
float erro, tamanhoIntervalo, inicioIntervalo;
if(argc < 5)
{
printf("ERRO: tem argumentos faltando, leia a descricao do programa.\n");
return 1;
}
intFuncao.inicio = atof(argv[1]);
intFuncao.fim = atof(argv[2]);
erro = atof(argv[3]);
nThreads = atoi(argv[4]);
pthread_mutex_init(&mutex, NULL);
erroMaximo = erro;
if(intFuncao.fim < intFuncao.inicio)
{
double temp = intFuncao.inicio;
intFuncao.inicio = intFuncao.fim;
intFuncao.fim = temp;
}
printf("Definições da entrada: a: %f, b: %f, erro máximo: %f, numero de threads: %d\n",
intFuncao.inicio, intFuncao.fim, erro, nThreads);
pthread_t threads[nThreads];
printf("Iniciando o calculo da integral concorrentemente...\n");
tempoInicio = clock();
tamanhoIntervalo = (intFuncao.fim - intFuncao.inicio) / nThreads;
if(DEBUG) printf("Inicializando Threads.\n");
for(index = 0, inicioIntervalo = intFuncao.inicio;
index < nThreads; index++, inicioIntervalo += tamanhoIntervalo)
{
INTERVALO novoIntervalo;
ARGS *threadArgs = malloc(sizeof(ARGS));
novoIntervalo.inicio = inicioIntervalo;
novoIntervalo.fim = inicioIntervalo + tamanhoIntervalo;
threadArgs->idThread = index;
threadArgs->Intervalo = novoIntervalo;
printf("Thread %d vai pegar a tarefa com intervalo inicial [%f %f]\n",
threadArgs->idThread, threadArgs->Intervalo.inicio, threadArgs->Intervalo.fim);
if(pthread_create(&threads[index], NULL, CalculaIntegral, threadArgs))
{
printf("ERRO AO CRIAR THREAD.\n");
pthread_exit(NULL);
}
}
if(DEBUG) printf("Main esperando threads concluirem.\n");
for(index = 0; index < nThreads; index++)
{
pthread_join(threads[index], NULL);
}
if(DEBUG) printf("Todas as threads acabaram as tarefas.\n");
tempoFim = clock();
printf("Valor da integral: %f\n", resultado);
printf("O tempo total de execução em segundos foi: %f\n", (double)(tempoFim - tempoInicio)/ CLOCKS_PER_SEC);
return 0;
} |
the_stack_data/73575576.c | #include <stdio.h>
int main()
{
int inter, gremio, vitorias_inter = 0, vitorias_gremio = 0, empates = 0, grenais = 0, aux = 1;
while (aux == 1) {
scanf("%d %d", &inter, &gremio);
if (inter > gremio) {
vitorias_inter++;
}
else {
if (inter < gremio)
vitorias_gremio++;
else
empates++;
}
grenais++;
printf("Novo grenal (1-sim 2-nao)\n");
scanf("%d", &aux);
}
printf("%d grenais\n", grenais);
printf("Inter:%d\n", vitorias_inter);
printf("Gremio:%d\n", vitorias_gremio);
printf("Empates:%d\n", empates);
if (vitorias_inter > vitorias_gremio)
printf("Inter venceu mais\n");
else {
if (vitorias_inter < vitorias_gremio)
printf("Gremio venceu mais\n");
else
printf("Nao houve vencedor\n");
}
return 0;
}
|
the_stack_data/343142.c |
void set(int *a) { *a = 8; }
/* basic test */
int main(void) {
void (*s)(int *) = set;
int a, b = 1, c = 13;
a = b + c;
b = 3;
c = 5;
s(&a);
test_assert(a == 8);
return 0;
}
|
the_stack_data/231394100.c | #include <stdio.h>
#include <setjmp.h>
jmp_buf buf;
void error_recovery()
{
printf("detected an unrecoverable error\n");
longjmp(buf, 1);
}
int main(void)
{
while(1)
{
if (setjmp(buf))
{
printf("back in main\n");
break;
}
else
{
error_recovery();
}
}
return 0;
}
|
the_stack_data/92326434.c | // RUN: %layout_check %s
//int x[] = { [3] = 5 };
//struct { int x, y, z; } q = { .y = 2, 3 };
//int k[] = { [7 ... 9] = 2 };
struct A
{
int i;
char buf[3];
struct B
{
int q;
int a[2];
} sub_b[10];
} ent1[] = {
[0 ... 3] = {
.i = 2,
.buf[0 ... 1] = 7,
.sub_b[3 ... 5].q = 1
},
[8].sub_b[3].a = { 2, 3 }
};
|
the_stack_data/384342.c | // vim: set ts=4:
/*
* The MIT License
*
* Copyright 2021 Jakub Jirutka <[email protected]>.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#define _POSIX_C_SOURCE 200809L
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <libgen.h>
#include <limits.h>
#include <spawn.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/wait.h>
#define PROGNAME "zzz"
#ifndef VERSION
#define VERSION "0.1.0"
#endif
#ifndef ZZZ_HOOKS_DIR
#define ZZZ_HOOKS_DIR "/etc/zzz.d"
#endif
#ifndef ZZZ_LOCK_FILE
#define ZZZ_LOCK_FILE "/tmp/zzz.lock"
#endif
#define FLAG_VERBOSE 0x0001
#define ERR_GENERAL 1
#define ERR_WRONG_USAGE 10
#define ERR_UNSUPPORTED 11
#define ERR_LOCK 12
#define ERR_SUSPEND 20
#define ERR_HOOK 21
#define RC_OK 0
#define RC_ERR -1
#define isempty(arg) \
(arg == NULL || arg[0] == '\0')
#define log_err(format, ...) \
do { \
fprintf(stderr, PROGNAME ": ERROR: " format "\n", __VA_ARGS__); \
syslog(LOG_ERR, format, __VA_ARGS__); \
} while (0)
#define log_errno(format, ...) \
log_err(format ": %s", __VA_ARGS__, strerror(errno))
#define log_info(format, ...) \
do { \
syslog(LOG_INFO, format, __VA_ARGS__); \
printf(format "\n", __VA_ARGS__); \
} while (0)
#define log_debug(format, ...) \
if (flags & FLAG_VERBOSE) { \
syslog(LOG_DEBUG, format, __VA_ARGS__); \
printf(format "\n", __VA_ARGS__); \
}
extern char **environ;
static const char *HELP_MSG =
"Usage: " PROGNAME " [-v] [-n|s|S|z|Z|H|R|V|h]\n"
"\n"
"Suspend or hibernate the system.\n"
"\n"
"Options:\n"
" -n Dry run (sleep for 5s instead of suspend/hibernate).\n"
" -s Low-power idle (ACPI S1).\n"
" -S Deprecated alias for -s.\n"
" -z Suspend to RAM (ACPI S3). [default for zzz(8)]\n"
" -Z Hibernate to disk & power off (ACPI S4). [default for ZZZ(8)]\n"
" -H Hibernate to disk & suspend (aka suspend-hybrid).\n"
" -R Hibernate to disk & reboot.\n"
" -v Be verbose.\n"
" -V Print program name & version and exit.\n"
" -h Show this message and exit.\n"
"\n"
"Homepage: https://github.com/jirutka/zzz\n";
static unsigned int flags = 0;
static bool str_ends_with (const char *str, const char *suffix) {
int diff = strlen(str) - strlen(suffix);
return diff > 0 && strcmp(&str[diff], suffix) == 0;
}
static int run_hook (const char *path, const char **argv) {
posix_spawn_file_actions_t factions;
int rc = RC_ERR;
(void) posix_spawn_file_actions_init(&factions);
(void) posix_spawn_file_actions_addclose(&factions, STDIN_FILENO);
log_debug("Executing hook script: %s", path);
argv[0] = path; // XXX: mutates input argument!
pid_t pid;
if ((rc = posix_spawn(&pid, path, &factions, 0, (char *const *)argv, environ)) != 0) {
log_errno("Unable to execute hook script %s", path);
goto done;
}
int status;
(void) waitpid(pid, &status, 0);
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
rc = WEXITSTATUS(status);
log_err("Hook script %s exited with code %d", path, rc);
goto done;
}
rc = RC_OK;
done:
posix_spawn_file_actions_destroy(&factions);
argv[0] = NULL; // XXX: mutates input argument!
return rc;
}
static int filter_hook_script (const struct dirent *entry) {
struct stat sb;
return stat(entry->d_name, &sb) >= 0
&& S_ISREG(sb.st_mode) // is regular file
&& sb.st_mode & S_IXUSR // is executable by owner
&& !(sb.st_mode & S_IWOTH) // is not writable by others
&& sb.st_uid == 0; // is owned by root
}
static int run_hooks (const char *dirpath, const char **argv) {
struct dirent **entries = NULL;
int rc = RC_OK;
if (chdir(dirpath) < 0) {
errno = 0;
goto done;
}
int n = 0;
if ((n = scandir(".", &entries, filter_hook_script, alphasort)) < 0) {
log_errno("%s", dirpath);
rc = RC_ERR;
goto done;
}
char path[PATH_MAX] = "\0";
for (int i = 0; i < n; i++) {
(void) snprintf(path, sizeof(path), "%s/%s", dirpath, entries[i]->d_name);
if (run_hook(path, argv) != RC_OK) {
rc = RC_ERR;
}
}
done:
if (entries) free(entries);
(void) chdir("/");
return rc;
}
static int check_sleep_mode (const char *filepath, const char *mode) {
FILE *fp = NULL;
int rc = RC_ERR;
if (access(filepath, W_OK) < 0) {
log_errno("%s", filepath);
goto done;
}
char line[64] = "\0";
if ((fp = fopen(filepath, "r")) == NULL || fgets(line, sizeof(line), fp) == NULL) {
log_errno("Failed to read %s", filepath);
goto done;
}
// XXX: This is sloppy...
if (strstr(line, mode) != NULL) {
rc = RC_OK;
}
done:
if (fp) fclose(fp);
return rc;
}
static int file_write (const char *filepath, const char *data) {
FILE *fp = NULL;
int rc = RC_ERR;
if ((fp = fopen(filepath, "w")) == NULL) {
log_errno("%s", filepath);
goto done;
}
(void) setvbuf(fp, NULL, _IONBF, 0); // disable buffering
if (fputs(data, fp) < 0) {
log_errno("%s", filepath);
goto done;
}
rc = RC_OK;
done:
if (fp) fclose(fp);
return rc;
}
static int execute (const char* zzz_mode, const char* sleep_state, const char* hibernate_mode) {
int lock_fd = -1;
int rc = EXIT_SUCCESS;
// Check if we can fulfil the request.
if (!isempty(sleep_state) && check_sleep_mode("/sys/power/state", sleep_state) < 0) {
return ERR_UNSUPPORTED;
}
if (!isempty(hibernate_mode) && check_sleep_mode("/sys/power/disk", hibernate_mode) < 0) {
return ERR_UNSUPPORTED;
}
// Obtain exclusive lock.
if ((lock_fd = open(ZZZ_LOCK_FILE, O_CREAT | O_RDWR | O_CLOEXEC, 0600)) < 0) {
log_errno("Failed to write %s", ZZZ_LOCK_FILE);
return ERR_LOCK;
}
if (flock(lock_fd, LOCK_EX | LOCK_NB) < 0) {
log_err("%s", "Another instance of zzz is running");
return ERR_LOCK;
}
// The first element will be replaced in run_hook() with the script path.
const char *hook_args[] = { NULL, "pre", zzz_mode, NULL };
if (run_hooks(ZZZ_HOOKS_DIR, hook_args) < 0) {
rc = ERR_HOOK;
}
// For compatibility with zzz on Void Linux.
if (run_hooks(ZZZ_HOOKS_DIR "/suspend", hook_args) < 0) {
rc = ERR_HOOK;
}
if (!isempty(hibernate_mode) && file_write("/sys/power/disk", hibernate_mode) < 0) {
rc = ERR_SUSPEND;
goto done;
}
log_info("Going to %s (%s)", zzz_mode, sleep_state);
if (isempty(sleep_state)) {
sleep(5);
} else if (file_write("/sys/power/state", sleep_state) < 0) {
log_err("Failed to %s system", zzz_mode);
rc = ERR_SUSPEND;
goto done;
}
log_info("System resumed from %s (%s)", zzz_mode, sleep_state);
hook_args[1] = "post";
if (run_hooks(ZZZ_HOOKS_DIR, hook_args) < 0) {
rc = ERR_HOOK;
}
// For compatibility with zzz on Void Linux.
if (run_hooks(ZZZ_HOOKS_DIR "/resume", hook_args) < 0) {
rc = ERR_HOOK;
}
done:
// Release lock.
if (unlink(ZZZ_LOCK_FILE) < 0) {
log_errno("Failed to remove lock file %s", ZZZ_LOCK_FILE);
rc = ERR_GENERAL;
}
if (flock(lock_fd, LOCK_UN) < 0) {
log_errno("Failed to release lock on %s", ZZZ_LOCK_FILE);
rc = ERR_GENERAL;
}
(void) close(lock_fd);
return rc;
}
int main (int argc, char **argv) {
char *zzz_mode = "suspend";
char *sleep_state = "mem";
char *hibernate_mode = "";
if (str_ends_with(argv[0], "/ZZZ")) {
zzz_mode = "hibernate";
sleep_state = "disk";
hibernate_mode = "platform";
}
int optch;
opterr = 0; // don't print implicit error message on unrecognized option
while ((optch = getopt(argc, argv, "nsSzHRZvhV")) != -1) {
switch (optch) {
case -1:
break;
case 'n':
zzz_mode = "noop";
sleep_state = "";
hibernate_mode = "";
break;
case 's':
case 'S':
zzz_mode = "standby";
sleep_state = "freeze";
hibernate_mode = "";
break;
case 'z':
zzz_mode = "suspend";
sleep_state = "mem";
hibernate_mode = "";
break;
case 'H':
zzz_mode = "hibernate";
sleep_state = "disk";
hibernate_mode = "suspend";
break;
case 'R':
zzz_mode = "hibernate";
sleep_state = "disk";
hibernate_mode = "reboot";
break;
case 'Z':
zzz_mode = "hibernate";
sleep_state = "disk";
hibernate_mode = "platform";
break;
case 'v':
flags |= FLAG_VERBOSE;
break;
case 'h':
printf("%s", HELP_MSG);
return EXIT_SUCCESS;
case 'V':
puts(PROGNAME " " VERSION);
return EXIT_SUCCESS;
default:
fprintf(stderr, "%1$s: Invalid option: -%2$c (see %1$s -h)\n", PROGNAME, optopt);
return ERR_WRONG_USAGE;
}
}
(void) chdir("/");
// Clear environment variables.
environ = NULL;
// Set environment for hooks.
setenv("PATH", "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", 1);
setenv("ZZZ_MODE", zzz_mode, 1);
setenv("ZZZ_HIBERNATE_MODE", hibernate_mode, 1);
// Open connection to syslog.
openlog(PROGNAME, LOG_PID, LOG_USER);
return execute(zzz_mode, sleep_state, hibernate_mode);
}
|
the_stack_data/232955030.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char** argv) {
FILE *s = fopen("/etc/shadow", "r");
char buffer[2048];
if (!s) {
printf("File open failed!\n");
return 1;
}
while (!feof(s)) {
memset(buffer, 0, 2048);
fread(buffer, 2048, 1, s);
printf("%s", buffer);
}
return 0;
}
|
the_stack_data/939777.c | /* Copyright (C) 1992, 1995, 1997, 2002, 2004 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <string.h>
#undef __stpcpy
#undef stpcpy
#ifndef weak_alias
# define __stpcpy stpcpy
#endif
/* Copy SRC to DEST, returning the address of the terminating '\0' in DEST. */
char *
__stpcpy (dest, src)
char *dest;
const char *src;
{
register char *d = dest;
register const char *s = src;
do
*d++ = *s;
while (*s++ != '\0');
return d - 1;
}
#ifdef libc_hidden_def
libc_hidden_def (__stpcpy)
#endif
#ifdef weak_alias
weak_alias (__stpcpy, stpcpy)
#endif
#ifdef libc_hidden_builtin_def
libc_hidden_builtin_def (stpcpy)
#endif
|
the_stack_data/102098.c | #include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
#include <assert.h>
#define EPSILON 1e-8
/* a bit slow, 144 ms */
int numSquares(int n) {
if (n <= 0) return 0;
if (n == 1) return 1;
int *squares = (int *)calloc(n, sizeof(int));
int *dp = (int *)calloc(n + 1, sizeof(int));
int k;
int storeIndex = 0;
for (k = 1; k <= n; k++) {
double root = sqrt(k);
if (fabs(root - (int)root) < EPSILON) { /* check if k is perfect square */
squares[storeIndex++] = k;
}
}
int i, j;
dp[0] = 0; /* dummy */
dp[1] = 1;
for (i = 2; i <= n; i++) {
int min = INT32_MAX;
for (j = 0; squares[j] <= i && j < storeIndex; j++) {
if (dp[i - squares[j]] + 1 < min) {
min = dp[i - squares[j]] + 1;
}
}
dp[i] = min;
}
int ans = dp[n];
free(squares);
free(dp);
return ans;
}
int main() {
assert(numSquares(1) == 1);
assert(numSquares(2) == 2);
assert(numSquares(3) == 3);
assert(numSquares(4) == 1);
assert(numSquares(5) == 2);
assert(numSquares(12) == 3);
assert(numSquares(13) == 2);
printf("all tests passed!\n");
return 0;
}
|
the_stack_data/2866.c | /* $NetBSD: getopt.c,v 1.29 2014/06/05 22:00:22 christos Exp $ */
/*-
* SPDX-License-Identifier: BSD-3-Clause
*
* Copyright (c) 1987, 1993, 1994
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifdef __CYGWIN__
#error Not for cygwin.
#endif
#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)getopt.c 8.3 (Berkeley) 4/27/95";
#endif /* LIBC_SCCS and not lint */
#ifdef unix
#include <sys/cdefs.h>
#endif
#ifdef __FreeBSD__
__FBSDID("$FreeBSD$");
#endif
#ifdef __FreeBSD__
#include "namespace.h"
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef unix
#include <unistd.h>
#endif
#ifdef __FreeBSD__
#include "un-namespace.h"
#endif
#ifdef __FreeBSD__
#include "libc_private.h"
#endif
int opterr = 1, /* if error message should be printed */
optind = 1, /* index into parent argv vector */
optopt, /* character checked for validity */
optreset; /* reset getopt */
char *optarg; /* argument associated with option */
#ifndef __FreeBSD__
const char *opt_progname = NULL;
#endif
#define BADCH (int)'?'
#define BADARG (int)':'
static char EMSG[] = "";
/*
* getopt --
* Parse argc/argv argument vector.
*/
int
getopt(int nargc, char * const nargv[], const char *ostr)
{
static char *place = EMSG; /* option letter processing */
char *oli; /* option letter list index */
if (optreset || *place == 0) { /* update scanning pointer */
optreset = 0;
place = nargv[optind];
if (optind >= nargc || *place++ != '-') {
/* Argument is absent or is not an option */
place = EMSG;
return (-1);
}
optopt = *place++;
if (optopt == '-' && *place == 0) {
/* "--" => end of options */
++optind;
place = EMSG;
return (-1);
}
if (optopt == 0) {
/* Solitary '-', treat as a '-' option
if the program (eg su) is looking for it. */
place = EMSG;
if (strchr(ostr, '-') == NULL)
return (-1);
optopt = '-';
}
} else
optopt = *place++;
/* See if option letter is one the caller wanted... */
if (optopt == ':' || (oli = strchr(ostr, optopt)) == NULL) {
if (*place == 0)
++optind;
if (opterr && *ostr != ':')
(void)fprintf(stderr,
#ifdef __FreeBSD__
"%s: illegal option -- %c\n", _getprogname(),
#else
"%s%sillegal option -- %c\n",
(opt_progname && *opt_progname) ? opt_progname : "",
(opt_progname && *opt_progname) ? ": " : "",
#endif
optopt);
return (BADCH);
}
/* Does this option need an argument? */
if (oli[1] != ':') {
/* don't need argument */
optarg = NULL;
if (*place == 0)
++optind;
} else {
/* Option-argument is either the rest of this argument or the
entire next argument. */
if (*place)
optarg = place;
else if (oli[2] == ':')
/*
* GNU Extension, for optional arguments if the rest of
* the argument is empty, we return NULL
*/
optarg = NULL;
else if (nargc > ++optind)
optarg = nargv[optind];
else {
/* option-argument absent */
place = EMSG;
if (*ostr == ':')
return (BADARG);
if (opterr)
(void)fprintf(stderr,
#ifdef __FreeBSD__
"%s: option requires an argument -- %c\n", _getprogname(),
#else
"%s%soption requires an argument -- %c\n",
(opt_progname && *opt_progname) ? opt_progname : "",
(opt_progname && *opt_progname) ? ": " : "",
#endif
optopt);
return (BADCH);
}
place = EMSG;
++optind;
}
return (optopt); /* return option letter */
}
|
the_stack_data/57950949.c | /* Taxonomy Classification: 0000000100000032000110 */
/*
* WRITE/READ 0 write
* WHICH BOUND 0 upper
* DATA TYPE 0 char
* MEMORY LOCATION 0 stack
* SCOPE 0 same
* CONTAINER 0 no
* POINTER 0 no
* INDEX COMPLEXITY 1 variable
* ADDRESS COMPLEXITY 0 constant
* LENGTH COMPLEXITY 0 N/A
* ADDRESS ALIAS 0 none
* INDEX ALIAS 0 none
* LOCAL CONTROL FLOW 0 none
* SECONDARY CONTROL FLOW 0 none
* LOOP STRUCTURE 3 while
* LOOP COMPLEXITY 2 one
* ASYNCHRONY 0 no
* TAINT 0 no
* RUNTIME ENV. DEPENDENCE 0 no
* MAGNITUDE 1 1 byte
* CONTINUOUS/DISCRETE 1 continuous
* SIGNEDNESS 0 no
*/
/*
Copyright 2005 Massachusetts Institute of Technology
All rights reserved.
Redistribution and use of software in source and binary forms, with or without
modification, are permitted provided that the following conditions are met.
- Redistributions of source code must retain the above copyright notice,
this set of conditions and the disclaimer below.
- Redistributions in binary form must reproduce the copyright notice, this
set of conditions, and the disclaimer below in the documentation and/or
other materials provided with the distribution.
- Neither the name of the Massachusetts Institute of Technology nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS".
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
int main(int argc, char *argv[])
{
int init_value;
int loop_counter;
char buf[10];
init_value = 0;
loop_counter = init_value;
while(loop_counter <= 10)
{
/* BAD */
buf[loop_counter] = 'A';
loop_counter++;
}
return 0;
}
|
the_stack_data/15465.c | /* ======================================================================== */
/* ========================= LICENSING & COPYRIGHT ======================== */
/* ======================================================================== */
/*
* MUSASHI
* Version 3.4
*
* A portable Motorola M680x0 processor emulation engine.
* Copyright 1998-2001 Karl Stenerud. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
/* ======================================================================== */
/* ============================ CODE GENERATOR ============================ */
/* ======================================================================== */
/*
* This is the code generator program which will generate the opcode table
* and the final opcode handlers.
*
* It requires an input file to function (default m68k_in.c), but you can
* specify your own like so:
*
* m68kmake <output path> <input file>
*
* where output path is the path where the output files should be placed, and
* input file is the file to use for input.
*
* If you modify the input file greatly from its released form, you may have
* to tweak the configuration section a bit since I'm using static allocation
* to keep things simple.
*
*
* TODO: - build a better code generator for the move instruction.
* - Add callm and rtm instructions
* - Fix RTE to handle other format words
* - Add address error (and bus error?) handling
*/
char* g_version = "3.3";
/* ======================================================================== */
/* =============================== INCLUDES =============================== */
/* ======================================================================== */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdarg.h>
/* ======================================================================== */
/* ============================= CONFIGURATION ============================ */
/* ======================================================================== */
#define M68K_MAX_PATH 1024
#define M68K_MAX_DIR 1024
#define NUM_CPUS 3 /* 000, 010, 020 */
#define MAX_LINE_LENGTH 200 /* length of 1 line */
#define MAX_BODY_LENGTH 300 /* Number of lines in 1 function */
#define MAX_REPLACE_LENGTH 30 /* Max number of replace strings */
#define MAX_INSERT_LENGTH 5000 /* Max size of insert piece */
#define MAX_NAME_LENGTH 30 /* Max length of ophandler name */
#define MAX_SPEC_PROC_LENGTH 4 /* Max length of special processing str */
#define MAX_SPEC_EA_LENGTH 5 /* Max length of specified EA str */
#define EA_ALLOWED_LENGTH 11 /* Max length of ea allowed str */
#define MAX_OPCODE_INPUT_TABLE_LENGTH 1000 /* Max length of opcode handler tbl */
#define MAX_OPCODE_OUTPUT_TABLE_LENGTH 3000 /* Max length of opcode handler tbl */
/* Default filenames */
#define FILENAME_INPUT "m68k_in.c"
#define FILENAME_PROTOTYPE "m68kops.h"
#define FILENAME_TABLE "m68kops.c"
#define FILENAME_OPS_AC "m68kopac.c"
#define FILENAME_OPS_DM "m68kopdm.c"
#define FILENAME_OPS_NZ "m68kopnz.c"
/* Identifier sequences recognized by this program */
#define ID_INPUT_SEPARATOR "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
#define ID_BASE "M68KMAKE"
#define ID_PROTOTYPE_HEADER ID_BASE "_PROTOTYPE_HEADER"
#define ID_PROTOTYPE_FOOTER ID_BASE "_PROTOTYPE_FOOTER"
#define ID_TABLE_HEADER ID_BASE "_TABLE_HEADER"
#define ID_TABLE_FOOTER ID_BASE "_TABLE_FOOTER"
#define ID_TABLE_BODY ID_BASE "_TABLE_BODY"
#define ID_TABLE_START ID_BASE "_TABLE_START"
#define ID_OPHANDLER_HEADER ID_BASE "_OPCODE_HANDLER_HEADER"
#define ID_OPHANDLER_FOOTER ID_BASE "_OPCODE_HANDLER_FOOTER"
#define ID_OPHANDLER_BODY ID_BASE "_OPCODE_HANDLER_BODY"
#define ID_END ID_BASE "_END"
#define ID_OPHANDLER_NAME ID_BASE "_OP"
#define ID_OPHANDLER_EA_AY_8 ID_BASE "_GET_EA_AY_8"
#define ID_OPHANDLER_EA_AY_16 ID_BASE "_GET_EA_AY_16"
#define ID_OPHANDLER_EA_AY_32 ID_BASE "_GET_EA_AY_32"
#define ID_OPHANDLER_OPER_AY_8 ID_BASE "_GET_OPER_AY_8"
#define ID_OPHANDLER_OPER_AY_16 ID_BASE "_GET_OPER_AY_16"
#define ID_OPHANDLER_OPER_AY_32 ID_BASE "_GET_OPER_AY_32"
#define ID_OPHANDLER_CC ID_BASE "_CC"
#define ID_OPHANDLER_NOT_CC ID_BASE "_NOT_CC"
#ifndef DECL_SPEC
#define DECL_SPEC
#endif /* DECL_SPEC */
/* ======================================================================== */
/* ============================== PROTOTYPES ============================== */
/* ======================================================================== */
#define CPU_TYPE_000 0
#define CPU_TYPE_010 1
#define CPU_TYPE_020 2
#define UNSPECIFIED "."
#define UNSPECIFIED_CH '.'
#define HAS_NO_EA_MODE(A) (strcmp(A, "..........") == 0)
#define HAS_EA_AI(A) ((A)[0] == 'A')
#define HAS_EA_PI(A) ((A)[1] == '+')
#define HAS_EA_PD(A) ((A)[2] == '-')
#define HAS_EA_DI(A) ((A)[3] == 'D')
#define HAS_EA_IX(A) ((A)[4] == 'X')
#define HAS_EA_AW(A) ((A)[5] == 'W')
#define HAS_EA_AL(A) ((A)[6] == 'L')
#define HAS_EA_PCDI(A) ((A)[7] == 'd')
#define HAS_EA_PCIX(A) ((A)[8] == 'x')
#define HAS_EA_I(A) ((A)[9] == 'I')
enum
{
EA_MODE_NONE, /* No special addressing mode */
EA_MODE_AI, /* Address register indirect */
EA_MODE_PI, /* Address register indirect with postincrement */
EA_MODE_PI7, /* Address register 7 indirect with postincrement */
EA_MODE_PD, /* Address register indirect with predecrement */
EA_MODE_PD7, /* Address register 7 indirect with predecrement */
EA_MODE_DI, /* Address register indirect with displacement */
EA_MODE_IX, /* Address register indirect with index */
EA_MODE_AW, /* Absolute word */
EA_MODE_AL, /* Absolute long */
EA_MODE_PCDI, /* Program counter indirect with displacement */
EA_MODE_PCIX, /* Program counter indirect with index */
EA_MODE_I /* Immediate */
};
/* Everything we need to know about an opcode */
typedef struct
{
char name[MAX_NAME_LENGTH]; /* opcode handler name */
unsigned char size; /* Size of operation */
char spec_proc[MAX_SPEC_PROC_LENGTH]; /* Special processing mode */
char spec_ea[MAX_SPEC_EA_LENGTH]; /* Specified effective addressing mode */
unsigned char bits; /* Number of significant bits (used for sorting the table) */
unsigned short op_mask; /* Mask to apply for matching an opcode to a handler */
unsigned short op_match; /* Value to match after masking */
char ea_allowed[EA_ALLOWED_LENGTH]; /* Effective addressing modes allowed */
char cpu_mode[NUM_CPUS]; /* User or supervisor mode */
char cpus[NUM_CPUS+1]; /* Allowed CPUs */
unsigned char cycles[NUM_CPUS]; /* cycles for 000, 010, 020 */
} opcode_struct;
/* All modifications necessary for a specific EA mode of an instruction */
typedef struct
{
char* fname_add;
char* ea_add;
unsigned int mask_add;
unsigned int match_add;
} ea_info_struct;
/* Holds the body of a function */
typedef struct
{
char body[MAX_BODY_LENGTH][MAX_LINE_LENGTH+1];
int length;
} body_struct;
/* Holds a sequence of search / replace strings */
typedef struct
{
char replace[MAX_REPLACE_LENGTH][2][MAX_LINE_LENGTH+1];
int length;
} replace_struct;
/* Function Prototypes */
void error_exit(char* fmt, ...);
void perror_exit(char* fmt, ...);
int check_strsncpy(char* dst, char* src, int maxlength);
int check_atoi(char* str, int *result);
int skip_spaces(char* str);
int num_bits(int value);
int atoh(char* buff);
int fgetline(char* buff, int nchars, FILE* file);
int get_oper_cycles(opcode_struct* op, int ea_mode, int cpu_type);
opcode_struct* find_opcode(char* name, int size, char* spec_proc, char* spec_ea);
opcode_struct* find_illegal_opcode(void);
int extract_opcode_info(char* src, char* name, int* size, char* spec_proc, char* spec_ea);
void add_replace_string(replace_struct* replace, char* search_str, char* replace_str);
void write_body(FILE* filep, body_struct* body, replace_struct* replace);
void get_base_name(char* base_name, opcode_struct* op);
void write_prototype(FILE* filep, char* base_name);
void write_function_name(FILE* filep, char* base_name);
void add_opcode_output_table_entry(opcode_struct* op, char* name);
static int DECL_SPEC compare_nof_true_bits(const void* aptr, const void* bptr);
void print_opcode_output_table(FILE* filep);
void write_table_entry(FILE* filep, opcode_struct* op);
void set_opcode_struct(opcode_struct* src, opcode_struct* dst, int ea_mode);
void generate_opcode_handler(FILE* filep, body_struct* body, replace_struct* replace, opcode_struct* opinfo, int ea_mode);
void generate_opcode_ea_variants(FILE* filep, body_struct* body, replace_struct* replace, opcode_struct* op);
void generate_opcode_cc_variants(FILE* filep, body_struct* body, replace_struct* replace, opcode_struct* op_in, int offset);
void process_opcode_handlers(void);
void populate_table(void);
void read_insert(char* insert);
/* ======================================================================== */
/* ================================= DATA ================================= */
/* ======================================================================== */
/* Name of the input file */
char g_input_filename[M68K_MAX_PATH] = FILENAME_INPUT;
/* File handles */
FILE* g_input_file = NULL;
FILE* g_prototype_file = NULL;
FILE* g_table_file = NULL;
FILE* g_ops_ac_file = NULL;
FILE* g_ops_dm_file = NULL;
FILE* g_ops_nz_file = NULL;
int g_num_functions = 0; /* Number of functions processed */
int g_num_primitives = 0; /* Number of function primitives read */
int g_line_number = 1; /* Current line number */
/* Opcode handler table */
opcode_struct g_opcode_input_table[MAX_OPCODE_INPUT_TABLE_LENGTH];
opcode_struct g_opcode_output_table[MAX_OPCODE_OUTPUT_TABLE_LENGTH];
int g_opcode_output_table_length = 0;
ea_info_struct g_ea_info_table[13] =
{/* fname ea mask match */
{"", "", 0x00, 0x00}, /* EA_MODE_NONE */
{"ai", "AY_AI", 0x38, 0x10}, /* EA_MODE_AI */
{"pi", "AY_PI", 0x38, 0x18}, /* EA_MODE_PI */
{"pi7", "A7_PI", 0x3f, 0x1f}, /* EA_MODE_PI7 */
{"pd", "AY_PD", 0x38, 0x20}, /* EA_MODE_PD */
{"pd7", "A7_PD", 0x3f, 0x27}, /* EA_MODE_PD7 */
{"di", "AY_DI", 0x38, 0x28}, /* EA_MODE_DI */
{"ix", "AY_IX", 0x38, 0x30}, /* EA_MODE_IX */
{"aw", "AW", 0x3f, 0x38}, /* EA_MODE_AW */
{"al", "AL", 0x3f, 0x39}, /* EA_MODE_AL */
{"pcdi", "PCDI", 0x3f, 0x3a}, /* EA_MODE_PCDI */
{"pcix", "PCIX", 0x3f, 0x3b}, /* EA_MODE_PCIX */
{"i", "I", 0x3f, 0x3c}, /* EA_MODE_I */
};
char* g_cc_table[16][2] =
{
{ "t", "T"}, /* 0000 */
{ "f", "F"}, /* 0001 */
{"hi", "HI"}, /* 0010 */
{"ls", "LS"}, /* 0011 */
{"cc", "CC"}, /* 0100 */
{"cs", "CS"}, /* 0101 */
{"ne", "NE"}, /* 0110 */
{"eq", "EQ"}, /* 0111 */
{"vc", "VC"}, /* 1000 */
{"vs", "VS"}, /* 1001 */
{"pl", "PL"}, /* 1010 */
{"mi", "MI"}, /* 1011 */
{"ge", "GE"}, /* 1100 */
{"lt", "LT"}, /* 1101 */
{"gt", "GT"}, /* 1110 */
{"le", "LE"}, /* 1111 */
};
/* size to index translator (0 -> 0, 8 and 16 -> 1, 32 -> 2) */
int g_size_select_table[33] =
{
0, /* unsized */
0, 0, 0, 0, 0, 0, 0, 1, /* 8 */
0, 0, 0, 0, 0, 0, 0, 1, /* 16 */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2 /* 32 */
};
/* Extra cycles required for certain EA modes */
int g_ea_cycle_table[13][NUM_CPUS][3] =
{/* 000 010 020 */
{{ 0, 0, 0}, { 0, 0, 0}, { 0, 0, 0}}, /* EA_MODE_NONE */
{{ 0, 4, 8}, { 0, 4, 8}, { 0, 4, 4}}, /* EA_MODE_AI */
{{ 0, 4, 8}, { 0, 4, 8}, { 0, 4, 4}}, /* EA_MODE_PI */
{{ 0, 4, 8}, { 0, 4, 8}, { 0, 4, 4}}, /* EA_MODE_PI7 */
{{ 0, 6, 10}, { 0, 6, 10}, { 0, 5, 5}}, /* EA_MODE_PD */
{{ 0, 6, 10}, { 0, 6, 10}, { 0, 5, 5}}, /* EA_MODE_PD7 */
{{ 0, 8, 12}, { 0, 8, 12}, { 0, 5, 5}}, /* EA_MODE_DI */
{{ 0, 10, 14}, { 0, 10, 14}, { 0, 7, 7}}, /* EA_MODE_IX */
{{ 0, 8, 12}, { 0, 8, 12}, { 0, 4, 4}}, /* EA_MODE_AW */
{{ 0, 12, 16}, { 0, 12, 16}, { 0, 4, 4}}, /* EA_MODE_AL */
{{ 0, 8, 12}, { 0, 8, 12}, { 0, 5, 5}}, /* EA_MODE_PCDI */
{{ 0, 10, 14}, { 0, 10, 14}, { 0, 7, 7}}, /* EA_MODE_PCIX */
{{ 0, 4, 8}, { 0, 4, 8}, { 0, 2, 4}}, /* EA_MODE_I */
};
/* Extra cycles for JMP instruction (000, 010) */
int g_jmp_cycle_table[13] =
{
0, /* EA_MODE_NONE */
4, /* EA_MODE_AI */
0, /* EA_MODE_PI */
0, /* EA_MODE_PI7 */
0, /* EA_MODE_PD */
0, /* EA_MODE_PD7 */
6, /* EA_MODE_DI */
10, /* EA_MODE_IX */
6, /* EA_MODE_AW */
8, /* EA_MODE_AL */
6, /* EA_MODE_PCDI */
10, /* EA_MODE_PCIX */
0, /* EA_MODE_I */
};
/* Extra cycles for JSR instruction (000, 010) */
int g_jsr_cycle_table[13] =
{
0, /* EA_MODE_NONE */
4, /* EA_MODE_AI */
0, /* EA_MODE_PI */
0, /* EA_MODE_PI7 */
0, /* EA_MODE_PD */
0, /* EA_MODE_PD7 */
6, /* EA_MODE_DI */
10, /* EA_MODE_IX */
6, /* EA_MODE_AW */
8, /* EA_MODE_AL */
6, /* EA_MODE_PCDI */
10, /* EA_MODE_PCIX */
0, /* EA_MODE_I */
};
/* Extra cycles for LEA instruction (000, 010) */
int g_lea_cycle_table[13] =
{
0, /* EA_MODE_NONE */
4, /* EA_MODE_AI */
0, /* EA_MODE_PI */
0, /* EA_MODE_PI7 */
0, /* EA_MODE_PD */
0, /* EA_MODE_PD7 */
8, /* EA_MODE_DI */
12, /* EA_MODE_IX */
8, /* EA_MODE_AW */
12, /* EA_MODE_AL */
8, /* EA_MODE_PCDI */
12, /* EA_MODE_PCIX */
0, /* EA_MODE_I */
};
/* Extra cycles for PEA instruction (000, 010) */
int g_pea_cycle_table[13] =
{
0, /* EA_MODE_NONE */
6, /* EA_MODE_AI */
0, /* EA_MODE_PI */
0, /* EA_MODE_PI7 */
0, /* EA_MODE_PD */
0, /* EA_MODE_PD7 */
10, /* EA_MODE_DI */
14, /* EA_MODE_IX */
10, /* EA_MODE_AW */
14, /* EA_MODE_AL */
10, /* EA_MODE_PCDI */
14, /* EA_MODE_PCIX */
0, /* EA_MODE_I */
};
/* Extra cycles for MOVES instruction (010) */
int g_moves_cycle_table[13][3] =
{
{ 0, 0, 0}, /* EA_MODE_NONE */
{ 0, 4, 6}, /* EA_MODE_AI */
{ 0, 4, 6}, /* EA_MODE_PI */
{ 0, 4, 6}, /* EA_MODE_PI7 */
{ 0, 6, 12}, /* EA_MODE_PD */
{ 0, 6, 12}, /* EA_MODE_PD7 */
{ 0, 12, 16}, /* EA_MODE_DI */
{ 0, 16, 20}, /* EA_MODE_IX */
{ 0, 12, 16}, /* EA_MODE_AW */
{ 0, 16, 20}, /* EA_MODE_AL */
{ 0, 0, 0}, /* EA_MODE_PCDI */
{ 0, 0, 0}, /* EA_MODE_PCIX */
{ 0, 0, 0}, /* EA_MODE_I */
};
/* Extra cycles for CLR instruction (010) */
int g_clr_cycle_table[13][3] =
{
{ 0, 0, 0}, /* EA_MODE_NONE */
{ 0, 4, 6}, /* EA_MODE_AI */
{ 0, 4, 6}, /* EA_MODE_PI */
{ 0, 4, 6}, /* EA_MODE_PI7 */
{ 0, 6, 8}, /* EA_MODE_PD */
{ 0, 6, 8}, /* EA_MODE_PD7 */
{ 0, 8, 10}, /* EA_MODE_DI */
{ 0, 10, 14}, /* EA_MODE_IX */
{ 0, 8, 10}, /* EA_MODE_AW */
{ 0, 10, 14}, /* EA_MODE_AL */
{ 0, 0, 0}, /* EA_MODE_PCDI */
{ 0, 0, 0}, /* EA_MODE_PCIX */
{ 0, 0, 0}, /* EA_MODE_I */
};
/* ======================================================================== */
/* =========================== UTILITY FUNCTIONS ========================== */
/* ======================================================================== */
/* Print an error message and exit with status error */
void error_exit(char* fmt, ...)
{
va_list args;
fprintf(stderr, "In %s, near or on line %d:\n\t", g_input_filename, g_line_number);
va_start(args, fmt);
vfprintf(stderr, fmt, args);
va_end(args);
fprintf(stderr, "\n");
if(g_prototype_file) fclose(g_prototype_file);
if(g_table_file) fclose(g_table_file);
if(g_ops_ac_file) fclose(g_ops_ac_file);
if(g_ops_dm_file) fclose(g_ops_dm_file);
if(g_ops_nz_file) fclose(g_ops_nz_file);
if(g_input_file) fclose(g_input_file);
exit(EXIT_FAILURE);
}
/* Print an error message, call perror(), and exit with status error */
void perror_exit(char* fmt, ...)
{
va_list args;
va_start(args, fmt);
vfprintf(stderr, fmt, args);
va_end(args);
perror("");
if(g_prototype_file) fclose(g_prototype_file);
if(g_table_file) fclose(g_table_file);
if(g_ops_ac_file) fclose(g_ops_ac_file);
if(g_ops_dm_file) fclose(g_ops_dm_file);
if(g_ops_nz_file) fclose(g_ops_nz_file);
if(g_input_file) fclose(g_input_file);
exit(EXIT_FAILURE);
}
/* copy until 0 or space and exit with error if we read too far */
int check_strsncpy(char* dst, char* src, int maxlength)
{
char* p = dst;
while(*src && *src != ' ')
{
*p++ = *src++;
if(p - dst > maxlength)
error_exit("Field too long");
}
*p = 0;
return p - dst;
}
/* copy until 0 or specified character and exit with error if we read too far */
int check_strcncpy(char* dst, char* src, char delim, int maxlength)
{
char* p = dst;
while(*src && *src != delim)
{
*p++ = *src++;
if(p - dst > maxlength)
error_exit("Field too long");
}
*p = 0;
return p - dst;
}
/* convert ascii to integer and exit with error if we find invalid data */
int check_atoi(char* str, int *result)
{
int accum = 0;
char* p = str;
while(*p >= '0' && *p <= '9')
{
accum *= 10;
accum += *p++ - '0';
}
if(*p != ' ' && *p != 0)
error_exit("Malformed integer value (%c)", *p);
*result = accum;
return p - str;
}
/* Skip past spaces in a string */
int skip_spaces(char* str)
{
char* p = str;
while(*p == ' ')
p++;
return p - str;
}
/* Count the number of set bits in a value */
int num_bits(int value)
{
value = ((value & 0xaaaa) >> 1) + (value & 0x5555);
value = ((value & 0xcccc) >> 2) + (value & 0x3333);
value = ((value & 0xf0f0) >> 4) + (value & 0x0f0f);
value = ((value & 0xff00) >> 8) + (value & 0x00ff);
return value;
}
/* Convert a hex value written in ASCII */
int atoh(char* buff)
{
int accum = 0;
for(;;buff++)
{
if(*buff >= '0' && *buff <= '9')
{
accum <<= 4;
accum += *buff - '0';
}
else if(*buff >= 'a' && *buff <= 'f')
{
accum <<= 4;
accum += *buff - 'a' + 10;
}
else break;
}
return accum;
}
/* Get a line of text from a file, discarding any end-of-line characters */
int fgetline(char* buff, int nchars, FILE* file)
{
int length;
if(fgets(buff, nchars, file) == NULL)
return -1;
if(buff[0] == '\r')
memcpy(buff, buff + 1, nchars - 1);
length = strlen(buff);
while(length && (buff[length-1] == '\r' || buff[length-1] == '\n'))
length--;
buff[length] = 0;
g_line_number++;
return length;
}
/* ======================================================================== */
/* =========================== HELPER FUNCTIONS =========================== */
/* ======================================================================== */
/* Calculate the number of cycles an opcode requires */
int get_oper_cycles(opcode_struct* op, int ea_mode, int cpu_type)
{
int size = g_size_select_table[op->size];
if(op->cpus[cpu_type] == '.')
return 0;
if(cpu_type < CPU_TYPE_020)
{
if(cpu_type == CPU_TYPE_010)
{
if(strcmp(op->name, "moves") == 0)
return op->cycles[cpu_type] + g_moves_cycle_table[ea_mode][size];
if(strcmp(op->name, "clr") == 0)
return op->cycles[cpu_type] + g_clr_cycle_table[ea_mode][size];
}
/* ASG: added these cases -- immediate modes take 2 extra cycles here */
if(cpu_type == CPU_TYPE_000 && ea_mode == EA_MODE_I &&
((strcmp(op->name, "add") == 0 && strcmp(op->spec_proc, "er") == 0) ||
strcmp(op->name, "adda") == 0 ||
(strcmp(op->name, "and") == 0 && strcmp(op->spec_proc, "er") == 0) ||
(strcmp(op->name, "or") == 0 && strcmp(op->spec_proc, "er") == 0) ||
(strcmp(op->name, "sub") == 0 && strcmp(op->spec_proc, "er") == 0) ||
strcmp(op->name, "suba") == 0))
return op->cycles[cpu_type] + g_ea_cycle_table[ea_mode][cpu_type][size] + 2;
if(strcmp(op->name, "jmp") == 0)
return op->cycles[cpu_type] + g_jmp_cycle_table[ea_mode];
if(strcmp(op->name, "jsr") == 0)
return op->cycles[cpu_type] + g_jsr_cycle_table[ea_mode];
if(strcmp(op->name, "lea") == 0)
return op->cycles[cpu_type] + g_lea_cycle_table[ea_mode];
if(strcmp(op->name, "pea") == 0)
return op->cycles[cpu_type] + g_pea_cycle_table[ea_mode];
}
return op->cycles[cpu_type] + g_ea_cycle_table[ea_mode][cpu_type][size];
}
/* Find an opcode in the opcode handler list */
opcode_struct* find_opcode(char* name, int size, char* spec_proc, char* spec_ea)
{
opcode_struct* op;
for(op = g_opcode_input_table;op->name != NULL;op++)
{
if( strcmp(name, op->name) == 0 &&
(size == op->size) &&
strcmp(spec_proc, op->spec_proc) == 0 &&
strcmp(spec_ea, op->spec_ea) == 0)
return op;
}
return NULL;
}
/* Specifically find the illegal opcode in the list */
opcode_struct* find_illegal_opcode(void)
{
opcode_struct* op;
for(op = g_opcode_input_table;op->name != NULL;op++)
{
if(strcmp(op->name, "illegal") == 0)
return op;
}
return NULL;
}
/* Parse an opcode handler name */
int extract_opcode_info(char* src, char* name, int* size, char* spec_proc, char* spec_ea)
{
char* ptr = strstr(src, ID_OPHANDLER_NAME);
if(ptr == NULL)
return 0;
ptr += strlen(ID_OPHANDLER_NAME) + 1;
ptr += check_strcncpy(name, ptr, ',', MAX_NAME_LENGTH);
if(*ptr != ',') return 0;
ptr++;
ptr += skip_spaces(ptr);
*size = atoi(ptr);
ptr = strstr(ptr, ",");
if(ptr == NULL) return 0;
ptr++;
ptr += skip_spaces(ptr);
ptr += check_strcncpy(spec_proc, ptr, ',', MAX_SPEC_PROC_LENGTH);
if(*ptr != ',') return 0;
ptr++;
ptr += skip_spaces(ptr);
ptr += check_strcncpy(spec_ea, ptr, ')', MAX_SPEC_EA_LENGTH);
if(*ptr != ')') return 0;
ptr++;
ptr += skip_spaces(ptr);
return 1;
}
/* Add a search/replace pair to a replace structure */
void add_replace_string(replace_struct* replace, char* search_str, char* replace_str)
{
if(replace->length >= MAX_REPLACE_LENGTH)
error_exit("overflow in replace structure");
strcpy(replace->replace[replace->length][0], search_str);
strcpy(replace->replace[replace->length++][1], replace_str);
}
/* Write a function body while replacing any selected strings */
void write_body(FILE* filep, body_struct* body, replace_struct* replace)
{
int i;
int j;
char* ptr;
char output[MAX_LINE_LENGTH+1];
char temp_buff[MAX_LINE_LENGTH+1];
int found;
for(i=0;i<body->length;i++)
{
strcpy(output, body->body[i]);
/* Check for the base directive header */
if(strstr(output, ID_BASE) != NULL)
{
/* Search for any text we need to replace */
found = 0;
for(j=0;j<replace->length;j++)
{
ptr = strstr(output, replace->replace[j][0]);
if(ptr)
{
/* We found something to replace */
found = 1;
strcpy(temp_buff, ptr+strlen(replace->replace[j][0]));
strcpy(ptr, replace->replace[j][1]);
strcat(ptr, temp_buff);
}
}
/* Found a directive with no matching replace string */
if(!found)
error_exit("Unknown " ID_BASE " directive");
}
fprintf(filep, "%s\n", output);
}
fprintf(filep, "\n\n");
}
/* Generate a base function name from an opcode struct */
void get_base_name(char* base_name, opcode_struct* op)
{
sprintf(base_name, "m68k_op_%s", op->name);
if(op->size > 0)
sprintf(base_name+strlen(base_name), "_%d", op->size);
if(strcmp(op->spec_proc, UNSPECIFIED) != 0)
sprintf(base_name+strlen(base_name), "_%s", op->spec_proc);
if(strcmp(op->spec_ea, UNSPECIFIED) != 0)
sprintf(base_name+strlen(base_name), "_%s", op->spec_ea);
}
/* Write the prototype of an opcode handler function */
void write_prototype(FILE* filep, char* base_name)
{
fprintf(filep, "void %s(void);\n", base_name);
}
/* Write the name of an opcode handler function */
void write_function_name(FILE* filep, char* base_name)
{
fprintf(filep, "void %s(void)\n", base_name);
}
void add_opcode_output_table_entry(opcode_struct* op, char* name)
{
opcode_struct* ptr;
if(g_opcode_output_table_length > MAX_OPCODE_OUTPUT_TABLE_LENGTH)
error_exit("Opcode output table overflow");
ptr = g_opcode_output_table + g_opcode_output_table_length++;
*ptr = *op;
strcpy(ptr->name, name);
ptr->bits = num_bits(ptr->op_mask);
}
/*
* Comparison function for qsort()
* For entries with an equal number of set bits in
* the mask compare the match values
*/
static int DECL_SPEC compare_nof_true_bits(const void* aptr, const void* bptr)
{
const opcode_struct *a = aptr, *b = bptr;
if(a->bits != b->bits)
return a->bits - b->bits;
if(a->op_mask != b->op_mask)
return a->op_mask - b->op_mask;
return a->op_match - b->op_match;
}
void print_opcode_output_table(FILE* filep)
{
int i;
qsort((void *)g_opcode_output_table, g_opcode_output_table_length, sizeof(g_opcode_output_table[0]), compare_nof_true_bits);
for(i=0;i<g_opcode_output_table_length;i++)
write_table_entry(filep, g_opcode_output_table+i);
}
/* Write an entry in the opcode handler table */
void write_table_entry(FILE* filep, opcode_struct* op)
{
int i;
fprintf(filep, "\t{%-28s, 0x%04x, 0x%04x, {",
op->name, op->op_mask, op->op_match);
for(i=0;i<NUM_CPUS;i++)
{
fprintf(filep, "%3d", op->cycles[i]);
if(i < NUM_CPUS-1)
fprintf(filep, ", ");
}
fprintf(filep, "}},\n");
}
/* Fill out an opcode struct with a specific addressing mode of the source opcode struct */
void set_opcode_struct(opcode_struct* src, opcode_struct* dst, int ea_mode)
{
int i;
*dst = *src;
for(i=0;i<NUM_CPUS;i++)
dst->cycles[i] = get_oper_cycles(dst, ea_mode, i);
if(strcmp(dst->spec_ea, UNSPECIFIED) == 0 && ea_mode != EA_MODE_NONE)
sprintf(dst->spec_ea, "%s", g_ea_info_table[ea_mode].fname_add);
dst->op_mask |= g_ea_info_table[ea_mode].mask_add;
dst->op_match |= g_ea_info_table[ea_mode].match_add;
}
/* Generate a final opcode handler from the provided data */
void generate_opcode_handler(FILE* filep, body_struct* body, replace_struct* replace, opcode_struct* opinfo, int ea_mode)
{
char str[MAX_LINE_LENGTH+1];
opcode_struct* op = malloc(sizeof(opcode_struct));
/* Set the opcode structure and write the tables, prototypes, etc */
set_opcode_struct(opinfo, op, ea_mode);
get_base_name(str, op);
write_prototype(g_prototype_file, str);
add_opcode_output_table_entry(op, str);
write_function_name(filep, str);
/* Add any replace strings needed */
if(ea_mode != EA_MODE_NONE)
{
sprintf(str, "EA_%s_8()", g_ea_info_table[ea_mode].ea_add);
add_replace_string(replace, ID_OPHANDLER_EA_AY_8, str);
sprintf(str, "EA_%s_16()", g_ea_info_table[ea_mode].ea_add);
add_replace_string(replace, ID_OPHANDLER_EA_AY_16, str);
sprintf(str, "EA_%s_32()", g_ea_info_table[ea_mode].ea_add);
add_replace_string(replace, ID_OPHANDLER_EA_AY_32, str);
sprintf(str, "OPER_%s_8()", g_ea_info_table[ea_mode].ea_add);
add_replace_string(replace, ID_OPHANDLER_OPER_AY_8, str);
sprintf(str, "OPER_%s_16()", g_ea_info_table[ea_mode].ea_add);
add_replace_string(replace, ID_OPHANDLER_OPER_AY_16, str);
sprintf(str, "OPER_%s_32()", g_ea_info_table[ea_mode].ea_add);
add_replace_string(replace, ID_OPHANDLER_OPER_AY_32, str);
}
/* Now write the function body with the selected replace strings */
write_body(filep, body, replace);
g_num_functions++;
free(op);
}
/* Generate opcode variants based on available addressing modes */
void generate_opcode_ea_variants(FILE* filep, body_struct* body, replace_struct* replace, opcode_struct* op)
{
int old_length = replace->length;
/* No ea modes available for this opcode */
if(HAS_NO_EA_MODE(op->ea_allowed))
{
generate_opcode_handler(filep, body, replace, op, EA_MODE_NONE);
return;
}
/* Check for and create specific opcodes for each available addressing mode */
if(HAS_EA_AI(op->ea_allowed))
generate_opcode_handler(filep, body, replace, op, EA_MODE_AI);
replace->length = old_length;
if(HAS_EA_PI(op->ea_allowed))
{
generate_opcode_handler(filep, body, replace, op, EA_MODE_PI);
replace->length = old_length;
if(op->size == 8)
generate_opcode_handler(filep, body, replace, op, EA_MODE_PI7);
}
replace->length = old_length;
if(HAS_EA_PD(op->ea_allowed))
{
generate_opcode_handler(filep, body, replace, op, EA_MODE_PD);
replace->length = old_length;
if(op->size == 8)
generate_opcode_handler(filep, body, replace, op, EA_MODE_PD7);
}
replace->length = old_length;
if(HAS_EA_DI(op->ea_allowed))
generate_opcode_handler(filep, body, replace, op, EA_MODE_DI);
replace->length = old_length;
if(HAS_EA_IX(op->ea_allowed))
generate_opcode_handler(filep, body, replace, op, EA_MODE_IX);
replace->length = old_length;
if(HAS_EA_AW(op->ea_allowed))
generate_opcode_handler(filep, body, replace, op, EA_MODE_AW);
replace->length = old_length;
if(HAS_EA_AL(op->ea_allowed))
generate_opcode_handler(filep, body, replace, op, EA_MODE_AL);
replace->length = old_length;
if(HAS_EA_PCDI(op->ea_allowed))
generate_opcode_handler(filep, body, replace, op, EA_MODE_PCDI);
replace->length = old_length;
if(HAS_EA_PCIX(op->ea_allowed))
generate_opcode_handler(filep, body, replace, op, EA_MODE_PCIX);
replace->length = old_length;
if(HAS_EA_I(op->ea_allowed))
generate_opcode_handler(filep, body, replace, op, EA_MODE_I);
replace->length = old_length;
}
/* Generate variants of condition code opcodes */
void generate_opcode_cc_variants(FILE* filep, body_struct* body, replace_struct* replace, opcode_struct* op_in, int offset)
{
char repl[20];
char replnot[20];
int i;
int old_length = replace->length;
opcode_struct* op = malloc(sizeof(opcode_struct));
*op = *op_in;
op->op_mask |= 0x0f00;
/* Do all condition codes except t and f */
for(i=2;i<16;i++)
{
/* Add replace strings for this condition code */
sprintf(repl, "COND_%s()", g_cc_table[i][1]);
sprintf(replnot, "COND_NOT_%s()", g_cc_table[i][1]);
add_replace_string(replace, ID_OPHANDLER_CC, repl);
add_replace_string(replace, ID_OPHANDLER_NOT_CC, replnot);
/* Set the new opcode info */
strcpy(op->name+offset, g_cc_table[i][0]);
op->op_match = (op->op_match & 0xf0ff) | (i<<8);
/* Generate all opcode variants for this modified opcode */
generate_opcode_ea_variants(filep, body, replace, op);
/* Remove the above replace strings */
replace->length = old_length;
}
free(op);
}
/* Process the opcode handlers section of the input file */
void process_opcode_handlers(void)
{
FILE* input_file = g_input_file;
FILE* output_file;
char func_name[MAX_LINE_LENGTH+1];
char oper_name[MAX_LINE_LENGTH+1];
int oper_size;
char oper_spec_proc[MAX_LINE_LENGTH+1];
char oper_spec_ea[MAX_LINE_LENGTH+1];
opcode_struct* opinfo;
replace_struct* replace = malloc(sizeof(replace_struct));
body_struct* body = malloc(sizeof(body_struct));
output_file = g_ops_ac_file;
for(;;)
{
/* Find the first line of the function */
func_name[0] = 0;
while(strstr(func_name, ID_OPHANDLER_NAME) == NULL)
{
if(strcmp(func_name, ID_INPUT_SEPARATOR) == 0)
{
free(replace);
free(body);
return; /* all done */
}
if(fgetline(func_name, MAX_LINE_LENGTH, input_file) < 0)
error_exit("Premature end of file when getting function name");
}
/* Get the rest of the function */
for(body->length=0;;body->length++)
{
if(body->length > MAX_BODY_LENGTH)
error_exit("Function too long");
if(fgetline(body->body[body->length], MAX_LINE_LENGTH, input_file) < 0)
error_exit("Premature end of file when getting function body");
if(body->body[body->length][0] == '}')
{
body->length++;
break;
}
}
g_num_primitives++;
/* Extract the function name information */
if(!extract_opcode_info(func_name, oper_name, &oper_size, oper_spec_proc, oper_spec_ea))
error_exit("Invalid " ID_OPHANDLER_NAME " format");
/* Find the corresponding table entry */
opinfo = find_opcode(oper_name, oper_size, oper_spec_proc, oper_spec_ea);
if(opinfo == NULL)
error_exit("Unable to find matching table entry for %s", func_name);
/* Change output files if we pass 'c' or 'n' */
if(output_file == g_ops_ac_file && oper_name[0] > 'c')
output_file = g_ops_dm_file;
else if(output_file == g_ops_dm_file && oper_name[0] > 'm')
output_file = g_ops_nz_file;
replace->length = 0;
/* Generate opcode variants */
if(strcmp(opinfo->name, "bcc") == 0 || strcmp(opinfo->name, "scc") == 0)
generate_opcode_cc_variants(output_file, body, replace, opinfo, 1);
else if(strcmp(opinfo->name, "dbcc") == 0)
generate_opcode_cc_variants(output_file, body, replace, opinfo, 2);
else if(strcmp(opinfo->name, "trapcc") == 0)
generate_opcode_cc_variants(output_file, body, replace, opinfo, 4);
else
generate_opcode_ea_variants(output_file, body, replace, opinfo);
}
free(replace);
free(body);
}
/* Populate the opcode handler table from the input file */
void populate_table(void)
{
char* ptr;
char bitpattern[17];
opcode_struct* op;
char buff[MAX_LINE_LENGTH];
int i;
int temp;
buff[0] = 0;
/* Find the start of the table */
while(strcmp(buff, ID_TABLE_START) != 0)
if(fgetline(buff, MAX_LINE_LENGTH, g_input_file) < 0)
error_exit("Premature EOF while reading table");
/* Process the entire table */
for(op = g_opcode_input_table;;op++)
{
if(fgetline(buff, MAX_LINE_LENGTH, g_input_file) < 0)
error_exit("Premature EOF while reading table");
if(strlen(buff) == 0)
continue;
/* We finish when we find an input separator */
if(strcmp(buff, ID_INPUT_SEPARATOR) == 0)
break;
/* Extract the info from the table */
ptr = buff;
/* Name */
ptr += skip_spaces(ptr);
ptr += check_strsncpy(op->name, ptr, MAX_NAME_LENGTH);
/* Size */
ptr += skip_spaces(ptr);
ptr += check_atoi(ptr, &temp);
op->size = (unsigned char)temp;
/* Special processing */
ptr += skip_spaces(ptr);
ptr += check_strsncpy(op->spec_proc, ptr, MAX_SPEC_PROC_LENGTH);
/* Specified EA Mode */
ptr += skip_spaces(ptr);
ptr += check_strsncpy(op->spec_ea, ptr, MAX_SPEC_EA_LENGTH);
/* Bit Pattern (more processing later) */
ptr += skip_spaces(ptr);
ptr += check_strsncpy(bitpattern, ptr, 17);
/* Allowed Addressing Mode List */
ptr += skip_spaces(ptr);
ptr += check_strsncpy(op->ea_allowed, ptr, EA_ALLOWED_LENGTH);
/* CPU operating mode (U = user or supervisor, S = supervisor only */
ptr += skip_spaces(ptr);
for(i=0;i<NUM_CPUS;i++)
{
op->cpu_mode[i] = *ptr++;
ptr += skip_spaces(ptr);
}
/* Allowed CPUs for this instruction */
for(i=0;i<NUM_CPUS;i++)
{
ptr += skip_spaces(ptr);
if(*ptr == UNSPECIFIED_CH)
{
op->cpus[i] = UNSPECIFIED_CH;
op->cycles[i] = 0;
ptr++;
}
else
{
op->cpus[i] = '0' + i;
ptr += check_atoi(ptr, &temp);
op->cycles[i] = (unsigned char)temp;
}
}
/* generate mask and match from bitpattern */
op->op_mask = 0;
op->op_match = 0;
for(i=0;i<16;i++)
{
op->op_mask |= (bitpattern[i] != '.') << (15-i);
op->op_match |= (bitpattern[i] == '1') << (15-i);
}
}
/* Terminate the list */
op->name[0] = 0;
}
/* Read a header or footer insert from the input file */
void read_insert(char* insert)
{
char* ptr = insert;
char* overflow = insert + MAX_INSERT_LENGTH - MAX_LINE_LENGTH;
int length;
char* first_blank = NULL;
first_blank = NULL;
/* Skip any leading blank lines */
for(length = 0;length == 0;length = fgetline(ptr, MAX_LINE_LENGTH, g_input_file))
if(ptr >= overflow)
error_exit("Buffer overflow reading inserts");
if(length < 0)
error_exit("Premature EOF while reading inserts");
/* Advance and append newline */
ptr += length;
strcpy(ptr++, "\n");
/* Read until next separator */
for(;;)
{
/* Read a new line */
if(ptr >= overflow)
error_exit("Buffer overflow reading inserts");
if((length = fgetline(ptr, MAX_LINE_LENGTH, g_input_file)) < 0)
error_exit("Premature EOF while reading inserts");
/* Stop if we read a separator */
if(strcmp(ptr, ID_INPUT_SEPARATOR) == 0)
break;
/* keep track in case there are trailing blanks */
if(length == 0)
{
if(first_blank == NULL)
first_blank = ptr;
}
else
first_blank = NULL;
/* Advance and append newline */
ptr += length;
strcpy(ptr++, "\n");
}
/* kill any trailing blank lines */
if(first_blank)
ptr = first_blank;
*ptr++ = 0;
}
/* ======================================================================== */
/* ============================= MAIN FUNCTION ============================ */
/* ======================================================================== */
int main(int argc, char **argv)
{
/* File stuff */
char output_path[M68K_MAX_DIR] = "";
char filename[M68K_MAX_PATH];
/* Section identifier */
char section_id[MAX_LINE_LENGTH+1];
/* Inserts */
char temp_insert[MAX_INSERT_LENGTH+1];
char prototype_footer_insert[MAX_INSERT_LENGTH+1];
char table_footer_insert[MAX_INSERT_LENGTH+1];
char ophandler_footer_insert[MAX_INSERT_LENGTH+1];
/* Flags if we've processed certain parts already */
int prototype_header_read = 0;
int prototype_footer_read = 0;
int table_header_read = 0;
int table_footer_read = 0;
int ophandler_header_read = 0;
int ophandler_footer_read = 0;
int table_body_read = 0;
int ophandler_body_read = 0;
printf("\n\t\tMusashi v%s 68000, 68010, 68EC020, 68020 emulator\n", g_version);
printf("\t\tCopyright 1998-2000 Karl Stenerud ([email protected])\n\n");
/* Check if output path and source for the input file are given */
if(argc > 1)
{
char *ptr;
strcpy(output_path, argv[1]);
for(ptr = strchr(output_path, '\\'); ptr; ptr = strchr(ptr, '\\'))
*ptr = '/';
if(output_path[strlen(output_path)-1] != '/')
strcat(output_path, "/");
if(argc > 2)
strcpy(g_input_filename, argv[2]);
}
/* Open the files we need */
sprintf(filename, "%s%s", output_path, FILENAME_PROTOTYPE);
if((g_prototype_file = fopen(filename, "wt")) == NULL)
perror_exit("Unable to create prototype file (%s)\n", filename);
sprintf(filename, "%s%s", output_path, FILENAME_TABLE);
if((g_table_file = fopen(filename, "wt")) == NULL)
perror_exit("Unable to create table file (%s)\n", filename);
sprintf(filename, "%s%s", output_path, FILENAME_OPS_AC);
if((g_ops_ac_file = fopen(filename, "wt")) == NULL)
perror_exit("Unable to create ops ac file (%s)\n", filename);
sprintf(filename, "%s%s", output_path, FILENAME_OPS_DM);
if((g_ops_dm_file = fopen(filename, "wt")) == NULL)
perror_exit("Unable to create ops dm file (%s)\n", filename);
sprintf(filename, "%s%s", output_path, FILENAME_OPS_NZ);
if((g_ops_nz_file = fopen(filename, "wt")) == NULL)
perror_exit("Unable to create ops nz file (%s)\n", filename);
if((g_input_file=fopen(g_input_filename, "rt")) == NULL)
perror_exit("can't open %s for input", g_input_filename);
/* Get to the first section of the input file */
section_id[0] = 0;
while(strcmp(section_id, ID_INPUT_SEPARATOR) != 0)
if(fgetline(section_id, MAX_LINE_LENGTH, g_input_file) < 0)
error_exit("Premature EOF while reading input file");
/* Now process all sections */
for(;;)
{
if(fgetline(section_id, MAX_LINE_LENGTH, g_input_file) < 0)
error_exit("Premature EOF while reading input file");
if(strcmp(section_id, ID_PROTOTYPE_HEADER) == 0)
{
if(prototype_header_read)
error_exit("Duplicate prototype header");
read_insert(temp_insert);
fprintf(g_prototype_file, "%s\n\n", temp_insert);
prototype_header_read = 1;
}
else if(strcmp(section_id, ID_TABLE_HEADER) == 0)
{
if(table_header_read)
error_exit("Duplicate table header");
read_insert(temp_insert);
fprintf(g_table_file, "%s", temp_insert);
table_header_read = 1;
}
else if(strcmp(section_id, ID_OPHANDLER_HEADER) == 0)
{
if(ophandler_header_read)
error_exit("Duplicate opcode handler header");
read_insert(temp_insert);
fprintf(g_ops_ac_file, "%s\n\n", temp_insert);
fprintf(g_ops_dm_file, "%s\n\n", temp_insert);
fprintf(g_ops_nz_file, "%s\n\n", temp_insert);
ophandler_header_read = 1;
}
else if(strcmp(section_id, ID_PROTOTYPE_FOOTER) == 0)
{
if(prototype_footer_read)
error_exit("Duplicate prototype footer");
read_insert(prototype_footer_insert);
prototype_footer_read = 1;
}
else if(strcmp(section_id, ID_TABLE_FOOTER) == 0)
{
if(table_footer_read)
error_exit("Duplicate table footer");
read_insert(table_footer_insert);
table_footer_read = 1;
}
else if(strcmp(section_id, ID_OPHANDLER_FOOTER) == 0)
{
if(ophandler_footer_read)
error_exit("Duplicate opcode handler footer");
read_insert(ophandler_footer_insert);
ophandler_footer_read = 1;
}
else if(strcmp(section_id, ID_TABLE_BODY) == 0)
{
if(!prototype_header_read)
error_exit("Table body encountered before prototype header");
if(!table_header_read)
error_exit("Table body encountered before table header");
if(!ophandler_header_read)
error_exit("Table body encountered before opcode handler header");
if(table_body_read)
error_exit("Duplicate table body");
populate_table();
table_body_read = 1;
}
else if(strcmp(section_id, ID_OPHANDLER_BODY) == 0)
{
if(!prototype_header_read)
error_exit("Opcode handlers encountered before prototype header");
if(!table_header_read)
error_exit("Opcode handlers encountered before table header");
if(!ophandler_header_read)
error_exit("Opcode handlers encountered before opcode handler header");
if(!table_body_read)
error_exit("Opcode handlers encountered before table body");
if(ophandler_body_read)
error_exit("Duplicate opcode handler section");
process_opcode_handlers();
ophandler_body_read = 1;
}
else if(strcmp(section_id, ID_END) == 0)
{
/* End of input file. Do a sanity check and then write footers */
if(!prototype_header_read)
error_exit("Missing prototype header");
if(!prototype_footer_read)
error_exit("Missing prototype footer");
if(!table_header_read)
error_exit("Missing table header");
if(!table_footer_read)
error_exit("Missing table footer");
if(!table_body_read)
error_exit("Missing table body");
if(!ophandler_header_read)
error_exit("Missing opcode handler header");
if(!ophandler_footer_read)
error_exit("Missing opcode handler footer");
if(!ophandler_body_read)
error_exit("Missing opcode handler body");
print_opcode_output_table(g_table_file);
fprintf(g_prototype_file, "%s\n\n", prototype_footer_insert);
fprintf(g_table_file, "%s\n\n", table_footer_insert);
fprintf(g_ops_ac_file, "%s\n\n", ophandler_footer_insert);
fprintf(g_ops_dm_file, "%s\n\n", ophandler_footer_insert);
fprintf(g_ops_nz_file, "%s\n\n", ophandler_footer_insert);
break;
}
else
{
error_exit("Unknown section identifier: %s", section_id);
}
}
/* Close all files and exit */
fclose(g_prototype_file);
fclose(g_table_file);
fclose(g_ops_ac_file);
fclose(g_ops_dm_file);
fclose(g_ops_nz_file);
fclose(g_input_file);
printf("Generated %d opcode handlers from %d primitives\n", g_num_functions, g_num_primitives);
return 0;
}
/* ======================================================================== */
/* ============================== END OF FILE ============================= */
/* ======================================================================== */
|
the_stack_data/32323.c | #ifdef COMPILE_FOR_TEST
#include <assert.h>
#define assume(cond) assert(cond)
#endif
void main(int argc, char* argv[]) {
int x_0_0;//sh_buf.outcnt
int x_0_1;//sh_buf.outcnt
int x_0_2;//sh_buf.outcnt
int x_0_3;//sh_buf.outcnt
int x_0_4;//sh_buf.outcnt
int x_0_5;//sh_buf.outcnt
int x_1_0;//sh_buf.outbuf[0]
int x_1_1;//sh_buf.outbuf[0]
int x_2_0;//sh_buf.outbuf[1]
int x_2_1;//sh_buf.outbuf[1]
int x_3_0;//sh_buf.outbuf[2]
int x_3_1;//sh_buf.outbuf[2]
int x_4_0;//sh_buf.outbuf[3]
int x_4_1;//sh_buf.outbuf[3]
int x_5_0;//sh_buf.outbuf[4]
int x_5_1;//sh_buf.outbuf[4]
int x_6_0;//sh_buf.outbuf[5]
int x_7_0;//sh_buf.outbuf[6]
int x_8_0;//sh_buf.outbuf[7]
int x_9_0;//sh_buf.outbuf[8]
int x_10_0;//sh_buf.outbuf[9]
int x_11_0;//LOG_BUFSIZE
int x_11_1;//LOG_BUFSIZE
int x_12_0;//CREST_scheduler::lock_0
int x_12_1;//CREST_scheduler::lock_0
int x_12_2;//CREST_scheduler::lock_0
int x_12_3;//CREST_scheduler::lock_0
int x_12_4;//CREST_scheduler::lock_0
int x_13_0;//t3 T0
int x_14_0;//t2 T0
int x_15_0;//arg T0
int x_16_0;//functioncall::param T0
int x_16_1;//functioncall::param T0
int x_17_0;//buffered T0
int x_18_0;//functioncall::param T0
int x_18_1;//functioncall::param T0
int x_19_0;//functioncall::param T0
int x_19_1;//functioncall::param T0
int x_20_0;//functioncall::param T0
int x_20_1;//functioncall::param T0
int x_20_2;//functioncall::param T0
int x_20_3;//functioncall::param T0
int x_21_0;//functioncall::param T0
int x_21_1;//functioncall::param T0
int x_22_0;//direction T0
int x_23_0;//functioncall::param T0
int x_23_1;//functioncall::param T0
int x_24_0;//functioncall::param T0
int x_24_1;//functioncall::param T0
int x_25_0;//functioncall::param T0
int x_25_1;//functioncall::param T0
int x_26_0;//functioncall::param T0
int x_26_1;//functioncall::param T0
int x_27_0;//functioncall::param T0
int x_27_1;//functioncall::param T0
int x_28_0;//functioncall::param T0
int x_28_1;//functioncall::param T0
int x_29_0;//functioncall::param T0
int x_29_1;//functioncall::param T0
int x_30_0;//functioncall::param T0
int x_30_1;//functioncall::param T0
int x_31_0;//functioncall::param T0
int x_31_1;//functioncall::param T0
int x_32_0;//functioncall::param T0
int x_32_1;//functioncall::param T0
int x_33_0;//functioncall::param T0
int x_33_1;//functioncall::param T0
int x_34_0;//functioncall::param T0
int x_34_1;//functioncall::param T0
int x_35_0;//functioncall::param T1
int x_35_1;//functioncall::param T1
int x_36_0;//functioncall::param T1
int x_36_1;//functioncall::param T1
int x_37_0;//i T1
int x_37_1;//i T1
int x_37_2;//i T1
int x_38_0;//rv T1
int x_39_0;//rv T1
int x_40_0;//blocksize T1
int x_40_1;//blocksize T1
int x_41_0;//functioncall::param T1
int x_41_1;//functioncall::param T1
int x_41_2;//functioncall::param T1
int x_42_0;//apr_thread_mutex_lock::rv T1
int x_42_1;//apr_thread_mutex_lock::rv T1
int x_43_0;//functioncall::param T1
int x_43_1;//functioncall::param T1
int x_44_0;//status T1
int x_44_1;//status T1
int x_45_0;//functioncall::param T1
int x_45_1;//functioncall::param T1
int x_46_0;//functioncall::param T1
int x_46_1;//functioncall::param T1
int x_47_0;//functioncall::param T1
int x_47_1;//functioncall::param T1
int x_48_0;//functioncall::param T1
int x_48_1;//functioncall::param T1
int x_49_0;//functioncall::param T1
int x_49_1;//functioncall::param T1
int x_50_0;//functioncall::param T1
int x_50_1;//functioncall::param T1
int x_51_0;//functioncall::param T2
int x_51_1;//functioncall::param T2
int x_52_0;//functioncall::param T2
int x_52_1;//functioncall::param T2
int x_53_0;//i T2
int x_53_1;//i T2
int x_53_2;//i T2
int x_53_3;//i T2
int x_54_0;//rv T2
int x_55_0;//rv T2
int x_56_0;//blocksize T2
int x_56_1;//blocksize T2
int x_57_0;//functioncall::param T2
int x_57_1;//functioncall::param T2
int x_57_2;//functioncall::param T2
int x_58_0;//apr_thread_mutex_lock::rv T2
int x_58_1;//apr_thread_mutex_lock::rv T2
int x_59_0;//functioncall::param T2
int x_59_1;//functioncall::param T2
int x_60_0;//status T2
int x_60_1;//status T2
int x_61_0;//functioncall::param T2
int x_61_1;//functioncall::param T2
int x_62_0;//functioncall::param T2
int x_62_1;//functioncall::param T2
int x_63_0;//functioncall::param T2
int x_63_1;//functioncall::param T2
int x_64_0;//functioncall::param T2
int x_64_1;//functioncall::param T2
int x_65_0;//functioncall::param T2
int x_65_1;//functioncall::param T2
int x_65_2;//functioncall::param T2
int x_66_0;//functioncall::param T2
int x_66_1;//functioncall::param T2
int x_67_0;//functioncall::param T2
int x_67_1;//functioncall::param T2
int x_68_0;//functioncall::param T2
int x_68_1;//functioncall::param T2
T_0_0_0: x_0_0 = 0;
T_0_1_0: x_1_0 = 0;
T_0_2_0: x_2_0 = 0;
T_0_3_0: x_3_0 = 0;
T_0_4_0: x_4_0 = 0;
T_0_5_0: x_5_0 = 0;
T_0_6_0: x_6_0 = 0;
T_0_7_0: x_7_0 = 0;
T_0_8_0: x_8_0 = 0;
T_0_9_0: x_9_0 = 0;
T_0_10_0: x_10_0 = 0;
T_0_11_0: x_11_0 = 0;
T_0_12_0: x_13_0 = 37039856;
T_0_13_0: x_14_0 = 3726762592;
T_0_14_0: x_15_0 = 0;
T_0_15_0: x_16_0 = 1020629563;
T_0_16_0: x_16_1 = -1;
T_0_17_0: x_17_0 = 0;
T_0_18_0: x_18_0 = 1006034084;
T_0_19_0: x_18_1 = x_17_0;
T_0_20_0: x_19_0 = 1999221188;
T_0_21_0: x_19_1 = 97;
T_0_22_0: x_20_0 = 1497177492;
T_0_23_0: x_20_1 = 0;
T_0_24_0: x_21_0 = 1416233394;
T_0_25_0: x_21_1 = 0;
T_0_26_0: x_22_0 = -568209344;
T_0_27_0: x_23_0 = 89396061;
T_0_28_0: x_23_1 = x_22_0;
T_0_29_0: x_24_0 = 576477384;
T_0_30_0: x_24_1 = 0;
T_0_31_0: x_12_0 = -1;
T_0_32_0: x_0_1 = 5;
T_0_33_0: x_1_1 = 72;
T_0_34_0: x_2_1 = 69;
T_0_35_0: x_3_1 = 76;
T_0_36_0: x_4_1 = 76;
T_0_37_0: x_5_1 = 79;
T_0_38_0: x_25_0 = 446760853;
T_0_39_0: x_25_1 = 83;
T_0_40_0: x_26_0 = 1601487399;
T_0_41_0: x_26_1 = 1;
T_0_42_0: x_27_0 = 1847509048;
T_0_43_0: x_27_1 = 1;
T_0_44_0: x_28_0 = 2117579748;
T_0_45_0: x_28_1 = 1;
T_0_46_0: x_29_0 = 133459976;
T_0_47_0: x_29_1 = 82;
T_0_48_0: x_30_0 = 1239572466;
T_0_49_0: x_30_1 = 90;
T_0_50_0: x_31_0 = 1100452369;
T_0_51_0: x_31_1 = 1;
T_0_52_0: x_32_0 = 631772893;
T_0_53_0: x_32_1 = 1;
T_0_54_0: x_33_0 = 1401517582;
T_0_55_0: x_33_1 = 2;
T_0_56_0: x_34_0 = 2074949251;
T_0_57_0: x_34_1 = 2;
T_0_58_0: x_11_1 = 5;
T_1_59_1: x_35_0 = 200850048;
T_1_60_1: x_35_1 = x_27_1;
T_1_61_1: x_36_0 = 1052311651;
T_1_62_1: x_36_1 = x_28_1;
T_1_63_1: x_37_0 = 0;
T_1_64_1: x_38_0 = 519647745;
T_2_65_2: x_51_0 = 1186436776;
T_2_66_2: x_51_1 = x_33_1;
T_2_67_2: x_52_0 = 842002895;
T_2_68_2: x_52_1 = x_34_1;
T_2_69_2: x_53_0 = 0;
T_2_70_2: x_54_0 = 517546497;
T_1_71_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0) x_39_0 = -561141840;
T_1_72_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0) x_40_0 = 11174;
T_2_73_2: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0) x_55_0 = -561141840;
T_2_74_2: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0) x_56_0 = 11174;
T_2_75_2: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0) x_57_0 = 866693083;
T_2_76_2: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0) x_57_1 = x_0_1;
T_2_77_2: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && x_0_1 == x_57_1) x_58_0 = 0;
T_2_78_2: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && x_0_1 == x_57_1 && 0 == x_12_0 + 1) x_12_1 = 2;
T_2_79_2: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && x_0_1 == x_57_1 && 2 == x_12_1) x_58_1 = 0;
T_2_80_2: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && 2 == x_12_1) x_59_0 = 1770559939;
T_2_81_2: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && 2 == x_12_1) x_59_1 = 0;
T_2_82_2: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && 0 == x_59_1 && 2 == x_12_1) x_56_1 = x_57_1;
T_2_83_2: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && 0 == x_59_1 && 2 == x_12_1) x_20_2 = x_20_1 + x_56_1;
T_2_84_2: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && 0 == x_59_1 && 2 == x_12_1) x_57_2 = -1*x_56_1 + x_57_1;
T_2_85_2: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && x_57_2 <= 0 && 2 == x_12_1) x_60_0 = 0;
T_2_86_2: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && x_57_2 <= 0 && 2 == x_12_1) x_12_2 = -1;
T_2_87_2: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0) x_41_0 = 1366810604;
T_2_88_2: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0) x_41_1 = x_0_1;
T_2_89_2: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && x_0_1 == x_41_1) x_42_0 = 0;
T_2_90_2: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && x_57_2 <= 0) x_60_1 = 0;
T_1_91_1: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0) x_61_0 = 1333151044;
T_1_92_1: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0) x_61_1 = x_59_1;
T_1_93_1: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0) x_62_0 = 90688164;
T_1_94_1: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0) x_62_1 = x_61_1;
T_2_95_2: if (x_0_1 + x_52_1 > x_11_1 && x_0_1 != 0) x_0_2 = 0;
T_2_96_2: if (x_52_1 < x_11_1) x_63_0 = 2093212249;
T_2_97_2: if (x_52_1 < x_11_1) x_63_1 = 47995741988608;
T_2_98_2: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && x_0_1 == x_41_1 && 0 == x_12_2 + 1) x_12_3 = 1;
T_2_99_2: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && x_0_1 == x_41_1 && 1 == x_12_3) x_42_1 = 0;
T_2_100_2: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && 1 == x_12_3) x_43_0 = 2113683857;
T_2_101_2: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && 1 == x_12_3) x_43_1 = 0;
T_1_102_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && 0 == x_43_1 && 1 == x_12_3) x_40_1 = x_41_1;
T_1_103_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && 0 == x_43_1 && 1 == x_12_3) x_20_3 = x_20_2 + x_40_1;
T_1_104_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && 0 == x_43_1 && 1 == x_12_3) x_41_2 = -1*x_40_1 + x_41_1;
T_1_105_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && x_41_2 <= 0 && 1 == x_12_3) x_44_0 = 0;
T_1_106_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && x_41_2 <= 0 && 1 == x_12_3) x_12_4 = -1;
T_1_107_1: if (x_52_1 < x_11_1) x_64_0 = 974093007;
T_1_108_1: if (x_52_1 < x_11_1) x_64_1 = x_0_2 + x_52_1;
T_1_109_1: if (x_52_1 < x_11_1) x_53_1 = 0;
T_1_110_1: if (x_52_1 < x_11_1 && x_53_1 < x_51_1) x_65_0 = 540894157;
T_1_111_1: if (x_52_1 < x_11_1 && x_53_1 < x_51_1) x_65_1 = 47995741988608;
T_2_112_2: if (x_52_1 < x_11_1) x_53_2 = 1 + x_53_1;
T_2_113_2: if (x_52_1 < x_11_1 && x_53_2 < x_51_1) x_65_2 = 47995741988608;
T_2_114_2: if (x_52_1 < x_11_1) x_53_3 = 1 + x_53_2;
T_2_115_2: if (x_52_1 < x_11_1) x_66_0 = 2005667721;
T_2_116_2: if (x_52_1 < x_11_1) x_66_1 = 47995741988608;
T_2_117_2: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 != 0 && x_41_2 <= 0) x_44_1 = 0;
T_2_118_2: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0) x_45_0 = 1994722570;
T_2_119_2: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0) x_45_1 = x_43_1;
T_2_120_2: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0) x_46_0 = 1546928242;
T_2_121_2: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0) x_46_1 = x_45_1;
T_2_122_2: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0) x_0_3 = 0;
T_1_123_1: if (x_36_1 < x_11_1) x_47_0 = 1857405261;
T_1_124_1: if (x_36_1 < x_11_1) x_47_1 = 47995739887360;
T_1_125_1: if (x_36_1 < x_11_1) x_48_0 = 1344416415;
T_1_126_1: if (x_36_1 < x_11_1) x_48_1 = x_0_3 + x_36_1;
T_1_127_1: if (x_36_1 < x_11_1) x_37_1 = 0;
T_1_128_1: if (x_36_1 < x_11_1 && x_37_1 < x_35_1) x_49_0 = 815677988;
T_1_129_1: if (x_36_1 < x_11_1 && x_37_1 < x_35_1) x_49_1 = 47995739887360;
T_1_130_1: if (x_36_1 < x_11_1) x_37_2 = 1 + x_37_1;
T_1_131_1: if (x_36_1 < x_11_1) x_50_0 = 1946801323;
T_1_132_1: if (x_36_1 < x_11_1) x_50_1 = 47995739887360;
T_1_133_1: if (x_52_1 < x_11_1) x_0_4 = x_0_2 + x_52_1;
T_1_134_1: if (x_36_1 < x_11_1) x_0_5 = x_0_3 + x_36_1;
T_1_135_1: if (x_52_1 < x_11_1) x_67_0 = 1920893799;
T_1_136_1: if (x_52_1 < x_11_1) x_67_1 = 47995741988608;
T_1_137_1: if (x_52_1 < x_11_1) x_68_0 = 1262438841;
T_1_138_1: if (x_52_1 < x_11_1) x_68_1 = 47995741988608;
T_2_139_2: if (x_52_1 < x_11_1) assert(x_0_5 == x_64_1);
}
|
the_stack_data/34513758.c | #include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/reboot.h>
int main (int argc, char *argv[]) {
sync();
switch ((int)argv[argc < 2 ? 0 : 1][0] + geteuid()) {
case 'p':
reboot(RB_POWER_OFF);
break;
case 'r':
reboot(RB_AUTOBOOT);
break;
default:
printf("usage (as root): kpow r[eboot]|p[oweroff]\n");
return 1;
}
return 0;
}
|
the_stack_data/75137322.c | // RUN: %clang_cc1 -fsyntax-only -verify %s
struct AB{const char *a; const char*b;};
const char *foo(const struct AB *ab) {
return ab->a + 'b'; // expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
}
void f(const char *s) {
char *str = 0;
char *str2 = str + 'c'; // expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
const char *constStr = s + 'c'; // expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
str = 'c' + str;// expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
char strArr[] = "foo";
str = strArr + 'c'; // expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
char *strArr2[] = {"ac","dc"};
str = strArr2[0] + 'c'; // expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
struct AB ab;
constStr = foo(&ab) + 'c'; // expected-warning {{adding 'char' to a string pointer does not append to the string}} expected-note {{use array indexing to silence this warning}}
// no-warning
char c = 'c';
str = str + c;
str = c + str;
}
|
the_stack_data/311112.c | /* Derived from list07, with code expansion and no list_free()
*
* Bug in the evaluation of the (dummy) conditional expression
*
* Bug in the update of the current points-to information because the
* analysis of the conditional operator uses two separate context,
* "int_t" and "in_f", to analyze the true and false sub-expressions.
*
* Note: the points-to analysis is limited because information gained
* about c is not used for l, although c is initialized as l (see
* PointerValues).
*/
#include <stdlib.h>
struct cons_t;
typedef struct cons_t * list;
// empty list
const list nil = ((list) 0);
struct cons_t {
double value;
list next;
};
int list_len(list l)
{
int n = 0;
list c = l;
//while (c!=nil) {
if (c!=nil) {
// We know that c!=nil...
// but this does not impact the result... as c->next may be NULL!
c = (c==nil)? nil: c->next;
n++;
}
return n;
}
|
the_stack_data/151340.c | /*Write a program to convert decimal number in to binary number.*/
#include <stdio.h>
#include <math.h>
void main(){
float num, decimalPart, binDec=0, binaryConversion;
int integerPart,a,binInt=0,p1=0, p2=-1;
printf("Enter a number : ");
scanf("%f",&num);
integerPart=num;
decimalPart=num-integerPart;
// binary conversion of the integer part
while (integerPart !=0)
{
a=integerPart%2;
binInt=binInt+pow(10,p1)*a;
integerPart/=2;
p1++;
}
// binary conversion of the decimal part
while (p2> -4)
{
decimalPart=decimalPart*2;
if (decimalPart<1)
{
binDec=binDec+pow(10,p2)*0;
}
else if (decimalPart>=1){
binDec=binDec+pow(10,p2)*1;
decimalPart-=1;
}
p2--;
}
// overall binary conversion
binaryConversion=binInt+binDec;
printf("The Binary conversion of the number is %.3f\n", binaryConversion);
} |
the_stack_data/76700045.c | /*
* Copyright (c) 2010 Martin Decky
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/** @addtogroup genericdebug
* @{
*/
/**
* @file
* @brief Kernel instrumentation functions.
*/
#ifdef CONFIG_TRACE
#include <debug.h>
#include <symtab.h>
#include <errno.h>
#include <print.h>
void __cyg_profile_func_enter(void *fn, void *call_site)
{
const char *fn_sym = symtab_fmt_name_lookup((uintptr_t) fn);
const char *call_site_sym;
uintptr_t call_site_off;
if (symtab_name_lookup((uintptr_t) call_site, &call_site_sym,
&call_site_off) == EOK)
printf("%s()+%p->%s()\n", call_site_sym,
(void *) call_site_off, fn_sym);
else
printf("->%s()\n", fn_sym);
}
void __cyg_profile_func_exit(void *fn, void *call_site)
{
const char *fn_sym = symtab_fmt_name_lookup((uintptr_t) fn);
const char *call_site_sym;
uintptr_t call_site_off;
if (symtab_name_lookup((uintptr_t) call_site, &call_site_sym,
&call_site_off) == EOK)
printf("%s()+%p<-%s()\n", call_site_sym,
(void *) call_site_off, fn_sym);
else
printf("<-%s()\n", fn_sym);
}
#endif /* CONFIG_TRACE */
/** @}
*/
|
the_stack_data/58579.c | /*************************************************************************
> File Name: merge.c
> Author: answer
> Mail: [email protected]
> Created Time: 2021年12月20日 星期一 20时57分32秒
************************************************************************/
|
the_stack_data/125141729.c | /* Copyright (C) 2000 Free Software Foundation */
/* Contributed by Alexandre Oliva <[email protected]> */
int
foo ()
{
while (1)
{
int a;
char b;
/* gcse should not merge these asm statements, since their
output operands have different modes. */
__asm__("":"=r" (a)); __asm__("":"=r" (b));
if (b)
return a;
}
}
|
the_stack_data/139902.c | #include <stdio.h>
#include <math.h>
//Перемножить каждую цифру в числе.
int main(int argc, char const *argv[])
{
int n = 423;
int pr = 1;
for ( ; n > 0; n /= 10)
{
pr *= n % 10;
}
printf("%i\n", pr);
return 0;
} |
the_stack_data/215769006.c | #include <stdio.h>
#include <string.h>
void caesar (char message[], int key);
int main (void) {
char message[] = "Sp S rkn kcuon zoyzvo grkd droi gkxdon, droi gyven rkfocksn pckcdob rybcoc.";
//main function, sets what the message is and then trys all possible values of the key
for (int i=1; i<25; i++){
caesar (message, i);
}
return 0;
}
void caesar (char message[], int key) {
char messageOut[264];
//sets a dummy variable for the message
for (int j = 0; j<(int) strlen(message); j++){
messageOut[j] = message[j];
}
int i = 0;
while (message[i] !='\0'){
//shifts each character that exists. separates between capital and lower case letters
if(message[i] >= 'a'&& message[i]<='z'){
messageOut[i] = (message[i] - 'a'+key)%26 + 'a';
}
else if (message[i] >='A' && message[i] <='Z'){
messageOut[i] = (message[i] - 'A'+ key)%26 + 'A';
}
i++;
}
printf("%s \n ", messageOut);
}
|
the_stack_data/18887236.c | /* Set block of memory to constant */
memset(blk,val,size)
register char *blk;
register char val;
register unsigned size;
{
while(size-- != 0)
*blk++ = val;
}
/* Copy block of memory */
memcpy(dest,src,size)
register char *dest,*src;
register unsigned size;
{
while(size-- != 0)
*dest++ = *src++;
}
/* Compare two blocks of memory */
memcmp(a,b,size)
register char *a,*b;
register unsigned size;
{
while(size-- != 0)
if(*a++ != *b++)
return 1;
return 0;
}
|
the_stack_data/80635.c | #include<stdio.h>
#include<string.h>
#include<stdlib.h>
int length(char *c);
int main(){
char str[1000];
printf("文字列を入力してくだい： ");
scanf("%s",str);
//gets(str);
printf("文字列の長さは%dです。\n",length(str));
return 0;
}
int length(char *c){
int len=0;
while(c[len] != '\0'){
len++;
}
return len;
}
|
the_stack_data/188384.c | /*Exercise 4 - Functions
Implement the three functions minimum(), maximum() and multiply() below the main() function.
Do not change the code given in the main() function when you are implementing your solution.*/
#include <stdio.h>
int minimum(int no1,int no2);
int maximum(int no1,int no2);
int multiply(int no1,int no2);
int main() {
int no1, no2;
printf("Enter a value for no 1 : ");
scanf("%d", &no1);
printf("Enter a value for no 2 : ");
scanf("%d", &no2);
printf("%d ", minimum(no1, no2));
printf("%d ", maximum(no1, no2));
printf("%d ", multiply(no1, no2));
return 0;
}
int minimum(int no1,int no2)
{
if(no1>no2)
{
return no2;
}
else
{
return no1;
}
}
int maximum(int no1,int no2)
{
if(no1>no2)
{
return no1;
}
else
{
return no2;
}
}
int multiply(int no1,int no2)
{
return no1*no2;
} |
the_stack_data/666241.c | #include <pthread.h>
#include <stdio.h>
int i = 0;
// Note the return type: void*
void* incrementingThreadFunction(){
// TODO: increment i 1_000_000 times
for (int j = 0; j<1000000; j++)
i++;
return NULL;
}
void* decrementingThreadFunction(){
// TODO: decrement i 1_000_000 times
for (int j = 0; j<1000000; j++)
i--;
return NULL;
}
int main(){
// TODO: declare incrementingThread and decrementingThread (hint: google pthread_create)
pthread_t incrementingThread;
pthread_t decrementingThread;
pthread_create(&incrementingThread, NULL, incrementingThreadFunction, NULL);
pthread_create(&decrementingThread, NULL, decrementingThreadFunction, NULL);
pthread_join(incrementingThread, NULL);
pthread_join(decrementingThread, NULL);
printf("The magic number is: %d\n", i);
return 0;
}
|
the_stack_data/126703358.c | /* { dg-options { -nostartfiles below100.o -Tbelow100.ld -O2 } } */
/* { dg-final { scan-assembler "set1 B100,#7" } } */
typedef struct
{
unsigned char b0:1;
unsigned char b1:1;
unsigned char b2:1;
unsigned char b3:1;
unsigned char b4:1;
unsigned char b5:1;
unsigned char b6:1;
unsigned char b7:1;
} BitField;
char acDummy[0xf0] __attribute__ ((__BELOW100__));
BitField B100 __attribute__ ((__BELOW100__));
unsigned char *p = (unsigned char *) &B100;
void
Do (void)
{
B100.b7 = 1;
}
int
main (void)
{
*p = 0x34;
Do ();
return (*p == 0xb4) ? 0 : 1;
}
|
the_stack_data/234517811.c | #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 */
typedef scalar_t__ uint16_t ;
typedef scalar_t__ u_int ;
typedef int u_char ;
typedef int /*<<< orphan*/ netdissect_options ;
/* Variables and functions */
scalar_t__ const ETHER_ADDR_LEN ;
scalar_t__ EXTRACT_16BITS (int const*) ;
scalar_t__ EXTRACT_32BITS (int const*) ;
int /*<<< orphan*/ ND_PRINT (int /*<<< orphan*/ *) ;
int /*<<< orphan*/ ND_TCHECK2 (int const,scalar_t__ const) ;
#define OFPAT_ENQUEUE 140
#define OFPAT_OUTPUT 139
#define OFPAT_SET_DL_DST 138
#define OFPAT_SET_DL_SRC 137
#define OFPAT_SET_NW_DST 136
#define OFPAT_SET_NW_SRC 135
#define OFPAT_SET_NW_TOS 134
#define OFPAT_SET_TP_DST 133
#define OFPAT_SET_TP_SRC 132
#define OFPAT_SET_VLAN_PCP 131
#define OFPAT_SET_VLAN_VID 130
#define OFPAT_STRIP_VLAN 129
#define OFPAT_VENDOR 128
scalar_t__ OFPP_CONTROLLER ;
scalar_t__ OF_ACTION_HEADER_LEN ;
int /*<<< orphan*/ etheraddr_string (int /*<<< orphan*/ *,int const*) ;
int /*<<< orphan*/ ipaddr_string (int /*<<< orphan*/ *,int const*) ;
int /*<<< orphan*/ istr ;
int* of10_vendor_action_print (int /*<<< orphan*/ *,int const*,int const*,scalar_t__) ;
int /*<<< orphan*/ ofpat_str ;
int /*<<< orphan*/ ofpp_str ;
int /*<<< orphan*/ ofpq_str ;
int /*<<< orphan*/ pcp_str (int const) ;
int /*<<< orphan*/ tok2str (int /*<<< orphan*/ ,char*,scalar_t__) ;
int /*<<< orphan*/ tstr ;
int /*<<< orphan*/ vlan_str (scalar_t__) ;
__attribute__((used)) static const u_char *
of10_actions_print(netdissect_options *ndo,
const char *pfx, const u_char *cp, const u_char *ep,
u_int len)
{
const u_char *cp0 = cp;
const u_int len0 = len;
uint16_t type, alen, output_port;
while (len) {
u_char alen_bogus = 0, skip = 0;
if (len < OF_ACTION_HEADER_LEN)
goto invalid;
/* type */
ND_TCHECK2(*cp, 2);
type = EXTRACT_16BITS(cp);
cp += 2;
ND_PRINT((ndo, "%saction type %s", pfx, tok2str(ofpat_str, "invalid (0x%04x)", type)));
/* length */
ND_TCHECK2(*cp, 2);
alen = EXTRACT_16BITS(cp);
cp += 2;
ND_PRINT((ndo, ", len %u", alen));
/* On action size underrun/overrun skip the rest of the action list. */
if (alen < OF_ACTION_HEADER_LEN || alen > len)
goto invalid;
/* On action size inappropriate for the given type or invalid type just skip
* the current action, as the basic length constraint has been met. */
switch (type) {
case OFPAT_OUTPUT:
case OFPAT_SET_VLAN_VID:
case OFPAT_SET_VLAN_PCP:
case OFPAT_STRIP_VLAN:
case OFPAT_SET_NW_SRC:
case OFPAT_SET_NW_DST:
case OFPAT_SET_NW_TOS:
case OFPAT_SET_TP_SRC:
case OFPAT_SET_TP_DST:
alen_bogus = alen != 8;
break;
case OFPAT_SET_DL_SRC:
case OFPAT_SET_DL_DST:
case OFPAT_ENQUEUE:
alen_bogus = alen != 16;
break;
case OFPAT_VENDOR:
alen_bogus = alen % 8 != 0; /* already >= 8 so far */
break;
default:
skip = 1;
}
if (alen_bogus) {
ND_PRINT((ndo, " (bogus)"));
skip = 1;
}
if (skip) {
ND_TCHECK2(*cp, alen - 4);
cp += alen - 4;
goto next_action;
}
/* OK to decode the rest of the action structure */
switch (type) {
case OFPAT_OUTPUT:
/* port */
ND_TCHECK2(*cp, 2);
output_port = EXTRACT_16BITS(cp);
cp += 2;
ND_PRINT((ndo, ", port %s", tok2str(ofpp_str, "%u", output_port)));
/* max_len */
ND_TCHECK2(*cp, 2);
if (output_port == OFPP_CONTROLLER)
ND_PRINT((ndo, ", max_len %u", EXTRACT_16BITS(cp)));
cp += 2;
break;
case OFPAT_SET_VLAN_VID:
/* vlan_vid */
ND_TCHECK2(*cp, 2);
ND_PRINT((ndo, ", vlan_vid %s", vlan_str(EXTRACT_16BITS(cp))));
cp += 2;
/* pad */
ND_TCHECK2(*cp, 2);
cp += 2;
break;
case OFPAT_SET_VLAN_PCP:
/* vlan_pcp */
ND_TCHECK2(*cp, 1);
ND_PRINT((ndo, ", vlan_pcp %s", pcp_str(*cp)));
cp += 1;
/* pad */
ND_TCHECK2(*cp, 3);
cp += 3;
break;
case OFPAT_SET_DL_SRC:
case OFPAT_SET_DL_DST:
/* dl_addr */
ND_TCHECK2(*cp, ETHER_ADDR_LEN);
ND_PRINT((ndo, ", dl_addr %s", etheraddr_string(ndo, cp)));
cp += ETHER_ADDR_LEN;
/* pad */
ND_TCHECK2(*cp, 6);
cp += 6;
break;
case OFPAT_SET_NW_SRC:
case OFPAT_SET_NW_DST:
/* nw_addr */
ND_TCHECK2(*cp, 4);
ND_PRINT((ndo, ", nw_addr %s", ipaddr_string(ndo, cp)));
cp += 4;
break;
case OFPAT_SET_NW_TOS:
/* nw_tos */
ND_TCHECK2(*cp, 1);
ND_PRINT((ndo, ", nw_tos 0x%02x", *cp));
cp += 1;
/* pad */
ND_TCHECK2(*cp, 3);
cp += 3;
break;
case OFPAT_SET_TP_SRC:
case OFPAT_SET_TP_DST:
/* nw_tos */
ND_TCHECK2(*cp, 2);
ND_PRINT((ndo, ", tp_port %u", EXTRACT_16BITS(cp)));
cp += 2;
/* pad */
ND_TCHECK2(*cp, 2);
cp += 2;
break;
case OFPAT_ENQUEUE:
/* port */
ND_TCHECK2(*cp, 2);
ND_PRINT((ndo, ", port %s", tok2str(ofpp_str, "%u", EXTRACT_16BITS(cp))));
cp += 2;
/* pad */
ND_TCHECK2(*cp, 6);
cp += 6;
/* queue_id */
ND_TCHECK2(*cp, 4);
ND_PRINT((ndo, ", queue_id %s", tok2str(ofpq_str, "%u", EXTRACT_32BITS(cp))));
cp += 4;
break;
case OFPAT_VENDOR:
if (ep == (cp = of10_vendor_action_print(ndo, cp, ep, alen - 4)))
return ep; /* end of snapshot */
break;
case OFPAT_STRIP_VLAN:
/* pad */
ND_TCHECK2(*cp, 4);
cp += 4;
break;
} /* switch */
next_action:
len -= alen;
} /* while */
return cp;
invalid: /* skip the rest of actions */
ND_PRINT((ndo, "%s", istr));
ND_TCHECK2(*cp0, len0);
return cp0 + len0;
trunc:
ND_PRINT((ndo, "%s", tstr));
return ep;
} |
the_stack_data/122014637.c | /**
* Write a program to display name of week as per the number entered by the user.
*/
#include <stdio.h>
int main()
{
int num;
printf("Enter any number from 1 to 7: ");
scanf("%d", &num);
switch (num)
{
case 1:
printf("Sunday\n");
break;
case 2:
printf("Monday\n");
break;
case 3:
printf("Tuesday\n");
break;
case 4:
printf("Wednesday\n");
break;
case 5:
printf("Thursday\n");
break;
case 6:
printf("Friday\n");
break;
case 7:
printf("Saturday\n");
break;
default:
printf("Invalid Number\nTry Again\n");
}
return 0;
}
|
the_stack_data/211081163.c | #include<stdio.h>
#include<string.h>
void main()
{
char s[100],s1[100],s2[100];
printf("Enter 1st string : ");
scanf("%[^\n]s",&s1);
gets();
printf("Enter 2nd string : ");
scanf("%[^\n]s",&s2);
gets();
int l=strlen(s1);
int m=strlen(s2);
for(int i=0;i<l;i++)
{
s[i]=s1[i];
}int k=0;
for(int i=l;i<l+m;i++)
{
s[i]=s2[k];
k++;
}
puts(s);
}
|
the_stack_data/145452963.c | /*
* x86-32on64 signal handling routines
*
* Copyright 1999, 2005 Alexandre Julliard
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifdef __i386_on_x86_64__
#include "config.h"
#include "wine/port.h"
#include <assert.h>
#include <signal.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <sys/types.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#ifdef HAVE_MACHINE_SYSARCH_H
# include <machine/sysarch.h>
#endif
#ifdef HAVE_SYS_PARAM_H
# include <sys/param.h>
#endif
#ifdef HAVE_SYSCALL_H
# include <syscall.h>
#else
# ifdef HAVE_SYS_SYSCALL_H
# include <sys/syscall.h>
# endif
#endif
#ifdef HAVE_SYS_SIGNAL_H
# include <sys/signal.h>
#endif
#ifdef HAVE_SYS_UCONTEXT_H
# include <sys/ucontext.h>
#endif
#ifdef __APPLE__
# include <mach/mach.h>
#endif
#define NONAMELESSUNION
#define NONAMELESSSTRUCT
#include "ntstatus.h"
#define WIN32_NO_STATUS
#include "windef.h"
#include "winternl.h"
#include "wine/library.h"
#include "ntdll_misc.h"
#include "wine/exception.h"
#include "wine/debug.h"
#ifdef HAVE_VALGRIND_MEMCHECK_H
#include <valgrind/memcheck.h>
#endif
WINE_DEFAULT_DEBUG_CHANNEL(seh);
WINE_DECLARE_DEBUG_CHANNEL(relay);
/* not defined for x86, so copy the x86_64 definition */
typedef struct DECLSPEC_ALIGN(16) _M128A
{
ULONGLONG Low;
LONGLONG High;
} M128A;
typedef struct
{
WORD ControlWord;
WORD StatusWord;
BYTE TagWord;
BYTE Reserved1;
WORD ErrorOpcode;
DWORD ErrorOffset;
WORD ErrorSelector;
WORD Reserved2;
DWORD DataOffset;
WORD DataSelector;
WORD Reserved3;
DWORD MxCsr;
DWORD MxCsr_Mask;
M128A FloatRegisters[8];
M128A XmmRegisters[16];
BYTE Reserved4[96];
} XMM_SAVE_AREA32;
typedef struct DECLSPEC_ALIGN(16) _CONTEXT64 {
DWORD64 P1Home; /* 000 */
DWORD64 P2Home; /* 008 */
DWORD64 P3Home; /* 010 */
DWORD64 P4Home; /* 018 */
DWORD64 P5Home; /* 020 */
DWORD64 P6Home; /* 028 */
/* Control flags */
DWORD ContextFlags; /* 030 */
DWORD MxCsr; /* 034 */
/* Segment */
WORD SegCs; /* 038 */
WORD SegDs; /* 03a */
WORD SegEs; /* 03c */
WORD SegFs; /* 03e */
WORD SegGs; /* 040 */
WORD SegSs; /* 042 */
DWORD EFlags; /* 044 */
/* Debug */
DWORD64 Dr0; /* 048 */
DWORD64 Dr1; /* 050 */
DWORD64 Dr2; /* 058 */
DWORD64 Dr3; /* 060 */
DWORD64 Dr6; /* 068 */
DWORD64 Dr7; /* 070 */
/* Integer */
DWORD64 Rax; /* 078 */
DWORD64 Rcx; /* 080 */
DWORD64 Rdx; /* 088 */
DWORD64 Rbx; /* 090 */
DWORD64 Rsp; /* 098 */
DWORD64 Rbp; /* 0a0 */
DWORD64 Rsi; /* 0a8 */
DWORD64 Rdi; /* 0b0 */
DWORD64 R8; /* 0b8 */
DWORD64 R9; /* 0c0 */
DWORD64 R10; /* 0c8 */
DWORD64 R11; /* 0d0 */
DWORD64 R12; /* 0d8 */
DWORD64 R13; /* 0e0 */
DWORD64 R14; /* 0e8 */
DWORD64 R15; /* 0f0 */
/* Counter */
DWORD64 Rip; /* 0f8 */
/* Floating point */
union {
XMM_SAVE_AREA32 FltSave; /* 100 */
struct {
M128A Header[2]; /* 100 */
M128A Legacy[8]; /* 120 */
M128A Xmm0; /* 1a0 */
M128A Xmm1; /* 1b0 */
M128A Xmm2; /* 1c0 */
M128A Xmm3; /* 1d0 */
M128A Xmm4; /* 1e0 */
M128A Xmm5; /* 1f0 */
M128A Xmm6; /* 200 */
M128A Xmm7; /* 210 */
M128A Xmm8; /* 220 */
M128A Xmm9; /* 230 */
M128A Xmm10; /* 240 */
M128A Xmm11; /* 250 */
M128A Xmm12; /* 260 */
M128A Xmm13; /* 270 */
M128A Xmm14; /* 280 */
M128A Xmm15; /* 290 */
} DUMMYSTRUCTNAME;
} DUMMYUNIONNAME;
/* Vector */
M128A VectorRegister[26]; /* 300 */
DWORD64 VectorControl; /* 4a0 */
/* Debug control */
DWORD64 DebugControl; /* 4a8 */
DWORD64 LastBranchToRip; /* 4b0 */
DWORD64 LastBranchFromRip; /* 4b8 */
DWORD64 LastExceptionToRip; /* 4c0 */
DWORD64 LastExceptionFromRip; /* 4c8 */
} CONTEXT64;
/***********************************************************************
* signal context platform-specific definitions
*/
#ifdef linux
#include <asm/prctl.h>
static inline int arch_prctl( int func, void *ptr ) { return syscall( __NR_arch_prctl, func, ptr ); }
#define RAX_sig(context) ((context)->uc_mcontext.gregs[REG_RAX])
#define RBX_sig(context) ((context)->uc_mcontext.gregs[REG_RBX])
#define RCX_sig(context) ((context)->uc_mcontext.gregs[REG_RCX])
#define RDX_sig(context) ((context)->uc_mcontext.gregs[REG_RDX])
#define RSI_sig(context) ((context)->uc_mcontext.gregs[REG_RSI])
#define RDI_sig(context) ((context)->uc_mcontext.gregs[REG_RDI])
#define RBP_sig(context) ((context)->uc_mcontext.gregs[REG_RBP])
#define R8_sig(context) ((context)->uc_mcontext.gregs[REG_R8])
#define R9_sig(context) ((context)->uc_mcontext.gregs[REG_R9])
#define R10_sig(context) ((context)->uc_mcontext.gregs[REG_R10])
#define R11_sig(context) ((context)->uc_mcontext.gregs[REG_R11])
#define R12_sig(context) ((context)->uc_mcontext.gregs[REG_R12])
#define R13_sig(context) ((context)->uc_mcontext.gregs[REG_R13])
#define R14_sig(context) ((context)->uc_mcontext.gregs[REG_R14])
#define R15_sig(context) ((context)->uc_mcontext.gregs[REG_R15])
#define CS_sig(context) (*((WORD *)&(context)->uc_mcontext.gregs[REG_CSGSFS] + 0))
#define GS_sig(context) (*((WORD *)&(context)->uc_mcontext.gregs[REG_CSGSFS] + 1))
#define FS_sig(context) (*((WORD *)&(context)->uc_mcontext.gregs[REG_CSGSFS] + 2))
#define RSP_sig(context) ((context)->uc_mcontext.gregs[REG_RSP])
#define RIP_sig(context) ((context)->uc_mcontext.gregs[REG_RIP])
#define EFL_sig(context) ((context)->uc_mcontext.gregs[REG_EFL])
#define TRAP_sig(context) ((context)->uc_mcontext.gregs[REG_TRAPNO])
#define ERROR_sig(context) ((context)->uc_mcontext.gregs[REG_ERR])
#define FPU_sig(context) ((XMM_SAVE_AREA32 * HOSTPTR)((context)->uc_mcontext.fpregs))
#elif defined (__APPLE__)
#if defined(MAC_OS_X_VERSION_10_15) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_15
typedef _STRUCT_MCONTEXT64_FULL *wine_mcontext;
#else
typedef struct
{
x86_thread_state64_t __ss64;
__uint64_t __ds;
__uint64_t __es;
__uint64_t __ss;
__uint64_t __gsbase;
} wine_thread_state;
typedef struct
{
x86_exception_state64_t __es;
wine_thread_state __ss;
x86_float_state64_t __fs;
} * HOSTPTR wine_mcontext;
#endif
#define RAX_sig(context) (((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__rax)
#define RBX_sig(context) (((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__rbx)
#define RCX_sig(context) (((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__rcx)
#define RDX_sig(context) (((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__rdx)
#define RSI_sig(context) (((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__rsi)
#define RDI_sig(context) (((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__rdi)
#define RBP_sig(context) (((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__rbp)
#define R8_sig(context) (((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__r8)
#define R9_sig(context) (((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__r9)
#define R10_sig(context) (((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__r10)
#define R11_sig(context) (((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__r11)
#define R12_sig(context) (((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__r12)
#define R13_sig(context) (((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__r13)
#define R14_sig(context) (((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__r14)
#define R15_sig(context) (((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__r15)
#define CS_sig(context) (*(WORD* HOSTPTR)&((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__cs)
#define DS_sig(context) (*(WORD* HOSTPTR)&((wine_mcontext)(context)->uc_mcontext)->__ss.__ds)
#define ES_sig(context) (*(WORD* HOSTPTR)&((wine_mcontext)(context)->uc_mcontext)->__ss.__es)
#define SS_sig(context) (*(WORD* HOSTPTR)&((wine_mcontext)(context)->uc_mcontext)->__ss.__ss)
#define FS_sig(context) (*(WORD* HOSTPTR)&((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__fs)
#define GS_sig(context) (*(WORD* HOSTPTR)&((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__gs)
#define EFL_sig(context) (((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__rflags)
#define RIP_sig(context) (*((unsigned long* HOSTPTR)&((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__rip))
#define RSP_sig(context) (*((unsigned long* HOSTPTR)&((wine_mcontext)(context)->uc_mcontext)->__ss.__ss64.__rsp))
#define TRAP_sig(context) (((wine_mcontext)(context)->uc_mcontext)->__es.__trapno)
#define ERROR_sig(context) (((wine_mcontext)(context)->uc_mcontext)->__es.__err)
#define FPU_sig(context) ((XMM_SAVE_AREA32 * HOSTPTR)&((wine_mcontext)(context)->uc_mcontext)->__fs.__fpu_fcw)
#else
#error You must define the signal context functions for your platform
#endif
/* stack layout when calling an exception raise function */
struct stack_layout
{
DWORD return_address;
DWORD return_sel;
DWORD padding[2];
CONTEXT64 context64;
CONTEXT context;
EXCEPTION_RECORD rec;
ULONG64 red_zone[16];
};
C_ASSERT( sizeof(struct stack_layout) % 16 == 0 );
typedef int (*wine_signal_handler)(unsigned int sig);
static const size_t teb_size = 4096; /* we reserve one page for the TEB */
static size_t signal_stack_mask;
static size_t signal_stack_size;
static wine_signal_handler handlers[256];
extern void DECLSPEC_NORETURN __wine_syscall_dispatcher( void );
extern NTSTATUS WINAPI __syscall_NtGetContextThread( HANDLE handle, CONTEXT *context );
/* convert from straight ASCII to Unicode without depending on the current codepage */
static inline void ascii_to_unicode( WCHAR *dst, const char *src, size_t len )
{
while (len--) *dst++ = (unsigned char)*src++;
}
static void* WINAPI __wine_fakedll_dispatcher( const char *module, ULONG ord )
{
UNICODE_STRING name;
NTSTATUS status;
HMODULE base;
WCHAR *moduleW;
void *proc = NULL;
DWORD len = strlen(module);
TRACE( "(%s, %u)\n", debugstr_a(module), ord );
if (!(moduleW = RtlAllocateHeap( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) )))
return NULL;
ascii_to_unicode( moduleW, module, len );
moduleW[ len ] = 0;
RtlInitUnicodeString( &name, moduleW );
status = LdrGetDllHandle( NULL, 0, &name, &base );
if (status == STATUS_DLL_NOT_FOUND)
status = LdrLoadDll( NULL, 0, &name, &base );
if (status == STATUS_SUCCESS)
status = LdrAddRefDll( LDR_ADDREF_DLL_PIN, base );
if (status == STATUS_SUCCESS)
status = LdrGetProcedureAddress( base, NULL, ord, &proc );
if (status)
FIXME( "No procedure address found for %s.#%u, status %x\n", debugstr_a(module), ord, status );
RtlFreeHeap( GetProcessHeap(), 0, moduleW );
return proc;
}
enum i386_trap_code
{
TRAP_x86_UNKNOWN = -1, /* Unknown fault (TRAP_sig not defined) */
TRAP_x86_DIVIDE = 0, /* Division by zero exception */
TRAP_x86_TRCTRAP = 1, /* Single-step exception */
TRAP_x86_NMI = 2, /* NMI interrupt */
TRAP_x86_BPTFLT = 3, /* Breakpoint exception */
TRAP_x86_OFLOW = 4, /* Overflow exception */
TRAP_x86_BOUND = 5, /* Bound range exception */
TRAP_x86_PRIVINFLT = 6, /* Invalid opcode exception */
TRAP_x86_DNA = 7, /* Device not available exception */
TRAP_x86_DOUBLEFLT = 8, /* Double fault exception */
TRAP_x86_FPOPFLT = 9, /* Coprocessor segment overrun */
TRAP_x86_TSSFLT = 10, /* Invalid TSS exception */
TRAP_x86_SEGNPFLT = 11, /* Segment not present exception */
TRAP_x86_STKFLT = 12, /* Stack fault */
TRAP_x86_PROTFLT = 13, /* General protection fault */
TRAP_x86_PAGEFLT = 14, /* Page fault */
TRAP_x86_ARITHTRAP = 16, /* Floating point exception */
TRAP_x86_ALIGNFLT = 17, /* Alignment check exception */
TRAP_x86_MCHK = 18, /* Machine check exception */
TRAP_x86_CACHEFLT = 19 /* SIMD exception (via SIGFPE) if CPU is SSE capable
otherwise Cache flush exception (via SIGSEV) */
};
struct x86_thread_data
{
DWORD fs; /* 1d4 TEB selector */
DWORD gs; /* 1d8 libc selector; update winebuild if you move this! */
DWORD dr0; /* 1dc debug registers */
DWORD dr1; /* 1e0 */
DWORD dr2; /* 1e4 */
DWORD dr3; /* 1e8 */
DWORD dr6; /* 1ec */
DWORD dr7; /* 1f0 */
void * HOSTPTR exit_frame; /* 1f4 exit frame pointer */
/* the ntdll_thread_data structure follows here */
};
C_ASSERT( offsetof( TEB, SystemReserved2 ) + offsetof( struct x86_thread_data, gs ) == 0x1d8 );
C_ASSERT( offsetof( TEB, SystemReserved2 ) + offsetof( struct x86_thread_data, exit_frame ) == 0x1f4 );
static inline struct x86_thread_data *x86_thread_data(void)
{
return (struct x86_thread_data *)NtCurrentTeb()->SystemReserved2;
}
/* Exception record for handling exceptions happening inside exception handlers */
typedef struct
{
EXCEPTION_REGISTRATION_RECORD frame;
EXCEPTION_REGISTRATION_RECORD *prevFrame;
} EXC_NESTED_FRAME;
extern DWORD CDECL EXC_CallHandler( EXCEPTION_RECORD *record, EXCEPTION_REGISTRATION_RECORD *frame,
CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **dispatcher,
PEXCEPTION_HANDLER handler, PEXCEPTION_HANDLER nested_handler );
/***********************************************************************
* dispatch_signal
*/
static inline int dispatch_signal(unsigned int sig)
{
if (handlers[sig] == NULL) return 0;
return handlers[sig](sig);
}
/***********************************************************************
* get_trap_code
*
* Get the trap code for a signal.
*/
static inline enum i386_trap_code get_trap_code( const ucontext_t *sigcontext )
{
#ifdef TRAP_sig
return TRAP_sig(sigcontext);
#else
return TRAP_x86_UNKNOWN; /* unknown trap code */
#endif
}
/***********************************************************************
* get_error_code
*
* Get the error code for a signal.
*/
static inline WORD get_error_code( const ucontext_t *sigcontext )
{
#ifdef ERROR_sig
return ERROR_sig(sigcontext);
#else
return 0;
#endif
}
/***********************************************************************
* get_signal_stack
*
* Get the base of the signal stack for the current thread.
*/
static inline void *get_signal_stack(void)
{
return (char *)NtCurrentTeb() + 4096;
}
/***********************************************************************
* get_current_teb
*
* Get the current teb based on the stack pointer.
*/
static inline TEB *get_current_teb(void)
{
unsigned long rsp;
__asm__("movq %%rsp,%0" : "=g" (rsp) );
return (TEB *)(DWORD)(rsp & ~signal_stack_mask);
}
/*******************************************************************
* is_valid_frame
*/
static inline BOOL is_valid_frame( void *frame )
{
if ((ULONG_PTR)frame & 3) return FALSE;
return (frame >= NtCurrentTeb()->Tib.StackLimit &&
(void **)frame < (void **)NtCurrentTeb()->Tib.StackBase - 1);
}
static inline int sel_is_64bit( unsigned short sel )
{
return sel != wine_32on64_cs32 && sel != wine_32on64_ds32 &&
wine_ldt_is_system( sel );
}
/*******************************************************************
* raise_handler
*
* Handler for exceptions happening inside a handler.
*/
static DWORD CDECL raise_handler( EXCEPTION_RECORD *rec, EXCEPTION_REGISTRATION_RECORD *frame,
CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **dispatcher )
{
if (rec->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND))
return ExceptionContinueSearch;
/* We shouldn't get here so we store faulty frame in dispatcher */
*dispatcher = ((EXC_NESTED_FRAME*)frame)->prevFrame;
return ExceptionNestedException;
}
/*******************************************************************
* unwind_handler
*
* Handler for exceptions happening inside an unwind handler.
*/
static DWORD CDECL unwind_handler( EXCEPTION_RECORD *rec, EXCEPTION_REGISTRATION_RECORD *frame,
CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **dispatcher )
{
if (!(rec->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND)))
return ExceptionContinueSearch;
/* We shouldn't get here so we store faulty frame in dispatcher */
*dispatcher = ((EXC_NESTED_FRAME*)frame)->prevFrame;
return ExceptionCollidedUnwind;
}
/**********************************************************************
* call_stack_handlers
*
* Call the stack handlers chain.
*/
static NTSTATUS call_stack_handlers( EXCEPTION_RECORD *rec, CONTEXT *context )
{
EXCEPTION_REGISTRATION_RECORD *frame, *dispatch, *nested_frame;
DWORD res;
frame = NtCurrentTeb()->Tib.ExceptionList;
nested_frame = NULL;
while (frame != (EXCEPTION_REGISTRATION_RECORD*)~0UL)
{
/* Check frame address */
if (!is_valid_frame( frame ))
{
rec->ExceptionFlags |= EH_STACK_INVALID;
break;
}
/* Call handler */
TRACE( "calling handler at %p code=%x flags=%x\n",
frame->Handler, rec->ExceptionCode, rec->ExceptionFlags );
res = WINE_CALL_IMPL32(EXC_CallHandler)( rec, frame, context, &dispatch, frame->Handler, raise_handler );
TRACE( "handler at %p returned %x\n", frame->Handler, res );
if (frame == nested_frame)
{
/* no longer nested */
nested_frame = NULL;
rec->ExceptionFlags &= ~EH_NESTED_CALL;
}
switch(res)
{
case ExceptionContinueExecution:
if (!(rec->ExceptionFlags & EH_NONCONTINUABLE)) return STATUS_SUCCESS;
return STATUS_NONCONTINUABLE_EXCEPTION;
case ExceptionContinueSearch:
break;
case ExceptionNestedException:
if (nested_frame < dispatch) nested_frame = dispatch;
rec->ExceptionFlags |= EH_NESTED_CALL;
break;
default:
return STATUS_INVALID_DISPOSITION;
}
frame = frame->Prev;
}
return STATUS_UNHANDLED_EXCEPTION;
}
/***********************************************************************
* fake_32bit_exception_code[_wrapper]
*
* Some 32-bit code to stand in as the location of an exception that
* actually occurred in 64-bit code. It just far returns back to 64-bit
* to restore the original 64-bit state at the point of the exception.
*/
extern void DECLSPEC_HIDDEN fake_32bit_exception_code(void) asm("fake_32bit_exception_code");
__ASM_GLOBAL_FUNC32( fake_32bit_exception_code_wrapper,
".skip 5, 0x90\n" /* nop */
"fake_32bit_exception_code:\n\t"
".skip 5, 0x90\n\t" /* nop */
"lretl" );
/*******************************************************************
* raise_exception
*
* Implementation of NtRaiseException.
*/
static NTSTATUS raise_exception( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
{
NTSTATUS status;
if (first_chance)
{
DWORD c;
TRACE( "code=%x flags=%x addr=%p ip=%08x tid=%04x\n",
rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress,
context->Eip, GetCurrentThreadId() );
for (c = 0; c < rec->NumberParameters; c++)
TRACE( " info[%d]=%08x\n", c, rec->ExceptionInformation[c] );
if (rec->ExceptionCode == EXCEPTION_WINE_STUB)
{
if (rec->ExceptionInformation[1] >> 16)
MESSAGE( "wine: Call from %p to unimplemented function %s.%s, aborting\n",
rec->ExceptionAddress,
(char*)rec->ExceptionInformation[0], (char*)rec->ExceptionInformation[1] );
else
MESSAGE( "wine: Call from %p to unimplemented function %s.%d, aborting\n",
rec->ExceptionAddress,
(char*)rec->ExceptionInformation[0], rec->ExceptionInformation[1] );
}
else
{
TRACE(" eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x\n",
context->Eax, context->Ebx, context->Ecx,
context->Edx, context->Esi, context->Edi );
TRACE(" ebp=%08x esp=%08x cs=%04x ds=%04x es=%04x fs=%04x gs=%04x flags=%08x\n",
context->Ebp, context->Esp, context->SegCs, context->SegDs,
context->SegEs, context->SegFs, context->SegGs, context->EFlags );
if (context->Eip == (DWORD)fake_32bit_exception_code)
{
CONTEXT64 *context64 = (CONTEXT64*)context->Edi;
TRACE(" underlying 64-bit state:\n");
TRACE(" rip=%016lx\n", context64->Rip );
TRACE(" rax=%016lx rbx=%016lx rcx=%016lx rdx=%016lx\n",
context64->Rax, context64->Rbx, context64->Rcx, context64->Rdx );
TRACE(" rsi=%016lx rdi=%016lx rbp=%016lx rsp=%016lx\n",
context64->Rsi, context64->Rdi, context64->Rbp, context64->Rsp );
TRACE(" r8=%016lx r9=%016lx r10=%016lx r11=%016lx\n",
context64->R8, context64->R9, context64->R10, context64->R11 );
TRACE(" r12=%016lx r13=%016lx r14=%016lx r15=%016lx\n",
context64->R12, context64->R13, context64->R14, context64->R15 );
}
}
/* fix up instruction pointer in context for EXCEPTION_BREAKPOINT */
if (rec->ExceptionCode == EXCEPTION_BREAKPOINT) context->Eip--;
if (call_vectored_handlers( rec, context ) == EXCEPTION_CONTINUE_EXECUTION) goto done;
if ((status = call_stack_handlers( rec, context )) == STATUS_SUCCESS) goto done;
if (status != STATUS_UNHANDLED_EXCEPTION) return status;
}
/* last chance exception */
status = send_debug_event( rec, FALSE, context );
if (status != DBG_CONTINUE)
{
if (rec->ExceptionFlags & EH_STACK_INVALID)
WINE_ERR("Exception frame is not in stack limits => unable to dispatch exception.\n");
else if (rec->ExceptionCode == STATUS_NONCONTINUABLE_EXCEPTION)
WINE_ERR("Process attempted to continue execution after noncontinuable exception.\n");
else
WINE_ERR("Unhandled exception code %x flags %x addr %p\n",
rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress );
NtTerminateProcess( NtCurrentProcess(), rec->ExceptionCode );
}
done:
return NtSetContextThread( GetCurrentThread(), context );
}
/***********************************************************************
* init_handler
*
* Handler initialization when the full context is not needed.
* Return the stack pointer to use for pushing the exception data.
*/
static inline void init_handler( const ucontext_t *sigcontext )
{
TEB *teb = get_current_teb();
struct x86_thread_data *thread_data = (struct x86_thread_data *)teb->SystemReserved2;
wine_set_fs( thread_data->fs );
/* Don't set %gs. That would corrupt the 64-bit GS.base and have no other effect. */
__asm__ volatile ( "mov %0, %%ds\n\t"
"mov %0, %%es\n\t"
: : "r" (wine_32on64_ds32) );
if (RSP_sig(sigcontext) >> 32)
{
WINE_ERR( "stack pointer above 4G in thread %04x rip %lx rsp %lx\n",
GetCurrentThreadId(), (DWORD64)RIP_sig(sigcontext), (DWORD64)RSP_sig(sigcontext) );
abort_thread(1);
}
}
/***********************************************************************
* save_fpu
*
* Save the thread FPU context.
*/
static inline void save_fpu( CONTEXT *context )
{
struct
{
DWORD ControlWord;
DWORD StatusWord;
DWORD TagWord;
DWORD ErrorOffset;
DWORD ErrorSelector;
DWORD DataOffset;
DWORD DataSelector;
}
float_status;
context->ContextFlags |= CONTEXT_FLOATING_POINT;
__asm__ __volatile__( "fnsave %0; fwait" : "=m" (context->FloatSave) );
/* Reset unmasked exceptions status to avoid firing an exception. */
memcpy(&float_status, &context->FloatSave, sizeof(float_status));
float_status.StatusWord &= float_status.ControlWord | 0xffffff80;
__asm__ __volatile__( "fldenv %0" : : "m" (float_status) );
}
/***********************************************************************
* save_fpux
*
* Save the thread FPU extended context.
*/
static inline void save_fpux( CONTEXT *context )
{
/* we have to enforce alignment by hand */
char buffer[sizeof(XMM_SAVE_AREA32) + 16];
XMM_SAVE_AREA32 *state = (XMM_SAVE_AREA32 *)(((ULONG_PTR)buffer + 15) & ~15);
context->ContextFlags |= CONTEXT_EXTENDED_REGISTERS;
__asm__ __volatile__( "fxsave %0" : "=m" (*state) );
memcpy( context->ExtendedRegisters, state, sizeof(*state) );
}
/***********************************************************************
* restore_fpu
*
* Restore the FPU context to a sigcontext.
*/
static inline void restore_fpu( const CONTEXT *context )
{
FLOATING_SAVE_AREA float_status = context->FloatSave;
/* reset the current interrupt status */
float_status.StatusWord &= float_status.ControlWord | 0xffffff80;
__asm__ __volatile__( "frstor %0; fwait" : : "m" (float_status) );
}
/***********************************************************************
* restore_fpux
*
* Restore the FPU extended context to a sigcontext.
*/
static inline void restore_fpux( const CONTEXT *context )
{
/* we have to enforce alignment by hand */
char buffer[sizeof(XMM_SAVE_AREA32) + 16];
XMM_SAVE_AREA32 *state = (XMM_SAVE_AREA32 *)(((ULONG_PTR)buffer + 15) & ~15);
memcpy( state, context->ExtendedRegisters, sizeof(*state) );
/* reset the current interrupt status */
state->StatusWord &= state->ControlWord | 0xff80;
state->MxCsr &= (state->MxCsr_Mask ?: 0xffbf);
__asm__ __volatile__( "fxrstor %0" : : "m" (*state) );
}
/***********************************************************************
* fpux_to_fpu
*
* Build a standard FPU context from an extended one.
*/
static void fpux_to_fpu( FLOATING_SAVE_AREA *fpu, const XMM_SAVE_AREA32 * HOSTPTR fpux )
{
unsigned int i, tag, stack_top;
fpu->ControlWord = fpux->ControlWord | 0xffff0000;
fpu->StatusWord = fpux->StatusWord | 0xffff0000;
fpu->ErrorOffset = fpux->ErrorOffset;
fpu->ErrorSelector = fpux->ErrorSelector | (fpux->ErrorOpcode << 16);
fpu->DataOffset = fpux->DataOffset;
fpu->DataSelector = fpux->DataSelector;
fpu->Cr0NpxState = fpux->StatusWord | 0xffff0000;
stack_top = (fpux->StatusWord >> 11) & 7;
fpu->TagWord = 0xffff0000;
for (i = 0; i < 8; i++)
{
memcpy( &fpu->RegisterArea[10 * i], &fpux->FloatRegisters[i], 10 );
if (!(fpux->TagWord & (1 << i))) tag = 3; /* empty */
else
{
const M128A * HOSTPTR reg = &fpux->FloatRegisters[(i - stack_top) & 7];
if ((reg->High & 0x7fff) == 0x7fff) /* exponent all ones */
{
tag = 2; /* special */
}
else if (!(reg->High & 0x7fff)) /* exponent all zeroes */
{
if (reg->Low) tag = 2; /* special */
else tag = 1; /* zero */
}
else
{
if (reg->Low >> 63) tag = 0; /* valid */
else tag = 2; /* special */
}
}
fpu->TagWord |= tag << (2 * i);
}
}
/***********************************************************************
* save_context64
*
* Set the register values from a 64-bit sigcontext to a CONTEXT64.
*/
static void save_context64( CONTEXT64 *context, const ucontext_t *sigcontext )
{
context->Rax = RAX_sig(sigcontext);
context->Rcx = RCX_sig(sigcontext);
context->Rdx = RDX_sig(sigcontext);
context->Rbx = RBX_sig(sigcontext);
context->Rsp = RSP_sig(sigcontext);
context->Rbp = RBP_sig(sigcontext);
context->Rsi = RSI_sig(sigcontext);
context->Rdi = RDI_sig(sigcontext);
context->R8 = R8_sig(sigcontext);
context->R9 = R9_sig(sigcontext);
context->R10 = R10_sig(sigcontext);
context->R11 = R11_sig(sigcontext);
context->R12 = R12_sig(sigcontext);
context->R13 = R13_sig(sigcontext);
context->R14 = R14_sig(sigcontext);
context->R15 = R15_sig(sigcontext);
context->Rip = RIP_sig(sigcontext);
context->SegCs = CS_sig(sigcontext);
context->SegFs = FS_sig(sigcontext);
context->SegGs = GS_sig(sigcontext);
context->EFlags = EFL_sig(sigcontext);
#ifdef DS_sig
context->SegDs = DS_sig(sigcontext);
#else
__asm__("movw %%ds,%0" : "=m" (context->SegDs));
#endif
#ifdef ES_sig
context->SegEs = ES_sig(sigcontext);
#else
__asm__("movw %%es,%0" : "=m" (context->SegEs));
#endif
#ifdef SS_sig
context->SegSs = SS_sig(sigcontext);
#else
__asm__("movw %%ss,%0" : "=m" (context->SegSs));
#endif
context->Dr0 = x86_thread_data()->dr0;
context->Dr1 = x86_thread_data()->dr1;
context->Dr2 = x86_thread_data()->dr2;
context->Dr3 = x86_thread_data()->dr3;
context->Dr6 = x86_thread_data()->dr6;
context->Dr7 = x86_thread_data()->dr7;
if (FPU_sig(sigcontext))
context->u.FltSave = *FPU_sig(sigcontext);
else
{
CONTEXT context32;
save_fpux( &context32 );
context->u.FltSave = *(XMM_SAVE_AREA32 *)context32.ExtendedRegisters;
}
context->MxCsr = context->u.FltSave.MxCsr;
}
/***********************************************************************
* save_context
*
* Set the register values from a sigcontext.
*/
static void save_context( CONTEXT *context, const ucontext_t *sigcontext )
{
memset( context, 0, sizeof(*context) );
context->ContextFlags = CONTEXT_FULL | CONTEXT_DEBUG_REGISTERS;
context->Eax = RAX_sig(sigcontext);
context->Ecx = RCX_sig(sigcontext);
context->Edx = RDX_sig(sigcontext);
context->Ebx = RBX_sig(sigcontext);
context->Esp = RSP_sig(sigcontext);
context->Ebp = RBP_sig(sigcontext);
context->Esi = RSI_sig(sigcontext);
context->Edi = RDI_sig(sigcontext);
context->Eip = RIP_sig(sigcontext);
context->SegCs = CS_sig(sigcontext);
context->SegFs = FS_sig(sigcontext);
context->SegGs = GS_sig(sigcontext);
context->EFlags = EFL_sig(sigcontext);
#ifdef DS_sig
context->SegDs = DS_sig(sigcontext);
#else
__asm__("movw %%ds,%0" : "=m" (context->SegDs));
#endif
#ifdef ES_sig
context->SegEs = ES_sig(sigcontext);
#else
__asm__("movw %%es,%0" : "=m" (context->SegEs));
#endif
#ifdef SS_sig
context->SegSs = SS_sig(sigcontext);
#else
__asm__("movw %%ss,%0" : "=m" (context->SegSs));
#endif
context->Dr0 = x86_thread_data()->dr0;
context->Dr1 = x86_thread_data()->dr1;
context->Dr2 = x86_thread_data()->dr2;
context->Dr3 = x86_thread_data()->dr3;
context->Dr6 = x86_thread_data()->dr6;
context->Dr7 = x86_thread_data()->dr7;
if (FPU_sig(sigcontext))
{
context->ContextFlags |= CONTEXT_FLOATING_POINT | CONTEXT_EXTENDED_REGISTERS;
*(XMM_SAVE_AREA32 *)context->ExtendedRegisters = *FPU_sig(sigcontext);
fpux_to_fpu( &context->FloatSave, FPU_sig(sigcontext) );
}
else
{
save_fpu( context );
save_fpux( context );
}
}
/***********************************************************************
* restore_context
*
* Build a sigcontext from the register values.
*/
static void restore_context( const CONTEXT *context, ucontext_t *sigcontext )
{
XMM_SAVE_AREA32 * HOSTPTR fpu = FPU_sig(sigcontext);
/* can't restore a 32-bit context into 64-bit mode */
if (sel_is_64bit(context->SegCs)) return;
x86_thread_data()->dr0 = context->Dr0;
x86_thread_data()->dr1 = context->Dr1;
x86_thread_data()->dr2 = context->Dr2;
x86_thread_data()->dr3 = context->Dr3;
x86_thread_data()->dr6 = context->Dr6;
x86_thread_data()->dr7 = context->Dr7;
RAX_sig(sigcontext) = context->Eax;
RBX_sig(sigcontext) = context->Ebx;
RCX_sig(sigcontext) = context->Ecx;
RDX_sig(sigcontext) = context->Edx;
RSI_sig(sigcontext) = context->Esi;
RDI_sig(sigcontext) = context->Edi;
RBP_sig(sigcontext) = context->Ebp;
EFL_sig(sigcontext) = context->EFlags;
RIP_sig(sigcontext) = context->Eip;
RSP_sig(sigcontext) = context->Esp;
CS_sig(sigcontext) = context->SegCs;
DS_sig(sigcontext) = context->SegDs;
ES_sig(sigcontext) = context->SegEs;
FS_sig(sigcontext) = context->SegFs;
GS_sig(sigcontext) = context->SegGs;
SS_sig(sigcontext) = context->SegSs;
if (fpu)
memcpy( fpu, context->ExtendedRegisters, sizeof(*fpu) );
else
restore_fpux( context );
}
static void save_xsave( XMM_SAVE_AREA32 *xsave )
{
/* we have to enforce alignment by hand */
char buffer[sizeof(XMM_SAVE_AREA32) + 16];
XMM_SAVE_AREA32 *state = (XMM_SAVE_AREA32 *)(((ULONG_PTR)buffer + 15) & ~15);
__asm__ __volatile__( "fxsave (%0)\n\t" /* xsave */
"movdqa %%xmm0,0xa0(%0)\n\t" /* xsave->XmmRegisters[0] */
"movdqa %%xmm1,0xb0(%0)\n\t" /* xsave->XmmRegisters[1] */
"movdqa %%xmm2,0xc0(%0)\n\t" /* xsave->XmmRegisters[2] */
"movdqa %%xmm3,0xd0(%0)\n\t" /* xsave->XmmRegisters[3] */
"movdqa %%xmm4,0xe0(%0)\n\t" /* xsave->XmmRegisters[4] */
"movdqa %%xmm5,0xf0(%0)\n\t" /* xsave->XmmRegisters[5] */
"movdqa %%xmm6,0x100(%0)\n\t" /* xsave->XmmRegisters[6] */
"movdqa %%xmm7,0x110(%0)\n\t" /* xsave->XmmRegisters[7] */
"movdqa %%xmm8,0x120(%0)\n\t" /* xsave->XmmRegisters[8] */
"movdqa %%xmm9,0x130(%0)\n\t" /* xsave->XmmRegisters[9] */
"movdqa %%xmm10,0x140(%0)\n\t" /* xsave->XmmRegisters[10] */
"movdqa %%xmm11,0x150(%0)\n\t" /* xsave->XmmRegisters[11] */
"movdqa %%xmm12,0x160(%0)\n\t" /* xsave->XmmRegisters[12] */
"movdqa %%xmm13,0x170(%0)\n\t" /* xsave->XmmRegisters[13] */
"movdqa %%xmm14,0x180(%0)\n\t" /* xsave->XmmRegisters[14] */
"movdqa %%xmm15,0x190(%0)\n\t" /* xsave->XmmRegisters[15] */
: : "r" (state) : "memory" );
memcpy( xsave, state, sizeof(*state) );
}
/***********************************************************************
* RtlCaptureContext (NTDLL.@)
*/
__ASM_STDCALL_FUNC( RtlCaptureContext, 4,
"pushq %rax\n\t"
__ASM_CFI(".cfi_adjust_cfa_offset 8\n\t")
"movl " __ASM_EXTRA_DIST "+12(%rsp),%eax\n\t" /* context */
"movl $0x10007,(%eax)\n\t" /* context->ContextFlags */
"movw %gs,0x8c(%eax)\n\t" /* context->SegGs */
"movw %fs,0x90(%eax)\n\t" /* context->SegFs */
"movw %es,0x94(%eax)\n\t" /* context->SegEs */
"movw %ds,0x98(%eax)\n\t" /* context->SegDs */
"movl %edi,0x9c(%eax)\n\t" /* context->Edi */
"movl %esi,0xa0(%eax)\n\t" /* context->Esi */
"movl %ebx,0xa4(%eax)\n\t" /* context->Ebx */
"movl %edx,0xa8(%eax)\n\t" /* context->Edx */
"movl %ecx,0xac(%eax)\n\t" /* context->Ecx */
"movl %ebp,0xb4(%eax)\n\t" /* context->Ebp */
"movl 8(%rsp),%edx\n\t"
"movl %edx,0xb8(%eax)\n\t" /* context->Eip */
"movw %cs,0xbc(%eax)\n\t" /* context->SegCs */
"pushfq\n\t"
__ASM_CFI(".cfi_adjust_cfa_offset 8\n\t")
"popq %rcx\n\t"
__ASM_CFI(".cfi_adjust_cfa_offset -8\n\t")
"movl %ecx,0xc0(%eax)\n\t" /* context->EFlags */
"leaq 16(%rsp),%rdx\n\t"
"movl %edx,0xc4(%eax)\n\t" /* context->Esp */
"movw %ss,0xc8(%eax)\n\t" /* context->SegSs */
"popq %rcx\n\t"
__ASM_CFI(".cfi_adjust_cfa_offset -8\n\t")
"movl %ecx,0xb0(%eax)\n\t" /* context->Eax */
"ret" )
__ASM_THUNK_STDCALL( RtlCaptureContext, 4,
"pushl %eax\n\t"
__ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
"movl 8(%esp),%eax\n\t" /* context */
"movl $0x10007,(%eax)\n\t" /* context->ContextFlags */
"movw %gs,0x8c(%eax)\n\t" /* context->SegGs */
"movw %fs,0x90(%eax)\n\t" /* context->SegFs */
"movw %es,0x94(%eax)\n\t" /* context->SegEs */
"movw %ds,0x98(%eax)\n\t" /* context->SegDs */
"movl %edi,0x9c(%eax)\n\t" /* context->Edi */
"movl %esi,0xa0(%eax)\n\t" /* context->Esi */
"movl %ebx,0xa4(%eax)\n\t" /* context->Ebx */
"movl %edx,0xa8(%eax)\n\t" /* context->Edx */
"movl %ecx,0xac(%eax)\n\t" /* context->Ecx */
"movl 0(%ebp),%edx\n\t"
"movl %edx,0xb4(%eax)\n\t" /* context->Ebp */
"movl 4(%ebp),%edx\n\t"
"movl %edx,0xb8(%eax)\n\t" /* context->Eip */
"movw %cs,0xbc(%eax)\n\t" /* context->SegCs */
"pushfl\n\t"
__ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
"popl 0xc0(%eax)\n\t" /* context->EFlags */
__ASM_CFI(".cfi_adjust_cfa_offset -4\n\t")
"leal 8(%ebp),%edx\n\t"
"movl %edx,0xc4(%eax)\n\t" /* context->Esp */
"movw %ss,0xc8(%eax)\n\t" /* context->SegSs */
"popl 0xb0(%eax)\n\t" /* context->Eax */
__ASM_CFI(".cfi_adjust_cfa_offset -4\n\t")
"ret $4" )
/***********************************************************************
* set_full_cpu_context64
*
* Set the new 64-bit CPU context.
*/
extern void set_full_cpu_context64( const CONTEXT64 *context );
__ASM_GLOBAL_FUNC( set_full_cpu_context64,
"subq $40,%rsp\n\t"
__ASM_CFI(".cfi_adjust_cfa_offset 40\n\t")
"ldmxcsr 0x34(%rdi)\n\t" /* context->MxCsr */
"movw 0x38(%rdi),%ax\n\t" /* context->SegCs */
"movq %rax,8(%rsp)\n\t"
"movw 0x42(%rdi),%ax\n\t" /* context->SegSs */
"movq %rax,32(%rsp)\n\t"
"movq 0x44(%rdi),%rax\n\t" /* context->Eflags */
"movq %rax,16(%rsp)\n\t"
"movq 0x80(%rdi),%rcx\n\t" /* context->Rcx */
"movq 0x88(%rdi),%rdx\n\t" /* context->Rdx */
"movq 0x90(%rdi),%rbx\n\t" /* context->Rbx */
"movq 0x98(%rdi),%rax\n\t" /* context->Rsp */
"movq %rax,24(%rsp)\n\t"
"movq 0xa0(%rdi),%rbp\n\t" /* context->Rbp */
"movq 0xa8(%rdi),%rsi\n\t" /* context->Rsi */
"movq 0xb8(%rdi),%r8\n\t" /* context->R8 */
"movq 0xc0(%rdi),%r9\n\t" /* context->R9 */
"movq 0xc8(%rdi),%r10\n\t" /* context->R10 */
"movq 0xd0(%rdi),%r11\n\t" /* context->R11 */
"movq 0xd8(%rdi),%r12\n\t" /* context->R12 */
"movq 0xe0(%rdi),%r13\n\t" /* context->R13 */
"movq 0xe8(%rdi),%r14\n\t" /* context->R14 */
"movq 0xf0(%rdi),%r15\n\t" /* context->R15 */
"movq 0xf8(%rdi),%rax\n\t" /* context->Rip */
"movq %rax,(%rsp)\n\t"
"fxrstor 0x100(%rdi)\n\t" /* context->FtlSave */
"movdqa 0x1a0(%rdi),%xmm0\n\t" /* context->Xmm0 */
"movdqa 0x1b0(%rdi),%xmm1\n\t" /* context->Xmm1 */
"movdqa 0x1c0(%rdi),%xmm2\n\t" /* context->Xmm2 */
"movdqa 0x1d0(%rdi),%xmm3\n\t" /* context->Xmm3 */
"movdqa 0x1e0(%rdi),%xmm4\n\t" /* context->Xmm4 */
"movdqa 0x1f0(%rdi),%xmm5\n\t" /* context->Xmm5 */
"movdqa 0x200(%rdi),%xmm6\n\t" /* context->Xmm6 */
"movdqa 0x210(%rdi),%xmm7\n\t" /* context->Xmm7 */
"movdqa 0x220(%rdi),%xmm8\n\t" /* context->Xmm8 */
"movdqa 0x230(%rdi),%xmm9\n\t" /* context->Xmm9 */
"movdqa 0x240(%rdi),%xmm10\n\t" /* context->Xmm10 */
"movdqa 0x250(%rdi),%xmm11\n\t" /* context->Xmm11 */
"movdqa 0x260(%rdi),%xmm12\n\t" /* context->Xmm12 */
"movdqa 0x270(%rdi),%xmm13\n\t" /* context->Xmm13 */
"movdqa 0x280(%rdi),%xmm14\n\t" /* context->Xmm14 */
"movdqa 0x290(%rdi),%xmm15\n\t" /* context->Xmm15 */
"movq 0x78(%rdi),%rax\n\t" /* context->Rax */
"movq 0xb0(%rdi),%rdi\n\t" /* context->Rdi */
"iretq" );
/***********************************************************************
* set_full_cpu_context
*
* Set the new CPU context.
*/
extern void CDECL set_full_cpu_context( const CONTEXT *context );
__ASM_GLOBAL_FUNC32( __ASM_THUNK_NAME(set_full_cpu_context),
"movl 4(%esp),%ecx\n\t"
"cmpw $0,0x8c(%ecx)\n\t" /* SegGs, if not 0 */
"je 1f\n\t"
"movw 0x8c(%ecx),%gs\n"
"1:\n\t"
"movw 0x90(%ecx),%fs\n\t" /* SegFs */
"movw 0x94(%ecx),%es\n\t" /* SegEs */
"movl 0x9c(%ecx),%edi\n\t" /* Edi */
"movl 0xa0(%ecx),%esi\n\t" /* Esi */
"movl 0xa4(%ecx),%ebx\n\t" /* Ebx */
"movl 0xb4(%ecx),%ebp\n\t" /* Ebp */
"movw %ss,%ax\n\t"
"cmpw 0xc8(%ecx),%ax\n\t" /* SegSs */
"jne 1f\n\t"
/* As soon as we have switched stacks the context structure could
* be invalid (when signal handlers are executed for example). Copy
* values on the target stack before changing ESP. */
"movl 0xc4(%ecx),%eax\n\t" /* Esp */
"leal -4*4(%eax),%eax\n\t"
"movl 0xc0(%ecx),%edx\n\t" /* EFlags */
"movl %edx,3*4(%eax)\n\t"
"movl 0xbc(%ecx),%edx\n\t" /* SegCs */
"movl %edx,2*4(%eax)\n\t"
"movl 0xb8(%ecx),%edx\n\t" /* Eip */
"movl %edx,1*4(%eax)\n\t"
"movl 0xb0(%ecx),%edx\n\t" /* Eax */
"movl %edx,0*4(%eax)\n\t"
"pushl 0x98(%ecx)\n\t" /* SegDs */
"movl 0xa8(%ecx),%edx\n\t" /* Edx */
"movl 0xac(%ecx),%ecx\n\t" /* Ecx */
"popl %ds\n\t"
"movl %eax,%esp\n\t"
"popl %eax\n\t"
"iret\n"
/* Restore the context when the stack segment changes. We can't use
* the same code as above because we do not know if the stack segment
* is 16 or 32 bit, and 'movl' will throw an exception when we try to
* access memory above the limit. */
"1:\n\t"
"movl 0xa8(%ecx),%edx\n\t" /* Edx */
"movl 0xb0(%ecx),%eax\n\t" /* Eax */
"movw 0xc8(%ecx),%ss\n\t" /* SegSs */
"movl 0xc4(%ecx),%esp\n\t" /* Esp */
"pushl 0xc0(%ecx)\n\t" /* EFlags */
"pushl 0xbc(%ecx)\n\t" /* SegCs */
"pushl 0xb8(%ecx)\n\t" /* Eip */
"pushl 0x98(%ecx)\n\t" /* SegDs */
"movl 0xac(%ecx),%ecx\n\t" /* Ecx */
"popl %ds\n\t"
"iret" )
/***********************************************************************
* set_cpu_context
*
* Set the new CPU context. Used by NtSetContextThread.
*/
void DECLSPEC_HIDDEN __attribute__((__force_align_arg_pointer__)) set_cpu_context( const CONTEXT *context )
{
DWORD flags = context->ContextFlags & ~CONTEXT_i386;
if ((flags & CONTEXT_EXTENDED_REGISTERS)) restore_fpux( context );
else if (flags & CONTEXT_FLOATING_POINT) restore_fpu( context );
if (flags & CONTEXT_DEBUG_REGISTERS)
{
x86_thread_data()->dr0 = context->Dr0;
x86_thread_data()->dr1 = context->Dr1;
x86_thread_data()->dr2 = context->Dr2;
x86_thread_data()->dr3 = context->Dr3;
x86_thread_data()->dr6 = context->Dr6;
x86_thread_data()->dr7 = context->Dr7;
}
if (flags & CONTEXT_FULL)
{
if (!(flags & CONTEXT_CONTROL))
FIXME( "setting partial context (%x) not supported\n", flags );
else if (flags & CONTEXT_SEGMENTS)
{
if (sel_is_64bit(context->SegCs))
FIXME( "setting 64-bit context not supported\n" );
else
WINE_CALL_IMPL32(set_full_cpu_context)( context );
}
else
{
CONTEXT newcontext = *context;
newcontext.SegDs = wine_get_ds();
newcontext.SegEs = wine_get_es();
newcontext.SegFs = wine_get_fs();
newcontext.SegGs = wine_get_gs();
WINE_CALL_IMPL32(set_full_cpu_context)( &newcontext );
}
}
}
/***********************************************************************
* get_server_context_flags
*
* Convert CPU-specific flags to generic server flags
*/
static unsigned int get_server_context_flags( DWORD flags )
{
unsigned int ret = 0;
flags &= ~CONTEXT_i386; /* get rid of CPU id */
if (flags & CONTEXT_CONTROL) ret |= SERVER_CTX_CONTROL;
if (flags & CONTEXT_INTEGER) ret |= SERVER_CTX_INTEGER;
if (flags & CONTEXT_SEGMENTS) ret |= SERVER_CTX_SEGMENTS;
if (flags & CONTEXT_FLOATING_POINT) ret |= SERVER_CTX_FLOATING_POINT;
if (flags & CONTEXT_DEBUG_REGISTERS) ret |= SERVER_CTX_DEBUG_REGISTERS;
if (flags & CONTEXT_EXTENDED_REGISTERS) ret |= SERVER_CTX_EXTENDED_REGISTERS;
return ret;
}
/***********************************************************************
* context_to_server
*
* Convert a register context to the server format.
*/
NTSTATUS context_to_server( context_t *to, const CONTEXT *from )
{
DWORD flags = from->ContextFlags & ~CONTEXT_i386; /* get rid of CPU id */
memset( to, 0, sizeof(*to) );
to->cpu = CPU_x86;
if (flags & CONTEXT_CONTROL)
{
to->flags |= SERVER_CTX_CONTROL;
to->ctl.i386_regs.ebp = from->Ebp;
to->ctl.i386_regs.esp = from->Esp;
to->ctl.i386_regs.eip = from->Eip;
to->ctl.i386_regs.cs = from->SegCs;
to->ctl.i386_regs.ss = from->SegSs;
to->ctl.i386_regs.eflags = from->EFlags;
}
if (flags & CONTEXT_INTEGER)
{
to->flags |= SERVER_CTX_INTEGER;
to->integer.i386_regs.eax = from->Eax;
to->integer.i386_regs.ebx = from->Ebx;
to->integer.i386_regs.ecx = from->Ecx;
to->integer.i386_regs.edx = from->Edx;
to->integer.i386_regs.esi = from->Esi;
to->integer.i386_regs.edi = from->Edi;
}
if (flags & CONTEXT_SEGMENTS)
{
to->flags |= SERVER_CTX_SEGMENTS;
to->seg.i386_regs.ds = from->SegDs;
to->seg.i386_regs.es = from->SegEs;
to->seg.i386_regs.fs = from->SegFs;
to->seg.i386_regs.gs = from->SegGs;
}
if (flags & CONTEXT_FLOATING_POINT)
{
to->flags |= SERVER_CTX_FLOATING_POINT;
to->fp.i386_regs.ctrl = from->FloatSave.ControlWord;
to->fp.i386_regs.status = from->FloatSave.StatusWord;
to->fp.i386_regs.tag = from->FloatSave.TagWord;
to->fp.i386_regs.err_off = from->FloatSave.ErrorOffset;
to->fp.i386_regs.err_sel = from->FloatSave.ErrorSelector;
to->fp.i386_regs.data_off = from->FloatSave.DataOffset;
to->fp.i386_regs.data_sel = from->FloatSave.DataSelector;
to->fp.i386_regs.cr0npx = from->FloatSave.Cr0NpxState;
memcpy( to->fp.i386_regs.regs, from->FloatSave.RegisterArea, sizeof(to->fp.i386_regs.regs) );
}
if (flags & CONTEXT_DEBUG_REGISTERS)
{
to->flags |= SERVER_CTX_DEBUG_REGISTERS;
to->debug.i386_regs.dr0 = from->Dr0;
to->debug.i386_regs.dr1 = from->Dr1;
to->debug.i386_regs.dr2 = from->Dr2;
to->debug.i386_regs.dr3 = from->Dr3;
to->debug.i386_regs.dr6 = from->Dr6;
to->debug.i386_regs.dr7 = from->Dr7;
}
if (flags & CONTEXT_EXTENDED_REGISTERS)
{
to->flags |= SERVER_CTX_EXTENDED_REGISTERS;
memcpy( to->ext.i386_regs, from->ExtendedRegisters, sizeof(to->ext.i386_regs) );
}
return STATUS_SUCCESS;
}
/***********************************************************************
* context_from_server
*
* Convert a register context from the server format.
*/
NTSTATUS context_from_server( CONTEXT *to, const context_t *from )
{
if (from->cpu != CPU_x86) return STATUS_INVALID_PARAMETER;
to->ContextFlags = CONTEXT_i386;
if (from->flags & SERVER_CTX_CONTROL)
{
to->ContextFlags |= CONTEXT_CONTROL;
to->Ebp = from->ctl.i386_regs.ebp;
to->Esp = from->ctl.i386_regs.esp;
to->Eip = from->ctl.i386_regs.eip;
to->SegCs = from->ctl.i386_regs.cs;
to->SegSs = from->ctl.i386_regs.ss;
to->EFlags = from->ctl.i386_regs.eflags;
}
if (from->flags & SERVER_CTX_INTEGER)
{
to->ContextFlags |= CONTEXT_INTEGER;
to->Eax = from->integer.i386_regs.eax;
to->Ebx = from->integer.i386_regs.ebx;
to->Ecx = from->integer.i386_regs.ecx;
to->Edx = from->integer.i386_regs.edx;
to->Esi = from->integer.i386_regs.esi;
to->Edi = from->integer.i386_regs.edi;
}
if (from->flags & SERVER_CTX_SEGMENTS)
{
to->ContextFlags |= CONTEXT_SEGMENTS;
to->SegDs = from->seg.i386_regs.ds;
to->SegEs = from->seg.i386_regs.es;
to->SegFs = from->seg.i386_regs.fs;
to->SegGs = from->seg.i386_regs.gs;
}
if (from->flags & SERVER_CTX_FLOATING_POINT)
{
to->ContextFlags |= CONTEXT_FLOATING_POINT;
to->FloatSave.ControlWord = from->fp.i386_regs.ctrl;
to->FloatSave.StatusWord = from->fp.i386_regs.status;
to->FloatSave.TagWord = from->fp.i386_regs.tag;
to->FloatSave.ErrorOffset = from->fp.i386_regs.err_off;
to->FloatSave.ErrorSelector = from->fp.i386_regs.err_sel;
to->FloatSave.DataOffset = from->fp.i386_regs.data_off;
to->FloatSave.DataSelector = from->fp.i386_regs.data_sel;
to->FloatSave.Cr0NpxState = from->fp.i386_regs.cr0npx;
memcpy( to->FloatSave.RegisterArea, from->fp.i386_regs.regs, sizeof(to->FloatSave.RegisterArea) );
}
if (from->flags & SERVER_CTX_DEBUG_REGISTERS)
{
to->ContextFlags |= CONTEXT_DEBUG_REGISTERS;
to->Dr0 = from->debug.i386_regs.dr0;
to->Dr1 = from->debug.i386_regs.dr1;
to->Dr2 = from->debug.i386_regs.dr2;
to->Dr3 = from->debug.i386_regs.dr3;
to->Dr6 = from->debug.i386_regs.dr6;
to->Dr7 = from->debug.i386_regs.dr7;
}
if (from->flags & SERVER_CTX_EXTENDED_REGISTERS)
{
to->ContextFlags |= CONTEXT_EXTENDED_REGISTERS;
memcpy( to->ExtendedRegisters, from->ext.i386_regs, sizeof(to->ExtendedRegisters) );
}
return STATUS_SUCCESS;
}
/***********************************************************************
* NtSetContextThread (NTDLL.@)
* ZwSetContextThread (NTDLL.@)
*/
NTSTATUS WINAPI NtSetContextThread( HANDLE handle, const CONTEXT *context )
{
NTSTATUS ret = STATUS_SUCCESS;
BOOL self = (handle == GetCurrentThread());
/* debug registers require a server call */
if (self && (context->ContextFlags & (CONTEXT_DEBUG_REGISTERS & ~CONTEXT_i386)))
self = (x86_thread_data()->dr0 == context->Dr0 &&
x86_thread_data()->dr1 == context->Dr1 &&
x86_thread_data()->dr2 == context->Dr2 &&
x86_thread_data()->dr3 == context->Dr3 &&
x86_thread_data()->dr6 == context->Dr6 &&
x86_thread_data()->dr7 == context->Dr7);
if (!self)
{
context_t server_context;
context_to_server( &server_context, context );
ret = set_thread_context( handle, &server_context, &self );
}
if (self && ret == STATUS_SUCCESS) set_cpu_context( context );
return ret;
}
/***********************************************************************
* NtGetContextThread (NTDLL.@)
* ZwGetContextThread (NTDLL.@)
*
* Note: we use a small assembly wrapper to save the necessary registers
* in case we are fetching the context of the current thread.
*/
NTSTATUS CDECL DECLSPEC_HIDDEN __regs_NtGetContextThread( HANDLE handle, CONTEXT *context, CONTEXT *captured_context )
{
NTSTATUS ret;
DWORD needed_flags = context->ContextFlags & ~CONTEXT_i386;
BOOL self = (handle == GetCurrentThread());
/* debug registers require a server call */
if (needed_flags & CONTEXT_DEBUG_REGISTERS) self = FALSE;
if (!self)
{
context_t server_context;
unsigned int server_flags = get_server_context_flags( context->ContextFlags );
if ((ret = get_thread_context( handle, &server_context, server_flags, &self ))) return ret;
if ((ret = context_from_server( context, &server_context ))) return ret;
needed_flags &= ~context->ContextFlags;
}
if (self)
{
XMM_SAVE_AREA32 xsave;
if (needed_flags & CONTEXT_INTEGER)
{
context->Eax = captured_context->Eax;
context->Ebx = captured_context->Ebx;
context->Ecx = captured_context->Ecx;
context->Edx = captured_context->Edx;
context->Esi = captured_context->Esi;
context->Edi = captured_context->Edi;
context->ContextFlags |= CONTEXT_INTEGER;
}
if (needed_flags & CONTEXT_CONTROL)
{
context->Ebp = captured_context->Ebp;
context->Eip = captured_context->Eip;
context->Eip = (DWORD)SYSCALL(NtGetContextThread) + 18;
context->Esp = captured_context->Esp;
context->SegCs = LOWORD(captured_context->SegCs);
context->SegSs = LOWORD(captured_context->SegSs);
context->EFlags = captured_context->EFlags;
context->ContextFlags |= CONTEXT_CONTROL;
}
if (needed_flags & CONTEXT_SEGMENTS)
{
context->SegDs = LOWORD(captured_context->SegDs);
context->SegEs = LOWORD(captured_context->SegEs);
context->SegFs = LOWORD(captured_context->SegFs);
context->SegGs = LOWORD(captured_context->SegGs);
context->ContextFlags |= CONTEXT_SEGMENTS;
}
if (needed_flags & (CONTEXT_FLOATING_POINT | CONTEXT_EXTENDED_REGISTERS))
save_xsave( &xsave );
if (needed_flags & CONTEXT_FLOATING_POINT)
{
fpux_to_fpu( &context->FloatSave, &xsave );
context->ContextFlags |= CONTEXT_FLOATING_POINT;
}
if (needed_flags & CONTEXT_EXTENDED_REGISTERS)
{
memcpy( context->ExtendedRegisters, &xsave, sizeof(xsave) );
context->ContextFlags |= CONTEXT_EXTENDED_REGISTERS;
}
/* FIXME: xstate */
/* update the cached version of the debug registers */
if (context->ContextFlags & (CONTEXT_DEBUG_REGISTERS & ~CONTEXT_i386))
{
x86_thread_data()->dr0 = context->Dr0;
x86_thread_data()->dr1 = context->Dr1;
x86_thread_data()->dr2 = context->Dr2;
x86_thread_data()->dr3 = context->Dr3;
x86_thread_data()->dr6 = context->Dr6;
x86_thread_data()->dr7 = context->Dr7;
}
}
if (context->ContextFlags & (CONTEXT_INTEGER & ~CONTEXT_i386))
TRACE( "%p: eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x\n", handle,
context->Eax, context->Ebx, context->Ecx, context->Edx, context->Esi, context->Edi );
if (context->ContextFlags & (CONTEXT_CONTROL & ~CONTEXT_i386))
TRACE( "%p: ebp=%08x esp=%08x eip=%08x cs=%04x ss=%04x flags=%08x\n", handle,
context->Ebp, context->Esp, context->Eip, context->SegCs, context->SegSs, context->EFlags );
if (context->ContextFlags & (CONTEXT_SEGMENTS & ~CONTEXT_i386))
TRACE( "%p: ds=%04x es=%04x fs=%04x gs=%04x\n", handle,
context->SegDs, context->SegEs, context->SegFs, context->SegGs );
if (context->ContextFlags & (CONTEXT_DEBUG_REGISTERS & ~CONTEXT_i386))
TRACE( "%p: dr0=%08x dr1=%08x dr2=%08x dr3=%08x dr6=%08x dr7=%08x\n", handle,
context->Dr0, context->Dr1, context->Dr2, context->Dr3, context->Dr6, context->Dr7 );
return STATUS_SUCCESS;
}
__ASM_STDCALL_FUNC32( __ASM_THUNK_NAME(NtGetContextThread), 8,
"pushl %ebp\n\t"
__ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
__ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
"movl %esp,%ebp\n\t"
__ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
"leal -0x2cc(%esp),%esp\n\t" /* sizeof(CONTEXT) for local */
"pushl %esp\n\t" /* local context */
"call " __ASM_THUNK_STDCALL_SYMBOL("RtlCaptureContext",4) "\n\t"
"leal 4(%ebp),%eax\n\t"
"movl %eax,0xc4(%esp)\n\t" /* local context->Esp on entry (not before call) */
"call 1f\n"
"1:\n\t"
"popl 0xb8(%esp)\n\t" /* local context->Eip near entry (not caller) */
"pushl %esp\n\t" /* local context */
"pushl 12(%ebp)\n\t" /* orig context param */
"pushl 8(%ebp)\n\t" /* handle param */
"calll " __ASM_THUNK_SYMBOL("__regs_NtGetContextThread") "\n\t"
"leave\n\t"
__ASM_CFI(".cfi_def_cfa %esp,4\n\t")
__ASM_CFI(".cfi_same_value %ebp\n\t")
"ret $8" )
/***********************************************************************
* is_privileged_instr
*
* Check if the fault location is a privileged instruction.
* Based on the instruction emulation code in dlls/kernel/instr.c.
*/
static inline DWORD is_privileged_instr( CONTEXT *context )
{
BYTE instr[16];
unsigned int i, len, prefix_count = 0;
if (context->SegCs != wine_32on64_cs32) return 0;
len = virtual_uninterrupted_read_memory( (BYTE *)context->Eip, instr, sizeof(instr) );
for (i = 0; i < len; i++) switch (instr[i])
{
/* instruction prefixes */
case 0x2e: /* %cs: */
case 0x36: /* %ss: */
case 0x3e: /* %ds: */
case 0x26: /* %es: */
case 0x64: /* %fs: */
case 0x65: /* %gs: */
case 0x66: /* opcode size */
case 0x67: /* addr size */
case 0xf0: /* lock */
case 0xf2: /* repne */
case 0xf3: /* repe */
if (++prefix_count >= 15) return EXCEPTION_ILLEGAL_INSTRUCTION;
continue;
case 0x0f: /* extended instruction */
if (i == len - 1) return 0;
switch(instr[i + 1])
{
case 0x20: /* mov crX, reg */
case 0x21: /* mov drX, reg */
case 0x22: /* mov reg, crX */
case 0x23: /* mov reg drX */
return EXCEPTION_PRIV_INSTRUCTION;
}
return 0;
case 0x6c: /* insb (%dx) */
case 0x6d: /* insl (%dx) */
case 0x6e: /* outsb (%dx) */
case 0x6f: /* outsl (%dx) */
case 0xcd: /* int $xx */
case 0xe4: /* inb al,XX */
case 0xe5: /* in (e)ax,XX */
case 0xe6: /* outb XX,al */
case 0xe7: /* out XX,(e)ax */
case 0xec: /* inb (%dx),%al */
case 0xed: /* inl (%dx),%eax */
case 0xee: /* outb %al,(%dx) */
case 0xef: /* outl %eax,(%dx) */
case 0xf4: /* hlt */
case 0xfa: /* cli */
case 0xfb: /* sti */
return EXCEPTION_PRIV_INSTRUCTION;
default:
return 0;
}
return 0;
}
#include "pshpack1.h"
union atl_thunk
{
struct
{
DWORD movl; /* movl this,4(%esp) */
DWORD this;
BYTE jmp; /* jmp func */
int func;
} t1;
struct
{
BYTE movl; /* movl this,ecx */
DWORD this;
BYTE jmp; /* jmp func */
int func;
} t2;
struct
{
BYTE movl1; /* movl this,edx */
DWORD this;
BYTE movl2; /* movl func,ecx */
DWORD func;
WORD jmp; /* jmp ecx */
} t3;
struct
{
BYTE movl1; /* movl this,ecx */
DWORD this;
BYTE movl2; /* movl func,eax */
DWORD func;
WORD jmp; /* jmp eax */
} t4;
struct
{
DWORD inst1; /* pop ecx
* pop eax
* push ecx
* jmp 4(%eax) */
WORD inst2;
} t5;
};
#include "poppack.h"
/**********************************************************************
* check_atl_thunk
*
* Check if code destination is an ATL thunk, and emulate it if so.
*/
static BOOL check_atl_thunk( ucontext_t *sigcontext, struct stack_layout *stack )
{
const union atl_thunk *thunk = (const union atl_thunk *)stack->rec.ExceptionInformation[1];
union atl_thunk thunk_copy;
SIZE_T thunk_len;
if (stack->context.SegCs != wine_32on64_cs32) return FALSE;
thunk_len = virtual_uninterrupted_read_memory( thunk, &thunk_copy, sizeof(*thunk) );
if (!thunk_len) return FALSE;
if (thunk_len >= sizeof(thunk_copy.t1) && thunk_copy.t1.movl == 0x042444c7 &&
thunk_copy.t1.jmp == 0xe9)
{
if (!virtual_uninterrupted_write_memory( (DWORD *)stack->context.Esp + 1,
&thunk_copy.t1.this, sizeof(DWORD) ))
{
RIP_sig(sigcontext) = (DWORD_PTR)(&thunk->t1.func + 1) + thunk_copy.t1.func;
TRACE( "emulating ATL thunk type 1 at %p, func=%08x arg=%08x\n",
thunk, (DWORD)RIP_sig(sigcontext), thunk_copy.t1.this );
return TRUE;
}
}
else if (thunk_len >= sizeof(thunk_copy.t2) && thunk_copy.t2.movl == 0xb9 &&
thunk_copy.t2.jmp == 0xe9)
{
RCX_sig(sigcontext) = thunk_copy.t2.this;
RIP_sig(sigcontext) = (DWORD_PTR)(&thunk->t2.func + 1) + thunk_copy.t2.func;
TRACE( "emulating ATL thunk type 2 at %p, func=%08x ecx=%08x\n",
thunk, (DWORD)RIP_sig(sigcontext), (DWORD)RCX_sig(sigcontext) );
return TRUE;
}
else if (thunk_len >= sizeof(thunk_copy.t3) && thunk_copy.t3.movl1 == 0xba &&
thunk_copy.t3.movl2 == 0xb9 &&
thunk_copy.t3.jmp == 0xe1ff)
{
RDX_sig(sigcontext) = thunk_copy.t3.this;
RCX_sig(sigcontext) = thunk_copy.t3.func;
RIP_sig(sigcontext) = thunk_copy.t3.func;
TRACE( "emulating ATL thunk type 3 at %p, func=%08x ecx=%08x edx=%08x\n",
thunk, (DWORD)RIP_sig(sigcontext), (DWORD)RCX_sig(sigcontext), (DWORD)RDX_sig(sigcontext) );
return TRUE;
}
else if (thunk_len >= sizeof(thunk_copy.t4) && thunk_copy.t4.movl1 == 0xb9 &&
thunk_copy.t4.movl2 == 0xb8 &&
thunk_copy.t4.jmp == 0xe0ff)
{
RCX_sig(sigcontext) = thunk_copy.t4.this;
RAX_sig(sigcontext) = thunk_copy.t4.func;
RIP_sig(sigcontext) = thunk_copy.t4.func;
TRACE( "emulating ATL thunk type 4 at %p, func=%08x eax=%08x ecx=%08x\n",
thunk, (DWORD)RIP_sig(sigcontext), (DWORD)RAX_sig(sigcontext), (DWORD)RCX_sig(sigcontext) );
return TRUE;
}
else if (thunk_len >= sizeof(thunk_copy.t5) && thunk_copy.t5.inst1 == 0xff515859 &&
thunk_copy.t5.inst2 == 0x0460)
{
DWORD func, sp[2];
if (virtual_uninterrupted_read_memory( (DWORD *)stack->context.Esp, sp, sizeof(sp) ) == sizeof(sp) &&
virtual_uninterrupted_read_memory( (DWORD *)sp[1] + 1, &func, sizeof(DWORD) ) == sizeof(DWORD) &&
!virtual_uninterrupted_write_memory( (DWORD *)stack->context.Esp + 1, &sp[0], sizeof(sp[0]) ))
{
RCX_sig(sigcontext) = sp[0];
RAX_sig(sigcontext) = sp[1];
RSP_sig(sigcontext) += sizeof(DWORD);
RIP_sig(sigcontext) = func;
TRACE( "emulating ATL thunk type 5 at %p, func=%08x eax=%08x ecx=%08x esp=%08x\n",
thunk, (DWORD)RIP_sig(sigcontext), (DWORD)RAX_sig(sigcontext),
(DWORD)RCX_sig(sigcontext), (DWORD)RSP_sig(sigcontext) );
return TRUE;
}
}
return FALSE;
}
/***********************************************************************
* setup_exception_record
*
* Setup the exception record and context on the thread stack.
*/
static struct stack_layout *setup_exception_record( ucontext_t *sigcontext )
{
struct stack_layout *stack = (struct stack_layout *)(DWORD)(RSP_sig(sigcontext) & ~15);
DWORD exception_code = 0;
/* stack sanity checks */
if ((char *)stack >= (char *)get_signal_stack() &&
(char *)stack < (char *)get_signal_stack() + signal_stack_size)
{
WINE_ERR( "nested exception on signal stack in thread %04x eip %lx esp %lx stack %p-%p\n",
GetCurrentThreadId(), (DWORD64)RIP_sig(sigcontext),
(DWORD64)RSP_sig(sigcontext), NtCurrentTeb()->Tib.StackLimit,
NtCurrentTeb()->Tib.StackBase );
abort_thread(1);
}
if (stack - 1 > stack || /* check for overflow in subtraction */
(char *)stack <= (char *)NtCurrentTeb()->DeallocationStack ||
(char *)stack > (char *)NtCurrentTeb()->Tib.StackBase)
{
WARN( "exception outside of stack limits in thread %04x eip %lx esp %lx stack %p-%p\n",
GetCurrentThreadId(), (DWORD64)RIP_sig(sigcontext),
(DWORD64)RSP_sig(sigcontext), NtCurrentTeb()->Tib.StackLimit,
NtCurrentTeb()->Tib.StackBase );
}
else if ((char *)(stack - 1) < (char *)NtCurrentTeb()->DeallocationStack + 4096)
{
/* stack overflow on last page, unrecoverable */
UINT diff = (char *)NtCurrentTeb()->DeallocationStack + 4096 - (char *)(stack - 1);
WINE_ERR( "stack overflow %u bytes in thread %04x eip %lx esp %lx stack %p-%p-%p\n",
diff, GetCurrentThreadId(), (DWORD64)RIP_sig(sigcontext),
(DWORD64)RSP_sig(sigcontext), NtCurrentTeb()->DeallocationStack,
NtCurrentTeb()->Tib.StackLimit, NtCurrentTeb()->Tib.StackBase );
abort_thread(1);
}
else if ((char *)(stack - 1) < (char *)NtCurrentTeb()->Tib.StackLimit)
{
/* stack access below stack limit, may be recoverable */
switch (virtual_handle_stack_fault( stack - 1 ))
{
case 0: /* not handled */
{
UINT diff = (char *)NtCurrentTeb()->Tib.StackLimit - (char *)(stack - 1);
WINE_ERR( "stack overflow %u bytes in thread %04x eip %lx esp %lx stack %p-%p-%p\n",
diff, GetCurrentThreadId(), (DWORD64)RIP_sig(sigcontext),
(DWORD64)RSP_sig(sigcontext), NtCurrentTeb()->DeallocationStack,
NtCurrentTeb()->Tib.StackLimit, NtCurrentTeb()->Tib.StackBase );
abort_thread(1);
}
case -1: /* overflow */
exception_code = EXCEPTION_STACK_OVERFLOW;
break;
}
}
stack--; /* push the stack_layout structure */
#if defined(VALGRIND_MAKE_MEM_UNDEFINED)
VALGRIND_MAKE_MEM_UNDEFINED(stack, sizeof(*stack));
#elif defined(VALGRIND_MAKE_WRITABLE)
VALGRIND_MAKE_WRITABLE(stack, sizeof(*stack));
#endif
stack->rec.ExceptionRecord = NULL;
stack->rec.ExceptionCode = exception_code;
stack->rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
stack->rec.ExceptionAddress = (LPVOID)(DWORD)RIP_sig(sigcontext);
stack->rec.NumberParameters = 0;
save_context( &stack->context, sigcontext );
if (sel_is_64bit(stack->context.SegCs))
{
/* Synthesize a 32-bit frame below the 64-bit one which, if resumed,
will restore the 64-bit state by far-returning to 64-bit
set_full_cpu_context64(). */
/* Set up far return destination as a far call would. */
stack->return_sel = wine_32on64_cs64;
stack->return_address = (DWORD)set_full_cpu_context64;
/* Modify the 32-bit context as though we were in the middle of
fake_32bit_exception_code_wrapper, about to far return. */
stack->context.Eip = (DWORD)fake_32bit_exception_code;
stack->context.SegCs = wine_32on64_cs32;
stack->context.Esp = (DWORD)stack;
save_context64( &stack->context64, sigcontext );
stack->context.Edi = (DWORD)&stack->context64; /* parameter for set_full_cpu_context64 */
stack->rec.ExceptionAddress = (LPVOID)stack->context.Eip;
}
return stack;
}
/***********************************************************************
* setup_exception
*
* Setup a proper stack frame for the raise function, and modify the
* sigcontext so that the return from the signal handler will call
* the raise function.
*/
static struct stack_layout *setup_exception( ucontext_t *sigcontext )
{
init_handler( sigcontext );
return setup_exception_record( sigcontext );
}
/**********************************************************************
* raise_generic_exception
*
* Generic raise function for exceptions that don't need special treatment.
*/
static void raise_generic_exception( EXCEPTION_RECORD *rec, CONTEXT *context )
{
NTSTATUS status;
status = raise_exception( rec, context, TRUE );
raise_status( status, rec );
}
/***********************************************************************
* setup_raise_exception
*
* Change context to setup a call to a raise exception function.
*/
static void setup_raise_exception( ucontext_t *sigcontext, struct stack_layout *stack )
{
NTSTATUS status = send_debug_event( &stack->rec, TRUE, &stack->context );
if (status == DBG_CONTINUE || status == DBG_EXCEPTION_HANDLED)
{
restore_context( &stack->context, sigcontext );
return;
}
CS_sig(sigcontext) = wine_32on64_cs64;
RIP_sig(sigcontext) = (ULONG64)raise_generic_exception;
RDI_sig(sigcontext) = (ULONG64)&stack->rec;
RSI_sig(sigcontext) = (ULONG64)&stack->context;
RSP_sig(sigcontext) = (ULONG64)stack;
/* clear single-step, direction, and align check flag */
EFL_sig(sigcontext) &= ~(0x100|0x400|0x40000);
DS_sig(sigcontext) = wine_32on64_ds32;
ES_sig(sigcontext) = wine_32on64_ds32;
}
/**********************************************************************
* get_fpu_code
*
* Get the FPU exception code from the FPU status.
*/
static inline DWORD get_fpu_code( const CONTEXT *context )
{
DWORD status = context->FloatSave.StatusWord & ~(context->FloatSave.ControlWord & 0x3f);
if (status & 0x01) /* IE */
{
if (status & 0x40) /* SF */
return EXCEPTION_FLT_STACK_CHECK;
else
return EXCEPTION_FLT_INVALID_OPERATION;
}
if (status & 0x02) return EXCEPTION_FLT_DENORMAL_OPERAND; /* DE flag */
if (status & 0x04) return EXCEPTION_FLT_DIVIDE_BY_ZERO; /* ZE flag */
if (status & 0x08) return EXCEPTION_FLT_OVERFLOW; /* OE flag */
if (status & 0x10) return EXCEPTION_FLT_UNDERFLOW; /* UE flag */
if (status & 0x20) return EXCEPTION_FLT_INEXACT_RESULT; /* PE flag */
return EXCEPTION_FLT_INVALID_OPERATION; /* generic error */
}
/***********************************************************************
* handle_interrupt
*
* Handle an interrupt.
*/
static BOOL handle_interrupt( unsigned int interrupt, ucontext_t *sigcontext, struct stack_layout *stack )
{
switch(interrupt)
{
case 0x2d:
if (!is_wow64)
{
/* On Wow64, the upper DWORD of Rax contains garbage, and the debug
* service is usually not recognized when called from usermode. */
switch (stack->context.Eax)
{
case 1: /* BREAKPOINT_PRINT */
case 3: /* BREAKPOINT_LOAD_SYMBOLS */
case 4: /* BREAKPOINT_UNLOAD_SYMBOLS */
case 5: /* BREAKPOINT_COMMAND_STRING (>= Win2003) */
RIP_sig(sigcontext) += 3;
return TRUE;
}
}
stack->context.Eip += 3;
stack->rec.ExceptionCode = EXCEPTION_BREAKPOINT;
stack->rec.ExceptionAddress = (void *)stack->context.Eip;
stack->rec.NumberParameters = is_wow64 ? 1 : 3;
stack->rec.ExceptionInformation[0] = stack->context.Eax;
stack->rec.ExceptionInformation[1] = stack->context.Ecx;
stack->rec.ExceptionInformation[2] = stack->context.Edx;
setup_raise_exception( sigcontext, stack );
return TRUE;
default:
return FALSE;
}
}
/**********************************************************************
* segv_handler
*
* Handler for SIGSEGV and related errors.
*/
static void segv_handler( int signal, siginfo_t * HOSTPTR siginfo, void * HOSTPTR sigcontext )
{
struct stack_layout *stack;
ucontext_t *context = sigcontext;
void *stack_ptr = TRUNCCAST( void *, RSP_sig(context) );
init_handler( sigcontext );
/* check for exceptions on the signal stack caused by write watches */
if (get_trap_code(context) == TRAP_x86_PAGEFLT &&
(char *)stack_ptr >= (char *)get_signal_stack() &&
(char *)stack_ptr < (char *)get_signal_stack() + signal_stack_size &&
!virtual_handle_fault( siginfo->si_addr, (get_error_code(context) >> 1) & 0x09, TRUE ))
{
return;
}
/* check for page fault inside the thread stack */
if (get_trap_code(context) == TRAP_x86_PAGEFLT && (ULONG_HOSTPTR)siginfo->si_addr < 0x100000000)
{
switch (virtual_handle_stack_fault( ADDRSPACECAST(void*, siginfo->si_addr) ))
{
case 1: /* handled */
return;
case -1: /* overflow */
stack = setup_exception_record( context );
stack->rec.ExceptionCode = EXCEPTION_STACK_OVERFLOW;
goto done;
}
}
stack = setup_exception_record( context );
if (stack->rec.ExceptionCode == EXCEPTION_STACK_OVERFLOW) goto done;
switch(get_trap_code(context))
{
case TRAP_x86_OFLOW: /* Overflow exception */
stack->rec.ExceptionCode = EXCEPTION_INT_OVERFLOW;
break;
case TRAP_x86_BOUND: /* Bound range exception */
stack->rec.ExceptionCode = EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
break;
case TRAP_x86_PRIVINFLT: /* Invalid opcode exception */
stack->rec.ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
break;
case TRAP_x86_STKFLT: /* Stack fault */
stack->rec.ExceptionCode = EXCEPTION_STACK_OVERFLOW;
break;
case TRAP_x86_SEGNPFLT: /* Segment not present exception */
case TRAP_x86_PROTFLT: /* General protection fault */
case TRAP_x86_UNKNOWN: /* Unknown fault code */
{
WORD err = get_error_code(context);
if (!err && (stack->rec.ExceptionCode = is_privileged_instr( &stack->context ))) break;
if ((err & 7) == 2 && handle_interrupt( err >> 3, context, stack )) return;
stack->rec.ExceptionCode = EXCEPTION_ACCESS_VIOLATION;
stack->rec.NumberParameters = 2;
stack->rec.ExceptionInformation[0] = 0;
/* if error contains a LDT selector, use that as fault address */
if ((err & 7) == 4 && !wine_ldt_is_system( err | 7 ))
stack->rec.ExceptionInformation[1] = err & ~7;
else
stack->rec.ExceptionInformation[1] = 0xffffffff;
}
break;
case TRAP_x86_PAGEFLT: /* Page fault */
stack->rec.NumberParameters = 2;
stack->rec.ExceptionInformation[0] = (get_error_code(context) >> 1) & 0x09;
stack->rec.ExceptionInformation[1] = TRUNCCAST( ULONG_PTR, siginfo->si_addr );
stack->rec.ExceptionCode = virtual_handle_fault( siginfo->si_addr,
stack->rec.ExceptionInformation[0], FALSE );
if (!stack->rec.ExceptionCode) return;
if (stack->rec.ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
stack->rec.ExceptionInformation[0] == EXCEPTION_EXECUTE_FAULT)
{
ULONG flags;
NtQueryInformationProcess( GetCurrentProcess(), ProcessExecuteFlags,
&flags, sizeof(flags), NULL );
if (!(flags & MEM_EXECUTE_OPTION_DISABLE_THUNK_EMULATION) && check_atl_thunk( context, stack ))
return;
/* send EXCEPTION_EXECUTE_FAULT only if data execution prevention is enabled */
if (!(flags & MEM_EXECUTE_OPTION_DISABLE))
stack->rec.ExceptionInformation[0] = EXCEPTION_READ_FAULT;
}
break;
case TRAP_x86_ALIGNFLT: /* Alignment check exception */
/* FIXME: pass through exception handler first? */
if (stack->context.EFlags & 0x00040000)
{
EFL_sig(context) &= ~0x00040000; /* disable AC flag */
return;
}
stack->rec.ExceptionCode = EXCEPTION_DATATYPE_MISALIGNMENT;
break;
default:
WINE_ERR( "Got unexpected trap %d\n", get_trap_code(context) );
/* fall through */
case TRAP_x86_NMI: /* NMI interrupt */
case TRAP_x86_DNA: /* Device not available exception */
case TRAP_x86_DOUBLEFLT: /* Double fault exception */
case TRAP_x86_TSSFLT: /* Invalid TSS exception */
case TRAP_x86_MCHK: /* Machine check exception */
case TRAP_x86_CACHEFLT: /* Cache flush exception */
stack->rec.ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
break;
}
done:
setup_raise_exception( context, stack );
}
/**********************************************************************
* trap_handler
*
* Handler for SIGTRAP.
*/
static void trap_handler( int signal, siginfo_t * HOSTPTR siginfo, void * HOSTPTR sigcontext )
{
ucontext_t *context = sigcontext;
struct stack_layout *stack = setup_exception( context );
switch(get_trap_code(context))
{
case TRAP_x86_TRCTRAP: /* Single-step exception */
stack->rec.ExceptionCode = EXCEPTION_SINGLE_STEP;
/* when single stepping can't tell whether this is a hw bp or a
* single step interrupt. try to avoid as much overhead as possible
* and only do a server call if there is any hw bp enabled. */
if (!(stack->context.EFlags & 0x100) || (stack->context.Dr7 & 0xff))
{
/* (possible) hardware breakpoint, fetch the debug registers */
DWORD saved_flags = stack->context.ContextFlags;
stack->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
__regs_NtGetContextThread( GetCurrentThread(), &stack->context, NULL );
stack->context.ContextFlags |= saved_flags; /* restore flags */
}
stack->context.EFlags &= ~0x100; /* clear single-step flag */
break;
case TRAP_x86_BPTFLT: /* Breakpoint exception */
stack->rec.ExceptionAddress = (char *)stack->rec.ExceptionAddress - 1; /* back up over the int3 instruction */
/* fall through */
default:
stack->rec.ExceptionCode = EXCEPTION_BREAKPOINT;
stack->rec.NumberParameters = is_wow64 ? 1 : 3;
stack->rec.ExceptionInformation[0] = 0;
stack->rec.ExceptionInformation[1] = 0; /* FIXME */
stack->rec.ExceptionInformation[2] = 0; /* FIXME */
break;
}
setup_raise_exception( context, stack );
}
/**********************************************************************
* fpe_handler
*
* Handler for SIGFPE.
*/
static void fpe_handler( int signal, siginfo_t * HOSTPTR siginfo, void * HOSTPTR sigcontext )
{
ucontext_t *context = sigcontext;
struct stack_layout *stack = setup_exception( context );
switch(get_trap_code(context))
{
case TRAP_x86_DIVIDE: /* Division by zero exception */
stack->rec.ExceptionCode = EXCEPTION_INT_DIVIDE_BY_ZERO;
break;
case TRAP_x86_FPOPFLT: /* Coprocessor segment overrun */
stack->rec.ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION;
break;
case TRAP_x86_ARITHTRAP: /* Floating point exception */
case TRAP_x86_UNKNOWN: /* Unknown fault code */
stack->rec.ExceptionCode = get_fpu_code( &stack->context );
stack->rec.ExceptionAddress = (LPVOID)stack->context.FloatSave.ErrorOffset;
break;
case TRAP_x86_CACHEFLT: /* SIMD exception */
/* TODO:
* Behaviour only tested for divide-by-zero exceptions
* Check for other SIMD exceptions as well */
if(siginfo->si_code != FPE_FLTDIV && siginfo->si_code != FPE_FLTINV)
FIXME("untested SIMD exception: %#x. Might not work correctly\n",
siginfo->si_code);
stack->rec.ExceptionCode = STATUS_FLOAT_MULTIPLE_TRAPS;
stack->rec.NumberParameters = 1;
/* no idea what meaning is actually behind this but that's what native does */
stack->rec.ExceptionInformation[0] = 0;
break;
default:
WINE_ERR( "Got unexpected trap %d\n", get_trap_code(context) );
stack->rec.ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION;
break;
}
setup_raise_exception( context, stack );
}
/**********************************************************************
* int_handler
*
* Handler for SIGINT.
*
* FIXME: should not be calling external functions on the signal stack.
*/
static void int_handler( int signal, siginfo_t * HOSTPTR siginfo, void * HOSTPTR sigcontext )
{
init_handler( sigcontext );
if (!dispatch_signal(SIGINT))
{
struct stack_layout *stack = setup_exception( sigcontext );
stack->rec.ExceptionCode = CONTROL_C_EXIT;
setup_raise_exception( sigcontext, stack );
}
}
/**********************************************************************
* abrt_handler
*
* Handler for SIGABRT.
*/
static void abrt_handler( int signal, siginfo_t * HOSTPTR siginfo, void * HOSTPTR sigcontext )
{
struct stack_layout *stack = setup_exception( sigcontext );
stack->rec.ExceptionCode = EXCEPTION_WINE_ASSERTION;
stack->rec.ExceptionFlags = EH_NONCONTINUABLE;
setup_raise_exception( sigcontext, stack );
}
/**********************************************************************
* quit_handler
*
* Handler for SIGQUIT.
*/
static void quit_handler( int signal, siginfo_t * HOSTPTR siginfo, void * HOSTPTR sigcontext )
{
init_handler( sigcontext );
abort_thread(0);
}
/**********************************************************************
* usr1_handler
*
* Handler for SIGUSR1, used to signal a thread that it got suspended.
*/
static void usr1_handler( int signal, siginfo_t * HOSTPTR siginfo, void * HOSTPTR sigcontext )
{
CONTEXT context;
init_handler( sigcontext );
save_context( &context, sigcontext );
wait_suspend( &context );
restore_context( &context, sigcontext );
}
/***********************************************************************
* __wine_set_signal_handler (NTDLL.@)
*/
int CDECL __wine_set_signal_handler(unsigned int sig, wine_signal_handler wsh)
{
if (sig >= ARRAY_SIZE(handlers)) return -1;
if (handlers[sig] != NULL) return -2;
handlers[sig] = wsh;
return 0;
}
/***********************************************************************
* locking for LDT routines
*/
static RTL_CRITICAL_SECTION ldt_section;
static RTL_CRITICAL_SECTION_DEBUG critsect_debug =
{
0, 0, &ldt_section,
{ &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
0, 0, { (DWORD_PTR)(__FILE__ ": ldt_section") }
};
static RTL_CRITICAL_SECTION ldt_section = { &critsect_debug, -1, 0, 0, 0, 0 };
static sigset_t ldt_sigset;
static void ldt_lock(void)
{
sigset_t sigset;
pthread_sigmask( SIG_BLOCK, &server_block_set, &sigset );
RtlEnterCriticalSection( &ldt_section );
if (ldt_section.RecursionCount == 1) ldt_sigset = sigset;
}
static void ldt_unlock(void)
{
if (ldt_section.RecursionCount == 1)
{
sigset_t sigset = ldt_sigset;
RtlLeaveCriticalSection( &ldt_section );
pthread_sigmask( SIG_SETMASK, &sigset, NULL );
}
else RtlLeaveCriticalSection( &ldt_section );
}
/**********************************************************************
* signal_alloc_thread
*/
NTSTATUS signal_alloc_thread( TEB **teb )
{
static size_t sigstack_alignment;
struct x86_thread_data *thread_data;
SIZE_T size;
void *addr = NULL;
NTSTATUS status;
if (!sigstack_alignment)
{
size_t min_size = teb_size + max( MINSIGSTKSZ, 8192 );
/* find the first power of two not smaller than min_size */
sigstack_alignment = 12;
while ((1u << sigstack_alignment) < min_size) sigstack_alignment++;
signal_stack_mask = (1 << sigstack_alignment) - 1;
signal_stack_size = (1 << sigstack_alignment) - teb_size;
}
size = signal_stack_mask + 1;
if (!(status = virtual_alloc_aligned( &addr, 0, &size, MEM_COMMIT | MEM_TOP_DOWN,
PAGE_READWRITE, sigstack_alignment )))
{
*teb = addr;
(*teb)->Tib.Self = &(*teb)->Tib;
(*teb)->Tib.ExceptionList = (void *)~0UL;
(*teb)->WOW32Reserved = __wine_syscall_dispatcher;
(*teb)->Spare2 = __wine_fakedll_dispatcher;
thread_data = (struct x86_thread_data *)(*teb)->SystemReserved2;
if (!(thread_data->fs = wine_ldt_alloc_fs()))
{
size = 0;
NtFreeVirtualMemory( NtCurrentProcess(), &addr, &size, MEM_RELEASE );
status = STATUS_TOO_MANY_THREADS;
}
}
return status;
}
/**********************************************************************
* signal_free_thread
*/
void signal_free_thread( TEB *teb )
{
SIZE_T size = 0;
struct x86_thread_data *thread_data = (struct x86_thread_data *)teb->SystemReserved2;
wine_ldt_free_fs( thread_data->fs );
NtFreeVirtualMemory( NtCurrentProcess(), (void **)&teb, &size, MEM_RELEASE );
}
/**********************************************************************
* signal_init_thread
*/
void signal_init_thread( TEB *teb )
{
const WORD fpu_cw = 0x27f;
struct x86_thread_data *thread_data = (struct x86_thread_data *)teb->SystemReserved2;
LDT_ENTRY fs_entry;
stack_t ss;
wine_ldt_set_base( &fs_entry, teb );
wine_ldt_set_limit( &fs_entry, teb_size - 1 );
wine_ldt_set_flags( &fs_entry, WINE_LDT_FLAGS_DATA|WINE_LDT_FLAGS_32BIT );
wine_ldt_init_fs( thread_data->fs, &fs_entry );
thread_data->gs = wine_get_gs();
__asm__ volatile ( "mov %0, %%ds\n\t"
"mov %0, %%es\n\t"
: : "r" (wine_32on64_ds32) );
ss.ss_sp = (char *)teb + teb_size;
ss.ss_size = signal_stack_size;
ss.ss_flags = 0;
if (sigaltstack(&ss, NULL) == -1) perror( "sigaltstack" );
__asm__ volatile ("fninit; fldcw %0" : : "m" (fpu_cw));
}
/**********************************************************************
* signal_init_process
*/
void signal_init_process(void)
{
struct sigaction sig_act;
sig_act.sa_mask = server_block_set;
sig_act.sa_flags = SA_RESTART | SA_SIGINFO | SA_ONSTACK;
sig_act.sa_sigaction = int_handler;
if (sigaction( SIGINT, &sig_act, NULL ) == -1) goto error;
sig_act.sa_sigaction = fpe_handler;
if (sigaction( SIGFPE, &sig_act, NULL ) == -1) goto error;
sig_act.sa_sigaction = abrt_handler;
if (sigaction( SIGABRT, &sig_act, NULL ) == -1) goto error;
sig_act.sa_sigaction = quit_handler;
if (sigaction( SIGQUIT, &sig_act, NULL ) == -1) goto error;
sig_act.sa_sigaction = usr1_handler;
if (sigaction( SIGUSR1, &sig_act, NULL ) == -1) goto error;
sig_act.sa_sigaction = segv_handler;
if (sigaction( SIGSEGV, &sig_act, NULL ) == -1) goto error;
if (sigaction( SIGILL, &sig_act, NULL ) == -1) goto error;
if (sigaction( SIGBUS, &sig_act, NULL ) == -1) goto error;
sig_act.sa_sigaction = trap_handler;
if (sigaction( SIGTRAP, &sig_act, NULL ) == -1) goto error;
wine_ldt_init_locking( ldt_lock, ldt_unlock );
return;
error:
perror("sigaction");
exit(1);
}
/*******************************************************************
* RtlUnwind (NTDLL.@)
*/
void WINAPI DECLSPEC_HIDDEN __regs_RtlUnwind( EXCEPTION_REGISTRATION_RECORD* pEndFrame, PVOID targetIp,
PEXCEPTION_RECORD pRecord, PVOID retval, CONTEXT *context )
{
EXCEPTION_RECORD record;
EXCEPTION_REGISTRATION_RECORD *frame, *dispatch;
DWORD res;
context->Eax = (DWORD)retval;
/* build an exception record, if we do not have one */
if (!pRecord)
{
record.ExceptionCode = STATUS_UNWIND;
record.ExceptionFlags = 0;
record.ExceptionRecord = NULL;
record.ExceptionAddress = (void *)context->Eip;
record.NumberParameters = 0;
pRecord = &record;
}
pRecord->ExceptionFlags |= EH_UNWINDING | (pEndFrame ? 0 : EH_EXIT_UNWIND);
TRACE( "code=%x flags=%x\n", pRecord->ExceptionCode, pRecord->ExceptionFlags );
TRACE( "eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x\n",
context->Eax, context->Ebx, context->Ecx, context->Edx, context->Esi, context->Edi );
TRACE( "ebp=%08x esp=%08x eip=%08x cs=%04x ds=%04x fs=%04x gs=%04x flags=%08x\n",
context->Ebp, context->Esp, context->Eip, LOWORD(context->SegCs), LOWORD(context->SegDs),
LOWORD(context->SegFs), LOWORD(context->SegGs), context->EFlags );
/* get chain of exception frames */
frame = NtCurrentTeb()->Tib.ExceptionList;
while ((frame != (EXCEPTION_REGISTRATION_RECORD*)~0UL) && (frame != pEndFrame))
{
/* Check frame address */
if (pEndFrame && (frame > pEndFrame))
raise_status( STATUS_INVALID_UNWIND_TARGET, pRecord );
if (!is_valid_frame( frame )) raise_status( STATUS_BAD_STACK, pRecord );
/* Call handler */
TRACE( "calling handler at %p code=%x flags=%x\n",
frame->Handler, pRecord->ExceptionCode, pRecord->ExceptionFlags );
res = WINE_CALL_IMPL32(EXC_CallHandler)( pRecord, frame, context, &dispatch, frame->Handler, unwind_handler );
TRACE( "handler at %p returned %x\n", frame->Handler, res );
switch(res)
{
case ExceptionContinueSearch:
break;
case ExceptionCollidedUnwind:
frame = dispatch;
break;
default:
raise_status( STATUS_INVALID_DISPOSITION, pRecord );
break;
}
frame = __wine_pop_frame( frame );
}
NtSetContextThread( GetCurrentThread(), context );
}
/*******************************************************************
* RtlUnwind (NTDLL.@)
*/
__ASM_STDCALL_FUNC32( __ASM_THUNK_NAME(RtlUnwind), 16,
"pushl %ebp\n\t"
__ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
__ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
"movl %esp,%ebp\n\t"
__ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
"leal -(0x2cc+8)(%esp),%esp\n\t" /* sizeof(CONTEXT) + alignment */
"pushl %eax\n\t"
"leal 4(%esp),%eax\n\t" /* context */
"xchgl %eax,(%esp)\n\t"
"call " __ASM_THUNK_STDCALL_SYMBOL("RtlCaptureContext",4) "\n\t"
"leal 24(%ebp),%eax\n\t"
"movl %eax,0xc4(%esp)\n\t" /* context->Esp */
"pushl %esp\n\t"
"pushl 20(%ebp)\n\t"
"pushl 16(%ebp)\n\t"
"pushl 12(%ebp)\n\t"
"pushl 8(%ebp)\n\t"
"call " __ASM_THUNK_STDCALL_SYMBOL("__regs_RtlUnwind",20) "\n\t"
"leave\n\t"
__ASM_CFI(".cfi_def_cfa %esp,4\n\t")
__ASM_CFI(".cfi_same_value %ebp\n\t")
"ret $16" ) /* actually never returns */
NTSTATUS WINAPI __syscall_NtContinue( CONTEXT *context, BOOLEAN alert );
/*******************************************************************
* NtRaiseException (NTDLL.@)
*/
NTSTATUS WINAPI NtRaiseException( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
{
if (first_chance)
{
NTSTATUS status = send_debug_event( rec, TRUE, context );
if (status == DBG_CONTINUE || status == DBG_EXCEPTION_HANDLED)
SYSCALL(NtContinue)(context, FALSE);
}
return raise_exception( rec, context, first_chance );
}
/*******************************************************************
* raise_exception_full_context
*
* Raise an exception with the full CPU context.
*/
void CDECL DECLSPEC_HIDDEN raise_exception_full_context( EXCEPTION_RECORD *rec, CONTEXT *context )
{
save_fpu( context );
save_fpux( context );
/* FIXME: xstate */
context->Dr0 = x86_thread_data()->dr0;
context->Dr1 = x86_thread_data()->dr1;
context->Dr2 = x86_thread_data()->dr2;
context->Dr3 = x86_thread_data()->dr3;
context->Dr6 = x86_thread_data()->dr6;
context->Dr7 = x86_thread_data()->dr7;
context->ContextFlags |= CONTEXT_DEBUG_REGISTERS;
RtlRaiseStatus( NtRaiseException( rec, context, TRUE ));
}
/***********************************************************************
* RtlRaiseException (NTDLL.@)
*/
void WINAPI RtlRaiseException( EXCEPTION_RECORD *rec )
{
WINE_CALL_IMPL32(RtlRaiseException)( rec );
}
__ASM_STDCALL_FUNC32( __ASM_THUNK_NAME(RtlRaiseException), 4,
"pushl %ebp\n\t"
__ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
__ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
"movl %esp,%ebp\n\t"
__ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
"leal -0x2cc(%esp),%esp\n\t" /* sizeof(CONTEXT) */
"pushl %esp\n\t" /* context */
"call " __ASM_THUNK_STDCALL_SYMBOL("RtlCaptureContext",4) "\n\t"
"movl 4(%ebp),%eax\n\t" /* return address */
"movl 8(%ebp),%ecx\n\t" /* rec */
"movl %eax,12(%ecx)\n\t" /* rec->ExceptionAddress */
"leal 12(%ebp),%eax\n\t"
"movl %eax,0xc4(%esp)\n\t" /* context->Esp */
"movl %esp,%eax\n\t"
"pushl %eax\n\t"
"pushl %ecx\n\t"
"call " __ASM_THUNK_SYMBOL("raise_exception_full_context") "\n\t"
"leave\n\t"
__ASM_CFI(".cfi_def_cfa %esp,4\n\t")
__ASM_CFI(".cfi_same_value %ebp\n\t")
"ret $4" ) /* actually never returns */
/*************************************************************************
* RtlCaptureStackBackTrace (NTDLL.@)
*/
USHORT WINAPI RtlCaptureStackBackTrace( ULONG skip, ULONG count, PVOID *buffer, ULONG *hash )
{
FIXME( "(%d, %d, %p, %p) stub!\n", skip, count, buffer, hash );
return 0;
}
extern void DECLSPEC_NORETURN start_thread( LPTHREAD_START_ROUTINE entry, void *arg, BOOL suspend,
void *relay );
__ASM_GLOBAL_FUNC( start_thread,
"subq $56,%rsp\n\t"
__ASM_CFI(".cfi_adjust_cfa_offset 56\n\t")
"movq %rbp,48(%rsp)\n\t"
__ASM_CFI(".cfi_rel_offset %rbp,48\n\t")
"movq %rbx,40(%rsp)\n\t"
__ASM_CFI(".cfi_rel_offset %rbx,40\n\t")
"movq %r12,32(%rsp)\n\t"
__ASM_CFI(".cfi_rel_offset %r12,32\n\t")
"movq %r13,24(%rsp)\n\t"
__ASM_CFI(".cfi_rel_offset %r13,24\n\t")
"movq %r14,16(%rsp)\n\t"
__ASM_CFI(".cfi_rel_offset %r14,16\n\t")
"movq %r15,8(%rsp)\n\t"
__ASM_CFI(".cfi_rel_offset %r15,8\n\t")
/* store exit frame */
"movq %rbp,%fs:0x1f4\n\t" /* x86_thread_data()->exit_frame */
/* switch to thread stack */
"movl %fs:4,%eax\n\t" /* NtCurrentTeb()->Tib.StackBase */
"leaq -0x1000(%rax),%rsp\n\t"
/* attach dlls */
"call " __ASM_NAME("attach_thread") "\n\t"
"movq %rax,%rsp\n\t"
/* clear the stack */
"andq $~0xfff,%rax\n\t" /* round down to page size */
"movq %rax,%rdi\n\t"
"call " __ASM_NAME("virtual_clear_thread_stack") "\n\t"
/* switch to the initial context */
"movq %rsp,%rdi\n\t"
"call " __ASM_NAME("set_cpu_context") )
extern void DECLSPEC_NORETURN call_thread_exit_func( int status, void (* HOSTPTR func)(int) );
__ASM_GLOBAL_FUNC( call_thread_exit_func,
/* fetch exit frame */
"movq %fs:0x1f4,%rdx\n\t" /* x86_thread_data()->exit_frame */
"testq %rdx,%rdx\n\t"
"jnz 1f\n\t"
"jmp *%rsi\n"
/* switch to exit frame stack */
"1:\tmovq $0,%fs:0x1f4\n\t"
"movq %rdx,%rsp\n\t"
__ASM_CFI(".cfi_adjust_cfa_offset 56\n\t")
__ASM_CFI(".cfi_rel_offset %rbp,48\n\t")
__ASM_CFI(".cfi_rel_offset %rbx,40\n\t")
__ASM_CFI(".cfi_rel_offset %r12,32\n\t")
__ASM_CFI(".cfi_rel_offset %r13,24\n\t")
__ASM_CFI(".cfi_rel_offset %r14,16\n\t")
__ASM_CFI(".cfi_rel_offset %r15,8\n\t")
"call *%rsi" )
extern void CDECL call_thread_func_wrapper(void) DECLSPEC_HIDDEN;
__ASM_GLOBAL_FUNC32( __ASM_THUNK_NAME(call_thread_func_wrapper),
"pushl %ebp\n\t"
__ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
__ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
"movl %esp,%ebp\n\t"
__ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
"pushl %ebx\n\t" /* arg */
"pushl %eax\n\t" /* entry */
"call " __ASM_THUNK_SYMBOL("call_thread_func") )
/* wrapper for apps that don't declare the thread function correctly */
extern DWORD CDECL call_entry( LPTHREAD_START_ROUTINE entry, void *arg );
__ASM_GLOBAL_FUNC32( __ASM_THUNK_NAME(call_entry),
"pushl %ebp\n\t"
__ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
__ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
"movl %esp,%ebp\n\t"
__ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
"subl $4,%esp\n\t"
"pushl 12(%ebp)\n\t"
"call *8(%ebp)\n\t"
"leave\n\t"
__ASM_CFI(".cfi_def_cfa %esp,4\n\t")
__ASM_CFI(".cfi_same_value %ebp\n\t")
"ret" )
/***********************************************************************
* call_thread_func
*/
extern void WINAPI call_thread_func( LPTHREAD_START_ROUTINE entry, void *arg )
{
__TRY
{
DWORD ret;
TRACE_(relay)( "\1Starting thread proc %p (arg=%p)\n", entry, arg );
if (wine_is_thunk32to64(entry))
ret = entry(arg);
else
ret = WINE_CALL_IMPL32(call_entry)( entry, arg );
RtlExitUserThread( ret );
}
__EXCEPT(call_unhandled_exception_filter)
{
NtTerminateThread( GetCurrentThread(), GetExceptionCode() );
}
__ENDTRY
abort(); /* should not be reached */
}
/***********************************************************************
* init_thread_context
*/
static void init_thread_context( CONTEXT *context, LPTHREAD_START_ROUTINE entry, void *arg, void *relay )
{
context->SegCs = wine_32on64_cs32;
context->SegDs = wine_get_ds();
context->SegEs = wine_get_es();
context->SegFs = wine_get_fs();
context->SegGs = wine_get_gs();
context->SegSs = wine_get_ss();
context->EFlags = 0x202;
context->Eax = (DWORD)entry;
context->Ebx = (DWORD)arg;
context->Esp = (DWORD)NtCurrentTeb()->Tib.StackBase - 16;
context->Eip = (DWORD)relay;
context->FloatSave.ControlWord = 0x27f;
((XMM_SAVE_AREA32 *)context->ExtendedRegisters)->ControlWord = 0x27f;
((XMM_SAVE_AREA32 *)context->ExtendedRegisters)->MxCsr = 0x1f80;
}
/***********************************************************************
* attach_thread
*/
PCONTEXT DECLSPEC_HIDDEN attach_thread( LPTHREAD_START_ROUTINE entry, void *arg,
BOOL suspend, void *relay )
{
CONTEXT *ctx;
if (suspend)
{
CONTEXT context = { CONTEXT_ALL };
init_thread_context( &context, entry, arg, relay );
wait_suspend( &context );
ctx = (CONTEXT *)((ULONG_PTR)context.Esp & ~15) - 1;
*ctx = context;
}
else
{
ctx = (CONTEXT *)((char *)NtCurrentTeb()->Tib.StackBase - 16) - 1;
memset( ctx, 0, sizeof(*ctx) );
init_thread_context( ctx, entry, arg, relay );
}
ctx->ContextFlags = CONTEXT_FULL | CONTEXT_FLOATING_POINT | CONTEXT_EXTENDED_REGISTERS;
LdrInitializeThunk( ctx, (void **)&ctx->Eax, 0, 0 );
return ctx;
}
/***********************************************************************
* signal_start_thread
*
* Thread startup sequence:
* signal_start_thread()
* -> start_thread()
* -> call_thread_func_wrapper()
* -> call_thread_func()
*/
void signal_start_thread( LPTHREAD_START_ROUTINE entry, void *arg, BOOL suspend )
{
start_thread( entry, arg, suspend, call_thread_func_wrapper );
}
/**********************************************************************
* signal_start_process
*
* Process startup sequence:
* signal_start_process()
* -> start_thread()
* -> kernel32_start_process()
*/
void signal_start_process( LPTHREAD_START_ROUTINE entry, BOOL suspend )
{
start_thread( entry, NtCurrentTeb()->Peb, suspend, kernel32_start_process );
}
/***********************************************************************
* signal_exit_thread
*/
void signal_exit_thread( int status )
{
call_thread_exit_func( status, exit_thread );
}
/***********************************************************************
* signal_exit_process
*/
void signal_exit_process( int status )
{
call_thread_exit_func( status, exit );
}
/**********************************************************************
* DbgBreakPoint (NTDLL.@)
*/
__ASM_STDCALL_FUNC( DbgBreakPoint, 0, "int $3; ret")
__ASM_THUNK_STDCALL( DbgBreakPoint, 0, "int $3; ret")
/**********************************************************************
* DbgUserBreakPoint (NTDLL.@)
*/
__ASM_STDCALL_FUNC( DbgUserBreakPoint, 0, "int $3; ret")
__ASM_THUNK_STDCALL( DbgUserBreakPoint, 0, "int $3; ret")
/**********************************************************************
* NtCurrentTeb (NTDLL.@)
*/
__ASM_STDCALL_FUNC( NTDLL_NtCurrentTeb, 0, "movl %fs:0x18,%eax\n\tret" )
__ASM_THUNK_STDCALL( NTDLL_NtCurrentTeb, 0, "movl %fs:0x18,%eax\n\tret" )
/**************************************************************************
* _chkstk (NTDLL.@)
*/
__ASM_STDCALL_FUNC32( __ASM_THUNK_NAME(_chkstk), 0,
"negl %eax\n\t"
"addl %esp,%eax\n\t"
"xchgl %esp,%eax\n\t"
"movl 0(%eax),%eax\n\t" /* copy return address from old location */
"movl %eax,0(%esp)\n\t"
"ret" )
/**************************************************************************
* _alloca_probe (NTDLL.@)
*/
__ASM_STDCALL_FUNC32( __ASM_THUNK_NAME(_alloca_probe), 0,
"negl %eax\n\t"
"addl %esp,%eax\n\t"
"xchgl %esp,%eax\n\t"
"movl 0(%eax),%eax\n\t" /* copy return address from old location */
"movl %eax,0(%esp)\n\t"
"ret" )
/**********************************************************************
* EXC_CallHandler (internal)
*
* Some exception handlers depend on EBP to have a fixed position relative to
* the exception frame.
* Shrinker depends on (*1) doing what it does,
* (*2) being the exact instruction it is and (*3) beginning with 0x64
* (i.e. the %fs prefix to the movl instruction). It also depends on the
* function calling the handler having only 5 parameters (*4).
*/
__ASM_GLOBAL_FUNC32( __ASM_THUNK_NAME(EXC_CallHandler),
"pushl %ebp\n\t"
__ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
__ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
"movl %esp,%ebp\n\t"
__ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
"pushl %ebx\n\t"
__ASM_CFI(".cfi_rel_offset %ebx,-4\n\t")
"movl 28(%ebp), %edx\n\t" /* ugly hack to pass the 6th param needed because of Shrinker */
"pushl 24(%ebp)\n\t"
"pushl 20(%ebp)\n\t"
"pushl 16(%ebp)\n\t"
"pushl 12(%ebp)\n\t"
"pushl 8(%ebp)\n\t"
"call " __ASM_NAME("call_exception_handler") "\n\t"
"popl %ebx\n\t"
__ASM_CFI(".cfi_same_value %ebx\n\t")
"leave\n"
__ASM_CFI(".cfi_def_cfa %esp,4\n\t")
__ASM_CFI(".cfi_same_value %ebp\n\t")
"ret" )
__ASM_GLOBAL_FUNC32(call_exception_handler,
"pushl %ebp\n\t"
__ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
__ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
"movl %esp,%ebp\n\t"
__ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
"subl $12,%esp\n\t"
"pushl 12(%ebp)\n\t" /* make any exceptions in this... */
"pushl %edx\n\t" /* handler be handled by... */
".byte 0x64\n\t"
"pushl (0)\n\t" /* nested_handler (passed in edx). */
".byte 0x64\n\t"
"movl %esp,(0)\n\t" /* push the new exception frame onto the exception stack. */
"pushl 20(%ebp)\n\t"
"pushl 16(%ebp)\n\t"
"pushl 12(%ebp)\n\t"
"pushl 8(%ebp)\n\t"
"movl 24(%ebp), %ecx\n\t" /* (*1) */
"call *%ecx\n\t" /* call handler. (*2) */
".byte 0x64\n\t"
"movl (0), %esp\n\t" /* restore previous... (*3) */
".byte 0x64\n\t"
"popl (0)\n\t" /* exception frame. */
"movl %ebp, %esp\n\t" /* restore saved stack, in case it was corrupted */
"popl %ebp\n\t"
__ASM_CFI(".cfi_def_cfa %esp,4\n\t")
__ASM_CFI(".cfi_same_value %ebp\n\t")
"ret $20" ) /* (*4) */
#endif /* __i386_on_x86_64__ */
|
the_stack_data/60373.c |
// #include <avr/io.h>
// #include "i2c.h"
// #include <util/delay.h>
// #include <math.h>
// #include <avr/interrupt.h>
// #include "serial_printf.h"
// #define PI 3.14159265358979323846
// #define RANGE_2G 0b00001000
// #define MEASURE 0x08
// #define DATA_RATE_100 0x0A
// #define I2C_ADDR 0x53
// #define DEVID 0x00
// #define POWER_CTL 0x2D
// #define BW_RATE 0x2C
// #define DATA_FORMAT 0x31
// #define DATAX 0x32
// #define DATAX0 0x32 // X-Axis Data 0
// #define DATAX1 0x33 // X-Axis Data 1
// #define DATAY 0x34
// #define DATAY0 0x34 // Y-Axis Data 0
// #define DATAY1 0x35 // Y-Axis Data 1
// #define DATAZ 0x36
// #define DATAZ0 0x36 // Z-Axis Data 0
// #define DATAZ1 0x37 // Z-Axis Data 1
// #define OFSX 0x1E
// #define OFSY 0x1F
// #define OFSZ 0x20
// uint8_t ADXL345_ID;
// uint8_t lsb, msb;
// uint16_t x_acc1, y_acc1, z_acc1;
// void ADXL345_init(uint8_t range, uint8_t data_rate)
// {
// uint8_t var = 0;
// i2c_read(I2C_ADDR, 1, DEVID, &ADXL345_ID);
// printf("Device ID=%d\n\r", ADXL345_ID);
// i2c_write(I2C_ADDR, 1, POWER_CTL, &var);
// i2c_write(I2C_ADDR, 1, BW_RATE, &data_rate);
// i2c_write(I2C_ADDR, 1, DATA_FORMAT, &range);
// var = MEASURE;
// i2c_write(I2C_ADDR, 1, POWER_CTL, &var);
// _delay_ms(20);
// }
// uint16_t read_Xdata(void){
// int16_t data;
// uint8_t buf[2];
// i2c_read(I2C_ADDR, 2, DATAX, buf);
// data = (int16_t)buf[1]<<8;
// data += (int16_t)buf[0];
// return(data);
// }
// uint16_t read_Ydata(void){
// int16_t data;
// uint8_t buf[2];
// i2c_read(I2C_ADDR, 2, DATAY, buf);
// data = (int16_t)buf[1]<<8;
// data += (int16_t)buf[0];
// return(data);
// }
// uint16_t read_Zdata(void){
// int16_t data;
// uint8_t buf[2];
// i2c_read(I2C_ADDR, 2, DATAZ, buf);
// data = (int16_t)buf[1]<<8;
// data += (int16_t)buf[0];
// return(data);
// }
// int main(void)
// {
// int16_t datax, datay, dataz;
// float X_out, Y_out, Z_out, roll, pitch, rollF = 0, pitchF = 0;
// int8_t offx, offy, offz;
// printf_init();
// i2c_init(100000);
// ADXL345_init(RANGE_2G, DATA_RATE_100);
// // offsets
// // datax = 17
// offx= (-17/4);
// printf("%d\n",offx);
// i2c_write(I2C_ADDR, 1, OFSX, &offx);
// offy= (23/4);
// printf("%d\n",offy);
// i2c_write(I2C_ADDR, 1, OFSY, &offy);
// while(1){
// datax = read_Xdata();
// X_out = (float)datax/256.0;
// datay = read_Ydata();
// Y_out = (float)datay/256.0;
// dataz = read_Zdata();
// Z_out = (float)dataz/256.0;
// // roll and pitch
// roll = atan2(Y_out , Z_out) * 180 / PI;
// pitch = atan2((- X_out) , sqrt(pow(Y_out, 2) + pow(Z_out, 2))) * 180 / PI;
// //printf("%d\t %d\t %d\n", datax, datay, dataz);
// //printf("%f\t %f\t %f\n", X_out, Y_out, Z_out);
// // Low-pass filter
// rollF = 0.94 * rollF + 0.06 * roll;
// pitchF = 0.94 * pitchF + 0.06 * pitch;
// printf("RollF: %f\t PitchF: %f\n", rollF, pitchF);
// _delay_ms(200);
// }
// }
|
the_stack_data/187642112.c | #include <stdio.h>
int main() {
printf("Hello, World!");
return 0;
} |
the_stack_data/47435.c | #include <stdio.h>
#include <stdlib.h>
long sum(int* array, int n)
{
long tot = 0;
for(int x = 0; x < n; x++)
tot += array[x];
return tot;
}
long sub_sequence(int* array, int n, long k)
{
long tot = 0;
long prev;
for(int x = 0; x < n; x++)
{
prev = array[x];
if(prev >= k)
{
tot += n - x;
continue;
}
for(int size = 2; size <= n - x; size++)
{
prev += array[x + (size-1)];
if(prev >= k)
{
tot += n - (x + (size - 1));
break;
}
}
}
return tot;
}
int main()
{
int* array;
int n;
long k;
scanf("%d %ld", &n, &k);
array = malloc(sizeof(int) * n);
for(int x = 0; x < n; x++)
scanf("%d", array+x);
printf("%ld\n", sub_sequence(array, n, k));
free(array);
}
|
the_stack_data/64199360.c | #if defined (STM32PLUS_F1_HD) || defined(STM32PLUS_F1_CL_E) || defined(STM32PLUS_F1_MD_VL)
/**
******************************************************************************
* @file misc.c
* @author MCD Application Team
* @version V3.5.0
* @date 11-March-2011
* @brief This file provides all the miscellaneous firmware functions (add-on
* to CMSIS functions).
******************************************************************************
* @attention
*
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
* TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*
* <h2><center>© COPYRIGHT 2011 STMicroelectronics</center></h2>
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "fwlib/f1/stdperiph/inc/misc.h"
/** @addtogroup STM32F10x_StdPeriph_Driver
* @{
*/
/** @defgroup MISC
* @brief MISC driver modules
* @{
*/
/** @defgroup MISC_Private_TypesDefinitions
* @{
*/
/**
* @}
*/
/** @defgroup MISC_Private_Defines
* @{
*/
#define AIRCR_VECTKEY_MASK ((uint32_t)0x05FA0000)
/**
* @}
*/
/** @defgroup MISC_Private_Macros
* @{
*/
/**
* @}
*/
/** @defgroup MISC_Private_Variables
* @{
*/
/**
* @}
*/
/** @defgroup MISC_Private_FunctionPrototypes
* @{
*/
/**
* @}
*/
/** @defgroup MISC_Private_Functions
* @{
*/
/**
* @brief Configures the priority grouping: pre-emption priority and subpriority.
* @param NVIC_PriorityGroup: specifies the priority grouping bits length.
* This parameter can be one of the following values:
* @arg NVIC_PriorityGroup_0: 0 bits for pre-emption priority
* 4 bits for subpriority
* @arg NVIC_PriorityGroup_1: 1 bits for pre-emption priority
* 3 bits for subpriority
* @arg NVIC_PriorityGroup_2: 2 bits for pre-emption priority
* 2 bits for subpriority
* @arg NVIC_PriorityGroup_3: 3 bits for pre-emption priority
* 1 bits for subpriority
* @arg NVIC_PriorityGroup_4: 4 bits for pre-emption priority
* 0 bits for subpriority
* @retval None
*/
void NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup)
{
/* Check the parameters */
assert_param(IS_NVIC_PRIORITY_GROUP(NVIC_PriorityGroup));
/* Set the PRIGROUP[10:8] bits according to NVIC_PriorityGroup value */
SCB->AIRCR = AIRCR_VECTKEY_MASK | NVIC_PriorityGroup;
}
/**
* @brief Initializes the NVIC peripheral according to the specified
* parameters in the NVIC_InitStruct.
* @param NVIC_InitStruct: pointer to a NVIC_InitTypeDef structure that contains
* the configuration information for the specified NVIC peripheral.
* @retval None
*/
void NVIC_Init(NVIC_InitTypeDef* NVIC_InitStruct)
{
uint32_t tmppriority = 0x00, tmppre = 0x00, tmpsub = 0x0F;
/* Check the parameters */
assert_param(IS_FUNCTIONAL_STATE(NVIC_InitStruct->NVIC_IRQChannelCmd));
assert_param(IS_NVIC_PREEMPTION_PRIORITY(NVIC_InitStruct->NVIC_IRQChannelPreemptionPriority));
assert_param(IS_NVIC_SUB_PRIORITY(NVIC_InitStruct->NVIC_IRQChannelSubPriority));
if (NVIC_InitStruct->NVIC_IRQChannelCmd != DISABLE)
{
/* Compute the Corresponding IRQ Priority --------------------------------*/
tmppriority = (0x700 - ((SCB->AIRCR) & (uint32_t)0x700))>> 0x08;
tmppre = (0x4 - tmppriority);
tmpsub = tmpsub >> tmppriority;
tmppriority = (uint32_t)NVIC_InitStruct->NVIC_IRQChannelPreemptionPriority << tmppre;
tmppriority |= NVIC_InitStruct->NVIC_IRQChannelSubPriority & tmpsub;
tmppriority = tmppriority << 0x04;
NVIC->IP[NVIC_InitStruct->NVIC_IRQChannel] = tmppriority;
/* Enable the Selected IRQ Channels --------------------------------------*/
NVIC->ISER[NVIC_InitStruct->NVIC_IRQChannel >> 0x05] =
(uint32_t)0x01 << (NVIC_InitStruct->NVIC_IRQChannel & (uint8_t)0x1F);
}
else
{
/* Disable the Selected IRQ Channels -------------------------------------*/
NVIC->ICER[NVIC_InitStruct->NVIC_IRQChannel >> 0x05] =
(uint32_t)0x01 << (NVIC_InitStruct->NVIC_IRQChannel & (uint8_t)0x1F);
}
}
/**
* @brief Sets the vector table location and Offset.
* @param NVIC_VectTab: specifies if the vector table is in RAM or FLASH memory.
* This parameter can be one of the following values:
* @arg NVIC_VectTab_RAM
* @arg NVIC_VectTab_FLASH
* @param Offset: Vector Table base offset field. This value must be a multiple
* of 0x200.
* @retval None
*/
void NVIC_SetVectorTable(uint32_t NVIC_VectTab, uint32_t Offset)
{
/* Check the parameters */
assert_param(IS_NVIC_VECTTAB(NVIC_VectTab));
assert_param(IS_NVIC_OFFSET(Offset));
SCB->VTOR = NVIC_VectTab | (Offset & (uint32_t)0x1FFFFF80);
}
/**
* @brief Selects the condition for the system to enter low power mode.
* @param LowPowerMode: Specifies the new mode for the system to enter low power mode.
* This parameter can be one of the following values:
* @arg NVIC_LP_SEVONPEND
* @arg NVIC_LP_SLEEPDEEP
* @arg NVIC_LP_SLEEPONEXIT
* @param NewState: new state of LP condition. This parameter can be: ENABLE or DISABLE.
* @retval None
*/
void NVIC_SystemLPConfig(uint8_t LowPowerMode, FunctionalState NewState)
{
/* Check the parameters */
assert_param(IS_NVIC_LP(LowPowerMode));
assert_param(IS_FUNCTIONAL_STATE(NewState));
if (NewState != DISABLE)
{
SCB->SCR |= LowPowerMode;
}
else
{
SCB->SCR &= (uint32_t)(~(uint32_t)LowPowerMode);
}
}
/**
* @brief Configures the SysTick clock source.
* @param SysTick_CLKSource: specifies the SysTick clock source.
* This parameter can be one of the following values:
* @arg SysTick_CLKSource_HCLK_Div8: AHB clock divided by 8 selected as SysTick clock source.
* @arg SysTick_CLKSource_HCLK: AHB clock selected as SysTick clock source.
* @retval None
*/
void SysTick_CLKSourceConfig(uint32_t SysTick_CLKSource)
{
/* Check the parameters */
assert_param(IS_SYSTICK_CLK_SOURCE(SysTick_CLKSource));
if (SysTick_CLKSource == SysTick_CLKSource_HCLK)
{
SysTick->CTRL |= SysTick_CLKSource_HCLK;
}
else
{
SysTick->CTRL &= SysTick_CLKSource_HCLK_Div8;
}
}
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
#endif
|
the_stack_data/107952897.c | #include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <pwd.h>
#include <shadow.h>
#include <errno.h>
#include <crypt.h>
int main(char argc, char *argv[])
{
long lnmax;
char *username, *password, *encrypted, *p;
int len;
struct passwd *pwd;
struct spwd *spwd;
lnmax = sysconf(_SC_LOGIN_NAME_MAX);
if (lnmax == -1) {
lnmax = 255;
}
username = malloc(lnmax);
if (username == NULL) {
fprintf(stderr, "malloc %ld bytes failed! file:%s line:%d\n", lnmax, __FILE__, __LINE__);
exit(EXIT_FAILURE);
}
printf("UserName: ");
fflush(stdout);
if (fgets(username, lnmax, stdin) == NULL) {
fprintf(stderr, "\nUserName input error!\n");
exit(EXIT_FAILURE);
}
len = strlen(username);
if (username[len - 1] == '\n') {
username[len - 1] = 0;
}
pwd = getpwnam(username);
if (pwd == NULL) {
fprintf(stderr, "cound't get password record!\n");
exit(EXIT_FAILURE);
}
spwd = getspnam(username);
if (spwd == NULL && errno == EACCES) {
fprintf(stderr, "The caller does not have permission to access the shadow password file!\n");
exit(EXIT_FAILURE);
}
if (spwd != NULL) {
pwd->pw_passwd = spwd->sp_pwdp;
}
password = getpass("PassWord: ");
/* Encrypt password */
/* link option -lcrypt */
encrypted = crypt(password, pwd->pw_passwd);
/* after encrypt password, we should clear password */
for (p = password; *p != 0;) {
*p++ = 0;
}
if (encrypted == NULL) {
fprintf(stderr, "crypt error!\n");
exit(EXIT_FAILURE);
}
if (strcmp(pwd->pw_passwd, encrypted)) {
printf("Incorrect password!\n");
exit(EXIT_FAILURE);
}
printf("Successfully authenticated: UID=%ld\n", (long)pwd->pw_uid);
exit(EXIT_SUCCESS);
} |
the_stack_data/162643695.c | #include <stdio.h>
#include <math.h>
int main()
{
unsigned long long int num = 286839645281;
int isPrime = 0;
while(!isPrime)
{
isPrime = 1;
if(num % 2 != 0)
{
unsigned long long int root = sqrt(num);
unsigned long long int i;
for(i = 2; i < root; i++)
{
if(num % i == 0)
{
isPrime = 0;
}
}
if(!isPrime)
num++;
}
else
{
isPrime = 0;
num++;
}
}
printf("%llu\n", num);
return 0;
}
|
the_stack_data/125695.c | /* Test Stack */
#include <stdio.h>
#include <setjmp.h>
static jmp_buf buf;
int recurse1(unsigned int x) {
unsigned int space[200];
if (x == 100) {
printf("Level 100 reached\n");
return 100;
}
if (x > 100) {
printf("ERROR: Over Level 100!!\n");
return 100;
}
space[x] = recurse1(x + 1);
if (space[x] != x + 1) {
printf("ERROR: Mismatched return!!\n");
}
return x;
}
int recurse2(unsigned int x) {
unsigned int space[200];
if (x == 100) {
printf("Level 100 reached\n");
longjmp(buf, 5);
return 100;
}
if (x > 100) {
printf("ERROR: Over Level 100!!\n");
longjmp(buf, 5);
return 100;
}
space[50] = x + 1;
recurse2(space[50]);
printf("ERROR: longjmp must have failed!!\n");
return x;
}
int recurse3(unsigned int x) {
unsigned int space[200];
if (x == 100) {
printf("Level 100 reached\n");
exit(0);
return 100;
}
if (x > 100) {
printf("ERROR: Over Level 100!!\n");
exit(5);
return 100;
}
space[50] = x + 1;
recurse3(space[50]);
printf("ERROR: exit() must have failed!!\n");
return x;
}
int main(int argc, char *argv[]) {
int r;
printf("GCCLIB Stack Test\n");
recurse1(0);
printf("GCCLIB Stack Test - Done\n");
printf("GCCLIB Stack Test (with longjmp)\n");
if (!(r = setjmp(buf))) recurse2(0);
if (r != 5) printf("ERROR: set/longjmp did not return expected rc!!\n");
printf("GCCLIB Stack Test (with longjmp) - Done\n");
printf("GCCLIB Stack Test (with exit)\n");
recurse3(0);
printf("ERROR - GCCLIB Stack Test (with exit) - should not get here\n");
return 0;
}
|
the_stack_data/51700221.c | #include <stdlib.h>
void assert(int);
int foo(int x, int y) {
assert(x > 0); /* pass */
assert(y == 1); /* fail */
return x + y;
}
int main() {
int i,j,k;
i = 1;
j = 2;
k = foo(i, j);
assert(k == 3); /* pass */
return 0;
}
|
the_stack_data/90763003.c | // general protection fault in nft_chain_parse_hook
// https://syzkaller.appspot.com/bug?id=48de800ab2740f8a9946ad02e91f04abe311309e
// status:open
// autogenerated by syzkaller (https://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <endian.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <unistd.h>
#define BITMASK(bf_off, bf_len) (((1ull << (bf_len)) - 1) << (bf_off))
#define STORE_BY_BITMASK(type, htobe, addr, val, bf_off, bf_len) \
*(type*)(addr) = \
htobe((htobe(*(type*)(addr)) & ~BITMASK((bf_off), (bf_len))) | \
(((type)(val) << (bf_off)) & BITMASK((bf_off), (bf_len))))
uint64_t r[2] = {0xffffffffffffffff, 0xffffffffffffffff};
int main(void)
{
syscall(__NR_mmap, 0x20000000ul, 0x1000000ul, 3ul, 0x32ul, -1, 0);
intptr_t res = 0;
res = syscall(__NR_socket, 0x10ul, 3ul, 0xcul);
if (res != -1)
r[0] = res;
*(uint64_t*)0x20000280 = 0;
*(uint32_t*)0x20000288 = 8;
*(uint64_t*)0x20000290 = 0x20000240;
*(uint64_t*)0x20000240 = 0x20000100;
memcpy((void*)0x20000100,
"\x14\x00\x00\x00\x10\x00\x00\x00\x1e\x6c\x00\x00\x00\x08\x00\x00\x00"
"\x00\x00\x0a\x20\x00\x00\x00\x00\x0a\x01\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x09\x00\x01\x00\x73\x79\x7a\x30\x00\x00\x00"
"\x00\x38\x00\x00\x00\x12\x0a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x08\x04\x00\x04\x80\x09\x00\x02\x00\x00\x39\x7d\x00\x00"
"\x00\x00\x00\x09\x00\x01\x00\x73\x79\x7a\x30\x00\x00\x00\x00\x08\x00"
"\x03\x40\x00\x00\x00\x01\x14\x00\x00\x00\x11\x00\xdf\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x0a",
128);
*(uint64_t*)0x20000248 = 0x80;
*(uint64_t*)0x20000298 = 1;
*(uint64_t*)0x200002a0 = 0;
*(uint64_t*)0x200002a8 = 0;
*(uint32_t*)0x200002b0 = 0;
syscall(__NR_sendmsg, r[0], 0x20000280ul, 0ul);
res = syscall(__NR_socket, 0x10ul, 3ul, 0xcul);
if (res != -1)
r[1] = res;
*(uint64_t*)0x2000d400 = 0;
*(uint32_t*)0x2000d408 = 0;
*(uint64_t*)0x2000d410 = 0x2000d3c0;
*(uint64_t*)0x2000d3c0 = 0x20009e80;
*(uint32_t*)0x20009e80 = 0x14;
*(uint16_t*)0x20009e84 = 0x10;
*(uint16_t*)0x20009e86 = 1;
*(uint32_t*)0x20009e88 = 0;
*(uint32_t*)0x20009e8c = 0;
*(uint8_t*)0x20009e90 = 0;
*(uint8_t*)0x20009e91 = 0;
*(uint16_t*)0x20009e92 = htobe16(0xa);
*(uint32_t*)0x20009e94 = 0x40;
*(uint8_t*)0x20009e98 = 3;
*(uint8_t*)0x20009e99 = 0xa;
*(uint16_t*)0x20009e9a = 0x401;
*(uint32_t*)0x20009e9c = 0;
*(uint32_t*)0x20009ea0 = 0;
*(uint8_t*)0x20009ea4 = 0;
*(uint8_t*)0x20009ea5 = 0;
*(uint16_t*)0x20009ea6 = htobe16(0);
*(uint16_t*)0x20009ea8 = 9;
*(uint16_t*)0x20009eaa = 3;
memcpy((void*)0x20009eac, "syz2\000", 5);
*(uint16_t*)0x20009eb4 = 9;
*(uint16_t*)0x20009eb6 = 1;
memcpy((void*)0x20009eb8, "syz0\000", 5);
*(uint16_t*)0x20009ec0 = 0x14;
STORE_BY_BITMASK(uint16_t, , 0x20009ec2, 4, 0, 14);
STORE_BY_BITMASK(uint16_t, , 0x20009ec3, 0, 6, 1);
STORE_BY_BITMASK(uint16_t, , 0x20009ec3, 1, 7, 1);
*(uint16_t*)0x20009ec4 = 8;
STORE_BY_BITMASK(uint16_t, , 0x20009ec6, 1, 0, 14);
STORE_BY_BITMASK(uint16_t, , 0x20009ec7, 1, 6, 1);
STORE_BY_BITMASK(uint16_t, , 0x20009ec7, 0, 7, 1);
*(uint32_t*)0x20009ec8 = htobe32(0);
*(uint16_t*)0x20009ecc = 8;
STORE_BY_BITMASK(uint16_t, , 0x20009ece, 2, 0, 14);
STORE_BY_BITMASK(uint16_t, , 0x20009ecf, 1, 6, 1);
STORE_BY_BITMASK(uint16_t, , 0x20009ecf, 0, 7, 1);
*(uint32_t*)0x20009ed0 = htobe32(0);
*(uint32_t*)0x20009ed4 = 0x14;
*(uint16_t*)0x20009ed8 = 0x11;
*(uint16_t*)0x20009eda = 1;
*(uint32_t*)0x20009edc = 0;
*(uint32_t*)0x20009ee0 = 0;
*(uint8_t*)0x20009ee4 = 0;
*(uint8_t*)0x20009ee5 = 0;
*(uint16_t*)0x20009ee6 = htobe16(0xa);
*(uint64_t*)0x2000d3c8 = 0x68;
*(uint64_t*)0x2000d418 = 1;
*(uint64_t*)0x2000d420 = 0;
*(uint64_t*)0x2000d428 = 0;
*(uint32_t*)0x2000d430 = 0x4000000;
syscall(__NR_sendmsg, r[1], 0x2000d400ul, 0x4000000ul);
return 0;
}
|
the_stack_data/45966.c | void puts(void * input)
{
}
void getchar()
{
}
|
the_stack_data/75137269.c | /* Generated by pypy/tool/import_cffi.py */
#include <stdio.h>
#include <assert.h>
#include <sys/time.h>
#ifdef PTEST_USE_THREAD
# include <pthread.h>
static pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
static int remaining;
#endif
extern int add1(int, int);
static double time_delta(struct timeval *stop, struct timeval *start)
{
return (stop->tv_sec - start->tv_sec) +
1e-6 * (stop->tv_usec - start->tv_usec);
}
static double measure(void)
{
long long i, iterations;
int result;
struct timeval start, stop;
double elapsed;
add1(0, 0); /* prepare off-line */
i = 0;
iterations = 1000;
result = gettimeofday(&start, NULL);
assert(result == 0);
while (1) {
for (; i < iterations; i++) {
add1(((int)i) & 0xaaaaaa, ((int)i) & 0x555555);
}
result = gettimeofday(&stop, NULL);
assert(result == 0);
elapsed = time_delta(&stop, &start);
assert(elapsed >= 0.0);
if (elapsed > 2.5)
break;
iterations = iterations * 3 / 2;
}
return elapsed / (double)iterations;
}
static void *start_routine(void *arg)
{
double t = measure();
printf("time per call: %.3g\n", t);
#ifdef PTEST_USE_THREAD
pthread_mutex_lock(&mutex1);
remaining -= 1;
if (!remaining)
pthread_cond_signal(&cond1);
pthread_mutex_unlock(&mutex1);
#endif
return arg;
}
int main(void)
{
#ifndef PTEST_USE_THREAD
start_routine(0);
#else
pthread_t th;
int i, status;
add1(0, 0); /* this is the main thread */
remaining = PTEST_USE_THREAD;
for (i = 0; i < PTEST_USE_THREAD; i++) {
status = pthread_create(&th, NULL, start_routine, NULL);
assert(status == 0);
}
pthread_mutex_lock(&mutex1);
while (remaining)
pthread_cond_wait(&cond1, &mutex1);
pthread_mutex_unlock(&mutex1);
#endif
return 0;
}
|
the_stack_data/34513613.c | /*-------------------------------------------------------------------------
*
* erand48.c
*
* This file supplies pg_erand48(), pg_lrand48(), and pg_srand48(), which
* are just like erand48(), lrand48(), and srand48() except that we use
* our own implementation rather than the one provided by the operating
* system. We used to test for an operating system version rather than
* unconditionally using our own, but (1) some versions of Cygwin have a
* buggy erand48() that always returns zero and (2) as of 2011, glibc's
* erand48() is strangely coded to be almost-but-not-quite thread-safe,
* which doesn't matter for the backend but is important for pgbench.
*
*
* Copyright (c) 1993 Martin Birgmeier
* All rights reserved.
*
* You may redistribute unmodified or modified versions of this source
* code provided that the above copyright notice and this and the
* following conditions are retained.
*
* This software is provided ``as is'', and comes with no warranties
* of any kind. I shall in no event be liable for anything that happens
* to anyone/anything when using this software.
*
* IDENTIFICATION
* src/port/erand48.c
*
*-------------------------------------------------------------------------
*/
#include <math.h>
#define RAND48_SEED_0 (0x330e)
#define RAND48_SEED_1 (0xabcd)
#define RAND48_SEED_2 (0x1234)
#define RAND48_MULT_0 (0xe66d)
#define RAND48_MULT_1 (0xdeec)
#define RAND48_MULT_2 (0x0005)
#define RAND48_ADD (0x000b)
static unsigned short _rand48_mult[3] = { RAND48_MULT_0,
RAND48_MULT_1,
RAND48_MULT_2 };
static unsigned short _rand48_add = RAND48_ADD;
static void
_dorand48(unsigned short xseed[3])
{
unsigned long accu;
unsigned short temp[2];
accu = (unsigned long)_rand48_mult[0] * (unsigned long)xseed[0] +
(unsigned long)_rand48_add;
temp[0] = (unsigned short)accu; /* lower 16 bits */
accu >>= sizeof(unsigned short) * 8;
accu += (unsigned long)_rand48_mult[0] * (unsigned long)xseed[1] +
(unsigned long)_rand48_mult[1] * (unsigned long)xseed[0];
temp[1] = (unsigned short)accu; /* middle 16 bits */
accu >>= sizeof(unsigned short) * 8;
accu += (long)_rand48_mult[0] * xseed[2] +
(long)_rand48_mult[1] * xseed[1] + (long)_rand48_mult[2] * xseed[0];
xseed[0] = temp[0];
xseed[1] = temp[1];
xseed[2] = (unsigned short)accu;
}
double
pg_erand48(unsigned short xseed[3])
{
_dorand48(xseed);
return ldexp((double)xseed[0], -48) + ldexp((double)xseed[1], -32) +
ldexp((double)xseed[2], -16);
}
long int
pg_lrand48(unsigned short *_rand48_seed)
{
_dorand48(_rand48_seed);
return ((long)_rand48_seed[2] << 15) + ((long)_rand48_seed[1] >> 1);
}
void
pg_srand48(long seed, unsigned short *_rand48_seed)
{
_rand48_seed[0] = RAND48_SEED_0;
_rand48_seed[1] = (unsigned short)seed;
_rand48_seed[2] = (unsigned short)(seed >> 16);
}
|
the_stack_data/32268.c | int main()
{
int s, c;
s=c=0;
if (c==1) s+=1; else s+=2;
if (c==1) s+=4; else s+=8;
if (c==1) s+=16; else s+=32;
if (s>42)
ERROR: goto ERROR;
return 0;
}
|
the_stack_data/89200765.c | /* to recompile use gcc start_in_chroot.c -ansi -pedantic -Wall -Werror -o sic */
#define _DEFAULT_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <string.h>
#include <pwd.h>
int main(int argc, char **argv, char **env) {
int r;
const char *m;
char *new_root;
char *dest_str, *dso = "HOME=/home/";
struct passwd *pwd;
if (argc < 4) {
printf("usage: %s [chroot location] [user name] [program]\n", argv[0]);
return 1;
}
/* get new root location */
new_root = argv[1];
/* try chdir to new root */
if ((r = chdir(new_root)) != 0) { m = "failed to locate new root"; goto fail; }
/* try to chroot */
if ((r = chroot(new_root)) != 0) { m = "failed to change root"; goto fail; }
/* try to fetch user id */
if ((pwd = getpwnam(argv[2])) == NULL) { m = "failed to look up username"; goto fail; }
/* try to change to user */
if ((setuid(pwd->pw_uid)) != 0) { m = "failed to change to user"; goto fail; }
/* change home directory */
r = strlen(dso) + strlen(argv[2]);
dest_str = malloc(r+1);
*dest_str = '\0';
strcat(dest_str, dso);
strcat(dest_str, argv[2]);
if ((putenv(dest_str)) != 0) { printf("failed to change home directory\n"); }
/* try running program */
if ((execve(argv[3], argv+3, env)) != 0) { m = "failed to run program in chroot"; goto fail; }
fail:
perror(m);
return 1;
}
|
the_stack_data/57950802.c | // CS 87 - Final Project
// Maria-Elena Solano
//
// This utility simply counts how many CPU cores are in this node
//
#include <stdio.h> // C's standard I/O library
#include <stdlib.h> // C's standard library
#include <unistd.h> // C's POSIX API
// macro/constant definitions
#define perror_out(X) perror(X), fflush(stderr)
#define stderr_out(...) fprintf(stderr, __VA_ARGS__), \
fflush(stderr)
#define print_out(...) printf(__VA_ARGS__), fflush(stdout)
int main(int argc, char** argv){
long int p; // number of cores
// (1) try retrieve the number of cores (or ret -1 if err)
if((p = sysconf(_SC_NPROCESSORS_ONLN)) == -1){
exit(EXIT_FAILURE);
}
// (2) print it out
print_out("%ld\n", p);
// (3) and return
exit(EXIT_SUCCESS);
}
|
the_stack_data/123576720.c | /* Example code for Exercises in C.
Copyright 2014 Allen Downey
License: Creative Commons Attribution-ShareAlike 3.0
*/
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// void free_anything(int *p) {
// free(p);
// }
int read_element(int *array, int index) {
return index;
}
int main()
{
// int never_allocated;
// int *free_twice = malloc(sizeof (int));
// int *use_after_free = malloc(sizeof (int));
// int *never_free = malloc(sizeof (int));
int array1[100];
// int *array2 = malloc(100 * sizeof (int));
// valgrind does not bounds-check static arrays
read_element(array1, -1);
read_element(array1, 100);
// but it does bounds-check dynamic arrays
// read_element(array2, -1);
// read_element(array2, 100);
// and it catches use after free
// free(use_after_free);
// *use_after_free = 17;
// never_free is definitely lost
// *never_free = 17;
// the following line would generate a warning
// free(&never_allocated);
// but this one doesn't
// free_anything(&never_allocated);
// free(free_twice);
// free(free_twice);
return 0;
}
// example from class:
//
// Point *make_point(double x, double y) {
// Point *new = malloc(sizeof(Point));
// new->x = x;
// new->y = y;
// return new;
// }
|
the_stack_data/192331571.c | /*Exercise 4 - Functions
Implement the three functions minimum(), maximum() and multiply() below the main() function.
Do not change the code given in the main() function when you are implementing your solution.*/
#include <stdio.h>
//Function Declaration
int maximum(int num1, int num2);
int minimum(int num1,int num2);
int multiply(int num1,int num2);
int main()
{
int num1, num2;
printf("Enter a value- no 1 : ");
scanf("%d", &num1);
printf("Enter a value- no 2 : ");
scanf("%d", &num2);
printf("%d ", minimum(num1, num2));//Funtion Call
printf("%d ", maximum(num1, num2));
printf("%d ", multiply(num1, num2));
return 0;
}
//Function Implimentation
int maximum(int num1, int num2){
int max=0;
if(num1>num2)
max=num1;
if(num1<num2)
max=num2;
return max;
}
int minimum(int num1,int num2){
int min=0;
if(num1>num2)
min=num2;
if(num1<num2)
min=num1;
return min;
}
int multiply(int num1,int num2){
return num1*num2;
}
|
the_stack_data/200143718.c | #include <sys/types.h>
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <stdlib.h>
#include <netdb.h>
#include <time.h>
#include <sys/select.h>
#include <sys/time.h>
int main(int argc, char** argv){
struct addrinfo* result=NULL;
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC; // IPv4 or IPv6
hints.ai_socktype = SOCK_DGRAM;// UDP
hints.ai_flags = AI_NUMERICHOST;
int rc = getaddrinfo(argv[1], argv[2] , &hints, &result);
// OPEN SOCKET
int udp_socket = socket(result->ai_family,result->ai_socktype,0);
struct sockaddr_storage src_addr;
socklen_t addrlen = sizeof(src_addr);
memcpy((void*) &src_addr, result->ai_addr, result->ai_addrlen);
freeaddrinfo(result);
char buf[2];
char buf_read[80];
while (1){
scanf("%s",buf);
sendto(udp_socket,buf, 1, 0, (struct sockaddr*)&src_addr,addrlen);
int bytes = recvfrom(udp_socket,buf_read, 79, 0, (struct sockaddr *) &src_addr,&addrlen);
buf_read[bytes]='\0';
printf("%s\n",buf_read);
}
close(udp_socket);
}
|
the_stack_data/113301.c | #include <stdio.h>
#include <stdlib.h>
int main() {
int *p;
while (1) {
p = (int *) malloc(4);
}
return 0;
}
|
the_stack_data/134447.c | #include <stdio.h>
#include <stdlib.h>
#define BUFFERSIZE 512
int GetNumber()
{
int val = 0;
do
{
char buff[BUFFERSIZE];
fgets(buff, BUFFERSIZE, stdin);
val = atoi(buff);
}
while (val <= 0 || val > 10); // input value greater then 10 will cause an overflow for dword (int)
printf("You have entered %i\n", val);
return val;
} |
the_stack_data/200142490.c | #include <stddef.h>
#include <stdint.h>
uint32_t ether_fcs(const void *data, size_t bsize)
{
const uint8_t *dp = (uint8_t *) data;
const uint32_t crc_table[] = {
0x4DBDF21C, 0x500AE278, 0x76D3D2D4, 0x6B64C2B0, 0x3B61B38C, 0x26D6A3E8,
0x000F9344, 0x1DB88320, 0xA005713C, 0xBDB26158, 0x9B6B51F4, 0x86DC4190,
0xD6D930AC, 0xCB6E20C8, 0xEDB71064, 0xF0000000};
uint32_t crc = 0;
for (size_t i = 0; i < bsize; i++) {
crc = (crc >> 4) ^ crc_table[(crc ^ (dp[i] >> 0)) & 0x0F];
crc = (crc >> 4) ^ crc_table[(crc ^ (dp[i] >> 4)) & 0x0F];
}
return crc;
}
|
the_stack_data/112089.c | /* The Computer Language Benchmarks Game
* http://benchmarksgame.alioth.debian.org/
*
* contributed by Christian Vosteen
*/
#include <stdlib.h>
#include <stdio.h>
#define TRUE 1
#define FALSE 0
/* The board is a 50 cell hexagonal pattern. For . . . . .
* maximum speed the board will be implemented as . . . . .
* 50 bits, which will fit into a 64 bit long long . . . . .
* int. . . . . .
* . . . . .
* I will represent 0's as empty cells and 1's . . . . .
* as full cells. . . . . .
* . . . . .
* . . . . .
* . . . . .
*/
unsigned long long board = 0xFFFC000000000000ULL;
/* The puzzle pieces must be specified by the path followed
* from one end to the other along 12 hexagonal directions.
*
* Piece 0 Piece 1 Piece 2 Piece 3 Piece 4
*
* O O O O O O O O O O O O O O O
* O O O O O O O
* O O O
*
* Piece 5 Piece 6 Piece 7 Piece 8 Piece 9
*
* O O O O O O O O O O O O O
* O O O O O O O O O
* O O O
*
* I had to make it 12 directions because I wanted all of the
* piece definitions to fit into the same size arrays. It is
* not possible to define piece 4 in terms of the 6 cardinal
* directions in 4 moves.
*/
#define E 0
#define ESE 1
#define SE 2
#define S 3
#define SW 4
#define WSW 5
#define W 6
#define WNW 7
#define NW 8
#define N 9
#define NE 10
#define ENE 11
#define PIVOT 12
char piece_def[10][4] = {
{ E, E, E, SE},
{ SE, E, NE, E},
{ E, E, SE, SW},
{ E, E, SW, SE},
{ SE, E, NE, S},
{ E, E, SW, E},
{ E, SE, SE, NE},
{ E, SE, SE, W},
{ E, SE, E, E},
{ E, E, E, SW}
};
/* To minimize the amount of work done in the recursive solve function below,
* I'm going to allocate enough space for all legal rotations of each piece
* at each position on the board. That's 10 pieces x 50 board positions x
* 12 rotations. However, not all 12 rotations will fit on every cell, so
* I'll have to keep count of the actual number that do.
* The pieces are going to be unsigned long long ints just like the board so
* they can be bitwise-anded with the board to determine if they fit.
* I'm also going to record the next possible open cell for each piece and
* location to reduce the burden on the solve function.
*/
unsigned long long pieces[10][50][12];
int piece_counts[10][50];
char next_cell[10][50][12];
/* Returns the direction rotated 60 degrees clockwise */
char rotate(char dir) {
return (dir + 2) % PIVOT;
}
/* Returns the direction flipped on the horizontal axis */
char flip(char dir) {
return (PIVOT - dir) % PIVOT;
}
/* Returns the new cell index from the specified cell in the
* specified direction. The index is only valid if the
* starting cell and direction have been checked by the
* out_of_bounds function first.
*/
char shift(char cell, char dir) {
switch(dir) {
case E:
return cell + 1;
case ESE:
if((cell / 5) % 2)
return cell + 7;
else
return cell + 6;
case SE:
if((cell / 5) % 2)
return cell + 6;
else
return cell + 5;
case S:
return cell + 10;
case SW:
if((cell / 5) % 2)
return cell + 5;
else
return cell + 4;
case WSW:
if((cell / 5) % 2)
return cell + 4;
else
return cell + 3;
case W:
return cell - 1;
case WNW:
if((cell / 5) % 2)
return cell - 6;
else
return cell - 7;
case NW:
if((cell / 5) % 2)
return cell - 5;
else
return cell - 6;
case N:
return cell - 10;
case NE:
if((cell / 5) % 2)
return cell - 4;
else
return cell - 5;
case ENE:
if((cell / 5) % 2)
return cell - 3;
else
return cell - 4;
default:
return cell;
}
}
/* Returns wether the specified cell and direction will land outside
* of the board. Used to determine if a piece is at a legal board
* location or not.
*/
char out_of_bounds(char cell, char dir) {
char i;
switch(dir) {
case E:
return cell % 5 == 4;
case ESE:
i = cell % 10;
return i == 4 || i == 8 || i == 9 || cell >= 45;
case SE:
return cell % 10 == 9 || cell >= 45;
case S:
return cell >= 40;
case SW:
return cell % 10 == 0 || cell >= 45;
case WSW:
i = cell % 10;
return i == 0 || i == 1 || i == 5 || cell >= 45;
case W:
return cell % 5 == 0;
case WNW:
i = cell % 10;
return i == 0 || i == 1 || i == 5 || cell < 5;
case NW:
return cell % 10 == 0 || cell < 5;
case N:
return cell < 10;
case NE:
return cell % 10 == 9 || cell < 5;
case ENE:
i = cell % 10;
return i == 4 || i == 8 || i == 9 || cell < 5;
default:
return FALSE;
}
}
/* Rotate a piece 60 degrees clockwise */
void rotate_piece(int piece) {
int i;
for(i = 0; i < 4; i++)
piece_def[piece][i] = rotate(piece_def[piece][i]);
}
/* Flip a piece along the horizontal axis */
void flip_piece(int piece) {
int i;
for(i = 0; i < 4; i++)
piece_def[piece][i] = flip(piece_def[piece][i]);
}
/* Convenience function to quickly calculate all of the indices for a piece */
void calc_cell_indices(char *cell, int piece, char index) {
cell[0] = index;
cell[1] = shift(cell[0], piece_def[piece][0]);
cell[2] = shift(cell[1], piece_def[piece][1]);
cell[3] = shift(cell[2], piece_def[piece][2]);
cell[4] = shift(cell[3], piece_def[piece][3]);
}
/* Convenience function to quickly calculate if a piece fits on the board */
int cells_fit_on_board(char *cell, int piece) {
return (!out_of_bounds(cell[0], piece_def[piece][0]) &&
!out_of_bounds(cell[1], piece_def[piece][1]) &&
!out_of_bounds(cell[2], piece_def[piece][2]) &&
!out_of_bounds(cell[3], piece_def[piece][3]));
}
/* Returns the lowest index of the cells of a piece.
* I use the lowest index that a piece occupies as the index for looking up
* the piece in the solve function.
*/
char minimum_of_cells(char *cell) {
char minimum = cell[0];
minimum = cell[1] < minimum ? cell[1] : minimum;
minimum = cell[2] < minimum ? cell[2] : minimum;
minimum = cell[3] < minimum ? cell[3] : minimum;
minimum = cell[4] < minimum ? cell[4] : minimum;
return minimum;
}
/* Calculate the lowest possible open cell if the piece is placed on the board.
* Used to later reduce the amount of time searching for open cells in the
* solve function.
*/
char first_empty_cell(char *cell, char minimum) {
char first_empty = minimum;
while(first_empty == cell[0] || first_empty == cell[1] ||
first_empty == cell[2] || first_empty == cell[3] ||
first_empty == cell[4])
first_empty++;
return first_empty;
}
/* Generate the unsigned long long int that will later be anded with the
* board to determine if it fits.
*/
unsigned long long bitmask_from_cells(char *cell) {
unsigned long long piece_mask = 0ULL;
int i;
for(i = 0; i < 5; i++)
piece_mask |= 1ULL << cell[i];
return piece_mask;
}
/* Record the piece and other important information in arrays that will
* later be used by the solve function.
*/
void record_piece(int piece, int minimum, char first_empty,
unsigned long long piece_mask) {
pieces[piece][minimum][piece_counts[piece][minimum]] = piece_mask;
next_cell[piece][minimum][piece_counts[piece][minimum]] = first_empty;
piece_counts[piece][minimum]++;
}
/* Fill the entire board going cell by cell. If any cells are "trapped"
* they will be left alone.
*/
void fill_contiguous_space(char *board, int index) {
if(board[index] == 1)
return;
board[index] = 1;
if(!out_of_bounds(index, E))
fill_contiguous_space(board, shift(index, E));
if(!out_of_bounds(index, SE))
fill_contiguous_space(board, shift(index, SE));
if(!out_of_bounds(index, SW))
fill_contiguous_space(board, shift(index, SW));
if(!out_of_bounds(index, W))
fill_contiguous_space(board, shift(index, W));
if(!out_of_bounds(index, NW))
fill_contiguous_space(board, shift(index, NW));
if(!out_of_bounds(index, NE))
fill_contiguous_space(board, shift(index, NE));
}
/* To thin the number of pieces, I calculate if any of them trap any empty
* cells at the edges. There are only a handful of exceptions where the
* the board can be solved with the trapped cells. For example: piece 8 can
* trap 5 cells in the corner, but piece 3 can fit in those cells, or piece 0
* can split the board in half where both halves are viable.
*/
int has_island(char *cell, int piece) {
char temp_board[50];
char c;
int i;
for(i = 0; i < 50; i++)
temp_board[i] = 0;
for(i = 0; i < 5; i++)
temp_board[((int)cell[i])] = 1;
i = 49;
while(temp_board[i] == 1)
i--;
fill_contiguous_space(temp_board, i);
c = 0;
for(i = 0; i < 50; i++)
if(temp_board[i] == 0)
c++;
if(c == 0 || (c == 5 && piece == 8) || (c == 40 && piece == 8) ||
(c % 5 == 0 && piece == 0))
return FALSE;
else
return TRUE;
}
/* Calculate all six rotations of the specified piece at the specified index.
* We calculate only half of piece 3's rotations. This is because any solution
* found has an identical solution rotated 180 degrees. Thus we can reduce the
* number of attempted pieces in the solve algorithm by not including the 180-
* degree-rotated pieces of ONE of the pieces. I chose piece 3 because it gave
* me the best time ;)
*/
void calc_six_rotations(char piece, char index) {
char rotation, cell[5];
char minimum, first_empty;
unsigned long long piece_mask;
for(rotation = 0; rotation < 6; rotation++) {
if(piece != 3 || rotation < 3) {
calc_cell_indices(cell, piece, index);
if(cells_fit_on_board(cell, piece) && !has_island(cell, piece)) {
minimum = minimum_of_cells(cell);
first_empty = first_empty_cell(cell, minimum);
piece_mask = bitmask_from_cells(cell);
record_piece(piece, minimum, first_empty, piece_mask);
}
}
rotate_piece(piece);
}
}
/* Calculate every legal rotation for each piece at each board location. */
void calc_pieces(void) {
char piece, index;
for(piece = 0; piece < 10; piece++) {
for(index = 0; index < 50; index++) {
calc_six_rotations(piece, index);
flip_piece(piece);
calc_six_rotations(piece, index);
}
}
}
/* Calculate all 32 possible states for a 5-bit row and all rows that will
* create islands that follow any of the 32 possible rows. These pre-
* calculated 5-bit rows will be used to find islands in a partially solved
* board in the solve function.
*/
#define ROW_MASK 0x1F
#define TRIPLE_MASK 0x7FFF
char all_rows[32] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31};
int bad_even_rows[32][32];
int bad_odd_rows[32][32];
int bad_even_triple[32768];
int bad_odd_triple[32768];
int rows_bad(char row1, char row2, int even) {
/* even is referring to row1 */
int i, in_zeroes, group_okay;
char block, row2_shift;
/* Test for blockages at same index and shifted index */
if(even)
row2_shift = ((row2 << 1) & ROW_MASK) | 0x01;
else
row2_shift = (row2 >> 1) | 0x10;
block = ((row1 ^ row2) & row2) & ((row1 ^ row2_shift) & row2_shift);
/* Test for groups of 0's */
in_zeroes = FALSE;
group_okay = FALSE;
for(i = 0; i < 5; i++) {
if(row1 & (1 << i)) {
if(in_zeroes) {
if(!group_okay)
return TRUE;
in_zeroes = FALSE;
group_okay = FALSE;
}
} else {
if(!in_zeroes)
in_zeroes = TRUE;
if(!(block & (1 << i)))
group_okay = TRUE;
}
}
if(in_zeroes)
return !group_okay;
else
return FALSE;
}
/* Check for cases where three rows checked sequentially cause a false
* positive. One scenario is when 5 cells may be surrounded where piece 5
* or 7 can fit. The other scenario is when piece 2 creates a hook shape.
*/
int triple_is_okay(char row1, char row2, char row3, int even) {
if(even) {
/* There are four cases:
* row1: 00011 00001 11001 10101
* row2: 01011 00101 10001 10001
* row3: 011?? 00110 ????? ?????
*/
return ((row1 == 0x03) && (row2 == 0x0B) && ((row3 & 0x1C) == 0x0C)) ||
((row1 == 0x01) && (row2 == 0x05) && (row3 == 0x06)) ||
((row1 == 0x19) && (row2 == 0x11)) ||
((row1 == 0x15) && (row2 == 0x11));
} else {
/* There are two cases:
* row1: 10011 10101
* row2: 10001 10001
* row3: ????? ?????
*/
return ((row1 == 0x13) && (row2 == 0x11)) ||
((row1 == 0x15) && (row2 == 0x11));
}
}
void calc_rows(void) {
int row1, row2, row3;
int result1, result2;
for(row1 = 0; row1 < 32; row1++) {
for(row2 = 0; row2 < 32; row2++) {
bad_even_rows[row1][row2] = rows_bad(row1, row2, TRUE);
bad_odd_rows[row1][row2] = rows_bad(row1, row2, FALSE);
}
}
for(row1 = 0; row1 < 32; row1++) {
for(row2 = 0; row2 < 32; row2++) {
for(row3 = 0; row3 < 32; row3++) {
result1 = bad_even_rows[row1][row2];
result2 = bad_odd_rows[row2][row3];
if(result1 == FALSE && result2 == TRUE
&& triple_is_okay(row1, row2, row3, TRUE))
bad_even_triple[row1+(row2*32)+(row3*1024)] = FALSE;
else
bad_even_triple[row1+(row2*32)+(row3*1024)] = result1 || result2;
result1 = bad_odd_rows[row1][row2];
result2 = bad_even_rows[row2][row3];
if(result1 == FALSE && result2 == TRUE
&& triple_is_okay(row1, row2, row3, FALSE))
bad_odd_triple[row1+(row2*32)+(row3*1024)] = FALSE;
else
bad_odd_triple[row1+(row2*32)+(row3*1024)] = result1 || result2;
}
}
}
}
/* Calculate islands while solving the board.
*/
int boardHasIslands(char cell) {
/* Too low on board, don't bother checking */
if(cell >= 40)
return FALSE;
int current_triple = (board >> ((cell / 5) * 5)) & TRIPLE_MASK;
if((cell / 5) % 2)
return bad_odd_triple[current_triple];
else
return bad_even_triple[current_triple];
}
/* The recursive solve algorithm. Try to place each permutation in the upper-
* leftmost empty cell. Mark off available pieces as it goes along.
* Because the board is a bit mask, the piece number and bit mask must be saved
* at each successful piece placement. This data is used to create a 50 char
* array if a solution is found.
*/
short avail = 0x03FF;
char sol_nums[10];
unsigned long long sol_masks[10];
signed char solutions[2100][50];
int solution_count = 0;
int max_solutions = 2100;
void record_solution(void) {
int sol_no, index;
unsigned long long sol_mask;
for(sol_no = 0; sol_no < 10; sol_no++) {
sol_mask = sol_masks[sol_no];
for(index = 0; index < 50; index++) {
if(sol_mask & 1ULL) {
solutions[solution_count][index] = sol_nums[sol_no];
/* Board rotated 180 degrees is a solution too! */
solutions[solution_count+1][49-index] = sol_nums[sol_no];
}
sol_mask = sol_mask >> 1;
}
}
solution_count += 2;
}
void solve(int depth, int cell) {
int piece, rotation, max_rots;
unsigned long long *piece_mask;
short piece_no_mask;
if(solution_count >= max_solutions)
return;
while(board & (1ULL << cell))
cell++;
for(piece = 0; piece < 10; piece++) {
piece_no_mask = 1 << piece;
if(!(avail & piece_no_mask))
continue;
avail ^= piece_no_mask;
max_rots = piece_counts[piece][cell];
piece_mask = pieces[piece][cell];
for(rotation = 0; rotation < max_rots; rotation++) {
if(!(board & *(piece_mask + rotation))) {
sol_nums[depth] = piece;
sol_masks[depth] = *(piece_mask + rotation);
if(depth == 9) {
/* Solution found!!!!!11!!ONE! */
record_solution();
avail ^= piece_no_mask;
return;
}
board |= *(piece_mask + rotation);
if(!boardHasIslands(next_cell[piece][cell][rotation]))
solve(depth + 1, next_cell[piece][cell][rotation]);
board ^= *(piece_mask + rotation);
}
}
avail ^= piece_no_mask;
}
}
/* qsort comparator - used to find first and last solutions */
int solution_sort(const void *elem1, const void *elem2) {
signed char *char1 = (signed char *) elem1;
signed char *char2 = (signed char *) elem2;
int i = 0;
while(i < 50 && char1[i] == char2[i])
i++;
return char1[i] - char2[i];
}
/* pretty print a board in the specified hexagonal format */
void pretty(signed char *b) {
int i;
for(i = 0; i < 50; i += 10) {
printf("%c %c %c %c %c \n %c %c %c %c %c \n", b[i]+'0', b[i+1]+'0',
b[i+2]+'0', b[i+3]+'0', b[i+4]+'0', b[i+5]+'0', b[i+6]+'0',
b[i+7]+'0', b[i+8]+'0', b[i+9]+'0');
}
printf("\n");
}
int main(int argc, char **argv) {
if(argc > 1)
max_solutions = atoi(argv[1]);
calc_pieces();
calc_rows();
solve(0, 0);
printf("%d solutions found\n\n", solution_count);
qsort(solutions, solution_count, 50 * sizeof(signed char), solution_sort);
pretty(solutions[0]);
pretty(solutions[solution_count-1]);
return 0;
}
|
the_stack_data/198581775.c | /* $Id: minihttptestserver.c,v 1.10 2012/05/01 16:24:36 nanard Exp $ */
/* Project : miniUPnP
* Author : Thomas Bernard
* Copyright (c) 2011 Thomas Bernard
* This software is subject to the conditions detailed in the
* LICENCE file provided in this distribution.
* */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <signal.h>
#include <time.h>
#define CRAP_LENGTH (2048)
volatile int quit = 0;
volatile int child_to_wait_for = 0;
/**
* signal handler for SIGCHLD (child status has changed)
*/
void handle_signal_chld(int sig)
{
printf("handle_signal_chld(%d)\n", sig);
++child_to_wait_for;
}
/**
* signal handler for SIGINT (CRTL C)
*/
#if 0
void handle_signal_int(int sig)
{
printf("handle_signal_int(%d)\n", sig);
quit = 1;
}
#endif
/**
* build a text/plain content of the specified length
*/
void build_content(char * p, int n)
{
char line_buffer[80];
int k;
int i = 0;
while(n > 0) {
k = snprintf(line_buffer, sizeof(line_buffer),
"%04d_ABCDEFGHIJKL_This_line_is_64_bytes_long_ABCDEFGHIJKL_%04d\r\n",
i, i);
if(k != 64) {
fprintf(stderr, "snprintf() returned %d in build_content()\n", k);
}
++i;
if(n >= 64) {
memcpy(p, line_buffer, 64);
p += 64;
n -= 64;
} else {
memcpy(p, line_buffer, n);
p += n;
n = 0;
}
}
}
/**
* build crappy content
*/
void build_crap(char * p, int n)
{
static const char crap[] = "_CRAP_\r\n";
int i;
while(n > 0) {
i = sizeof(crap) - 1;
if(i > n)
i = n;
memcpy(p, crap, i);
p += i;
n -= i;
}
}
/**
* build chunked response.
* return a malloc'ed buffer
*/
char * build_chunked_response(int content_length, int * response_len) {
char * response_buffer;
char * content_buffer;
int buffer_length;
int i, n;
/* allocate to have some margin */
buffer_length = 256 + content_length + (content_length >> 4);
response_buffer = malloc(buffer_length);
*response_len = snprintf(response_buffer, buffer_length,
"HTTP/1.1 200 OK\r\n"
"Content-Type: text/plain\r\n"
"Transfer-Encoding: chunked\r\n"
"\r\n");
/* build the content */
content_buffer = malloc(content_length);
build_content(content_buffer, content_length);
/* chunk it */
i = 0;
while(i < content_length) {
n = (rand() % 199) + 1;
if(i + n > content_length) {
n = content_length - i;
}
/* TODO : check buffer size ! */
*response_len += snprintf(response_buffer + *response_len,
buffer_length - *response_len,
"%x\r\n", n);
memcpy(response_buffer + *response_len, content_buffer + i, n);
*response_len += n;
i += n;
response_buffer[(*response_len)++] = '\r';
response_buffer[(*response_len)++] = '\n';
}
memcpy(response_buffer + *response_len, "0\r\n", 3);
*response_len += 3;
free(content_buffer);
printf("resp_length=%d buffer_length=%d content_length=%d\n",
*response_len, buffer_length, content_length);
return response_buffer;
}
enum modes { MODE_INVALID, MODE_CHUNKED, MODE_ADDCRAP, MODE_NORMAL };
const struct {
const enum modes mode;
const char * text;
} modes_array[] = {
{MODE_CHUNKED, "chunked"},
{MODE_ADDCRAP, "addcrap"},
{MODE_NORMAL, "normal"},
{MODE_INVALID, NULL}
};
/**
* write the response with random behaviour !
*/
void send_response(int c, const char * buffer, int len)
{
int n;
while(len > 0) {
n = (rand() % 99) + 1;
if(n > len)
n = len;
n = write(c, buffer, n);
if(n < 0) {
perror("write");
return;
} else {
len -= n;
buffer += n;
}
usleep(10000); /* 10ms */
}
}
/**
* handle the HTTP connection
*/
void handle_http_connection(int c)
{
char request_buffer[2048];
int request_len = 0;
int headers_found = 0;
int n, i;
char request_method[16];
char request_uri[256];
char http_version[16];
char * p;
char * response_buffer;
int response_len;
enum modes mode;
int content_length = 16*1024;
/* read the request */
while(request_len < (int)sizeof(request_buffer) && !headers_found) {
n = read(c,
request_buffer + request_len,
sizeof(request_buffer) - request_len);
if(n < 0) {
perror("read");
return;
} else if(n==0) {
/* remote host closed the connection */
break;
} else {
request_len += n;
for(i = 0; i < request_len - 3; i++) {
if(0 == memcmp(request_buffer + i, "\r\n\r\n", 4)) {
/* found the end of headers */
headers_found = 1;
break;
}
}
}
}
if(!headers_found) {
/* error */
return;
}
printf("headers :\n%.*s", request_len, request_buffer);
/* the request have been received, now parse the request line */
p = request_buffer;
for(i = 0; i < (int)sizeof(request_method) - 1; i++) {
if(*p == ' ' || *p == '\r')
break;
request_method[i] = *p;
++p;
}
request_method[i] = '\0';
while(*p == ' ')
p++;
for(i = 0; i < (int)sizeof(request_uri) - 1; i++) {
if(*p == ' ' || *p == '\r')
break;
request_uri[i] = *p;
++p;
}
request_uri[i] = '\0';
while(*p == ' ')
p++;
for(i = 0; i < (int)sizeof(http_version) - 1; i++) {
if(*p == ' ' || *p == '\r')
break;
http_version[i] = *p;
++p;
}
http_version[i] = '\0';
printf("Method = %s, URI = %s, %s\n",
request_method, request_uri, http_version);
/* check if the request method is allowed */
if(0 != strcmp(request_method, "GET")) {
const char response405[] = "HTTP/1.1 405 Method Not Allowed\r\n"
"Allow: GET\r\n\r\n";
const char * pc;
/* 405 Method Not Allowed */
/* The response MUST include an Allow header containing a list
* of valid methods for the requested resource. */
n = sizeof(response405) - 1;
pc = response405;
while(n > 0) {
i = write(c, pc, n);
if(i<0) {
perror("write");
return;
}
n -= i;
pc += i;
}
return;
}
mode = MODE_INVALID;
/* use the request URI to know what to do */
for(i = 0; modes_array[i].mode != MODE_INVALID; i++) {
if(strstr(request_uri, modes_array[i].text)) {
mode = modes_array[i].mode; /* found */
break;
}
}
switch(mode) {
case MODE_CHUNKED:
response_buffer = build_chunked_response(content_length, &response_len);
break;
case MODE_ADDCRAP:
response_len = content_length+256;
response_buffer = malloc(response_len);
n = snprintf(response_buffer, response_len,
"HTTP/1.1 200 OK\r\n"
"Server: minihttptestserver\r\n"
"Content-Type: text/plain\r\n"
"Content-Length: %d\r\n"
"\r\n", content_length);
response_len = content_length+n+CRAP_LENGTH;
response_buffer = realloc(response_buffer, response_len);
build_content(response_buffer + n, content_length);
build_crap(response_buffer + n + content_length, CRAP_LENGTH);
break;
default:
response_len = content_length+256;
response_buffer = malloc(response_len);
n = snprintf(response_buffer, response_len,
"HTTP/1.1 200 OK\r\n"
"Server: minihttptestserver\r\n"
"Content-Type: text/plain\r\n"
"\r\n");
response_len = content_length+n;
response_buffer = realloc(response_buffer, response_len);
build_content(response_buffer + n, response_len - n);
}
if(response_buffer) {
send_response(c, response_buffer, response_len);
free(response_buffer);
} else {
/* Error 500 */
}
}
/**
*/
int main(int argc, char * * argv) {
int ipv6 = 0;
int s, c, i;
unsigned short port = 0;
struct sockaddr_storage server_addr;
socklen_t server_addrlen;
struct sockaddr_storage client_addr;
socklen_t client_addrlen;
pid_t pid;
int child = 0;
int status;
const char * expected_file_name = NULL;
for(i = 1; i < argc; i++) {
if(argv[i][0] == '-') {
switch(argv[i][1]) {
case '6':
ipv6 = 1;
break;
case 'e':
/* write expected file ! */
expected_file_name = argv[++i];
break;
case 'p':
/* port */
if(++i < argc) {
port = (unsigned short)atoi(argv[i]);
}
break;
default:
fprintf(stderr, "unknown command line switch '%s'\n", argv[i]);
}
} else {
fprintf(stderr, "unkown command line argument '%s'\n", argv[i]);
}
}
srand(time(NULL));
signal(SIGCHLD, handle_signal_chld);
#if 0
signal(SIGINT, handle_signal_int);
#endif
s = socket(ipv6 ? AF_INET6 : AF_INET, SOCK_STREAM, 0);
if(s < 0) {
perror("socket");
return 1;
}
memset(&server_addr, 0, sizeof(struct sockaddr_storage));
memset(&client_addr, 0, sizeof(struct sockaddr_storage));
if(ipv6) {
struct sockaddr_in6 * addr = (struct sockaddr_in6 *)&server_addr;
addr->sin6_family = AF_INET6;
addr->sin6_port = htons(port);
addr->sin6_addr = in6addr_loopback;
} else {
struct sockaddr_in * addr = (struct sockaddr_in *)&server_addr;
addr->sin_family = AF_INET;
addr->sin_port = htons(port);
addr->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
}
if(bind(s, (struct sockaddr *)&server_addr,
ipv6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in)) < 0) {
perror("bind");
return 1;
}
if(listen(s, 5) < 0) {
perror("listen");
}
if(port == 0) {
server_addrlen = sizeof(struct sockaddr_storage);
if(getsockname(s, (struct sockaddr *)&server_addr, &server_addrlen) < 0) {
perror("getsockname");
return 1;
}
if(ipv6) {
struct sockaddr_in6 * addr = (struct sockaddr_in6 *)&server_addr;
port = ntohs(addr->sin6_port);
} else {
struct sockaddr_in * addr = (struct sockaddr_in *)&server_addr;
port = ntohs(addr->sin_port);
}
printf("Listening on port %hu\n", port);
fflush(stdout);
}
/* write expected file */
if(expected_file_name) {
FILE * f;
f = fopen(expected_file_name, "wb");
if(f) {
char * buffer;
buffer = malloc(16*1024);
build_content(buffer, 16*1024);
i = fwrite(buffer, 1, 16*1024, f);
if(i != 16*1024) {
fprintf(stderr, "error writing to file %s : %dbytes written (out of %d)\n", expected_file_name, i, 16*1024);
}
free(buffer);
fclose(f);
} else {
fprintf(stderr, "error opening file %s for writing\n", expected_file_name);
}
}
/* fork() loop */
while(!child && !quit) {
while(child_to_wait_for > 0) {
pid = wait(&status);
if(pid < 0) {
perror("wait");
} else {
printf("child(%d) terminated with status %d\n", pid, status);
}
--child_to_wait_for;
}
/* TODO : add a select() call in order to handle the case
* when a signal is caught */
client_addrlen = sizeof(struct sockaddr_storage);
c = accept(s, (struct sockaddr *)&client_addr,
&client_addrlen);
if(c < 0) {
perror("accept");
return 1;
}
printf("accept...\n");
pid = fork();
if(pid < 0) {
perror("fork");
return 1;
} else if(pid == 0) {
/* child */
child = 1;
close(s);
s = -1;
handle_http_connection(c);
}
close(c);
}
if(s >= 0) {
close(s);
s = -1;
}
if(!child) {
while(child_to_wait_for > 0) {
pid = wait(&status);
if(pid < 0) {
perror("wait");
} else {
printf("child(%d) terminated with status %d\n", pid, status);
}
--child_to_wait_for;
}
printf("Bye...\n");
}
return 0;
}
|
the_stack_data/182953686.c | /*****************************************************************************
*
* Dynamic Memory Allocation
*
* Author: Daniel Stenberg
* Date: March 10, 1997
* Version: 2.3
* Email: [email protected]
*
*
* Read 'thoughts' for theories and details of this implementation.
*
* v2.1
* - I once again managed to gain some memory. BLOCK allocations now only use
* a 4 bytes header (instead of previos 8) just as FRAGMENTS.
*
* v2.2
* - Re-adjusted the fragment sizes to better fit into the somewhat larger
* block.
*
* v2.3
* - Made realloc(NULL, size) work as it should. Which is like a malloc(size)
*
*****************************************************************************/
#include <stdio.h>
#include <string.h>
#ifdef DEBUG
#include <stdarg.h>
#endif
#ifdef PSOS
#include <psos.h>
#define SEMAPHORE /* the PSOS routines use semaphore protection */
#else
#include <stdlib.h> /* makes the PSOS complain on the 'size_t' typedef */
#endif
#ifdef BMALLOC
#include "bmalloc.h"
#endif
/* Each TOP takes care of a chain of BLOCKS */
struct MemTop {
struct MemBlock *chain; /* pointer to the BLOCK chain */
long nfree; /* total number of free FRAGMENTS in the chain */
short nmax; /* total number of FRAGMENTS in this kind of BLOCK */
size_t fragsize; /* the size of each FRAGMENT */
#ifdef SEMAPHORE /* if we're protecting the list with SEMAPHORES */
long semaphore_id; /* semaphore used to lock this particular list */
#endif
};
/* Each BLOCK takes care of an amount of FRAGMENTS */
struct MemBlock {
struct MemTop *top; /* our TOP struct */
struct MemBlock *next; /* next BLOCK */
struct MemBlock *prev; /* prev BLOCK */
struct MemFrag *first; /* the first free FRAGMENT in this block */
short nfree; /* number of free FRAGMENTS in this BLOCK */
};
/* This is the data kept in all _free_ FRAGMENTS */
struct MemFrag {
struct MemFrag *next; /* next free FRAGMENT */
struct MemFrag *prev; /* prev free FRAGMENT */
};
/* This is the data kept in all _allocated_ FRAGMENTS and BLOCKS. We add this
to the allocation size first thing in the ALLOC function to make room for
this smoothly. */
struct MemInfo {
void *block;
/* which BLOCK is our father, if BLOCK_BIT is set it means this is a
stand-alone, large allocation and then the rest of the bits should be
treated as the size of the block */
#define BLOCK_BIT 1
};
/* ---------------------------------------------------------------------- */
/* Defines */
/* ---------------------------------------------------------------------- */
#ifdef DEBUG
#define MEMINCR(addr,x) memchange(addr, x)
#define MEMDECR(addr,x) memchange(addr,-(x))
#else
#define MEMINCR(a,x)
#define MEMDECR(a,x)
#endif
/* The low level functions used to get memory from the OS and to return memory
to the OS, we may also define a stub that does the actual allocation and
free, these are the defined function names used in the dmalloc system
anyway: */
#ifdef PSOS
#ifdef DEBUG
#define DMEM_OSALLOCMEM(size,pointer,type) pointer=(type)dbgmalloc(size)
#define DMEM_OSFREEMEM(x) dbgfree(x)
#else
#define DMEM_OSALLOCMEM(size,pointer,type) rn_getseg(0,size,RN_NOWAIT,0,(void **)&pointer)
/* Similar, but this returns the memory */
#define DMEM_OSFREEMEM(x) rn_retseg(0, x)
#endif
/* Argument: <id> */
#define SEMAPHOREOBTAIN(x) sm_p(x, SM_WAIT, 0)
/* Argument: <id> */
#define SEMAPHORERETURN(x) sm_v(x)
/* Argument: <name> <id-variable name> */
#define SEMAPHORECREATE(x,y) sm_create(x, 1, SM_FIFO, (ULONG *)&(y))
#else
#ifdef BMALLOC /* use our own big-memory-allocation system */
#define DMEM_OSALLOCMEM(size,pointer,type) pointer=(type)bmalloc(size)
#define DMEM_OSFREEMEM(x) bfree(x)
#elif DEBUG
#define DMEM_OSALLOCMEM(size,pointer,type) pointer=(type)dbgmalloc(size)
#define DMEM_OSFREEMEM(x) dbgfree(x)
#else
#define DMEM_OSALLOCMEM(size,pointer,type) pointer=(type)malloc(size)
#define DMEM_OSFREEMEM(x) free(x)
#endif
#endif
/* the largest memory allocation that is made a FRAGMENT: (grab the highest
number from the list below) */
#define DMEM_LARGESTSIZE 2032
/* The total size of a BLOCK used for FRAGMENTS
In order to make this use only *1* even alignment from the big-block-
allocation-system (possible the bmalloc() system also written by me)
we need to subtract the [maximum] struct sizes that could get added all
the way through to the grab from the memory. */
#define DMEM_BLOCKSIZE 4064 /* (4096 - sizeof(struct MemBlock) - 12) */
/* Since the blocksize isn't an even 2^X story anymore, we make a table with
the FRAGMENT sizes and amounts that fills up a BLOCK nicely */
/* a little 'bc' script that helps us maximize the usage:
- for 32-bit aligned addresses (SPARC crashes otherwise):
for(i=20; i<2040; i++) { a=4064/i; if(a*i >= 4060) { if(i%4==0) {i;} } }
I try to approximate a double of each size, starting with ~20. We don't do
ODD sizes since several CPU flavours dump core when accessing such
addresses. We try to do 32-bit aligned to make ALL kinds of CPUs to remain
happy with us.
*/
#if BIGBLOCKS==4060 /* previously */
short qinfo[]= { 20, 28, 52, 116, 312, 580, 812, 2028 };
#else
short qinfo[]= { 20, 28, 52, 116, 312, 580, 1016, 2032};
/* 52 and 312 only make use of 4056 bytes, but without them there are too
wide gaps */
#endif
#define MIN(x,y) ((x)<(y)?(x):(y))
/* ---------------------------------------------------------------------- */
/* Globals */
/* ---------------------------------------------------------------------- */
/* keeper of the chain of BLOCKS */
static struct MemTop top[ sizeof(qinfo)/sizeof(qinfo[0]) ];
/* are we experienced? */
static char initialized = 0;
/* ---------------------------------------------------------------------- */
/* Start of the real code */
/* ---------------------------------------------------------------------- */
#ifdef DEBUG
/************
* A few functions that are verbose and tells us about the current status
* of the dmalloc system
***********/
static void dmalloc_status()
{
int i;
int used;
int num;
int totalfree=0;
struct MemBlock *block;
for(i=0; i<sizeof(qinfo)/sizeof(qinfo[0]);i++) {
block = top[i].chain;
used = 0;
num = 0;
while(block) {
used += top[i].nmax-block->nfree;
num++;
block = block->next;
}
printf("Q %d (FRAG %4d), USED %4d FREE %4ld (SIZE %4ld) BLOCKS %d\n",
i, top[i].fragsize, used, top[i].nfree,
top[i].nfree*top[i].fragsize, num);
totalfree += top[i].nfree*top[i].fragsize;
}
printf("Total unused memory stolen by dmalloc: %d\n", totalfree);
}
static void dmalloc_failed(size_t size)
{
printf("*** " __FILE__ " Couldn't allocate %d bytes\n", size);
dmalloc_status();
}
#else
#define dmalloc_failed(x)
#endif
#ifdef DEBUG
#define BORDER 1200
void *dbgmalloc(int size)
{
char *mem;
size += BORDER;
#ifdef PSOS
rn_getseg(0,size,RN_NOWAIT,0,(void **)&mem);
#else
mem = malloc(size);
#endif
if(mem) {
memset(mem, 0xaa, BORDER/2);
memset(mem+BORDER/2, 0xbb, size -BORDER);
memset(mem-BORDER/2+size, 0xcc, BORDER/2);
*(long *)mem = size;
mem += (BORDER/2);
}
printf("OSmalloc(%p)\n", mem);
return (void *)mem;
}
void checkmem(char *ptr)
{
int i;
long size;
ptr -= BORDER/2;
for(i=4; i<(BORDER/2); i++)
if((unsigned char)ptr[i] != 0xaa) {
printf("########### ALERT ALERT\n");
break;
}
size = *(long *)ptr;
for(i=size-1; i>=(size - BORDER/2); i--)
if((unsigned char)ptr[i] != 0xcc) {
printf("********* POST ALERT\n");
break;
}
}
void dbgfree(char *ptr)
{
long size;
checkmem(ptr);
ptr -= BORDER/2;
size = *(long *)ptr;
printf("OSfree(%ld)\n", size);
#ifdef PSOS
rn_retseg(0, ptr);
#else
free(ptr);
#endif
}
#define DBG(x) syslog x
void syslog(char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
vfprintf(stdout, fmt, ap);
va_end(ap);
}
void memchange(void *a, int x)
{
static int memory=0;
static int count=0;
static int max=0;
if(memory > max)
max = memory;
memory += x;
DBG(("%d. PTR %p / %d TOTAL %d MAX %d\n", ++count, a, x, memory, max));
}
#else
#define DBG(x)
#endif
/****************************************************************************
*
* FragBlock()
*
* This function makes FRAGMENTS of the BLOCK sent as argument.
*
***************************************************************************/
static void FragBlock(char *memp, int size)
{
struct MemFrag *frag=(struct MemFrag *)memp;
struct MemFrag *prev=NULL; /* no previous in the first round */
int count=0;
while((count+size) <= DMEM_BLOCKSIZE) {
memp += size;
frag->next = (struct MemFrag *)memp;
frag->prev = prev;
prev = frag;
frag = frag->next;
count += size;
}
prev->next = NULL; /* the last one has no next struct */
}
/***************************************************************************
*
* initialize();
*
* Called in the first dmalloc(). Inits a few memory things.
*
**************************************************************************/
static void initialize(void)
{
int i;
/* Setup the nmax and fragsize fields of the top structs */
for(i=0; i< sizeof(qinfo)/sizeof(qinfo[0]); i++) {
top[i].fragsize = qinfo[i];
top[i].nmax = DMEM_BLOCKSIZE/qinfo[i];
#ifdef PSOS
/* for some reason, these aren't nulled from start: */
top[i].chain = NULL; /* no BLOCKS */
top[i].nfree = 0; /* no FRAGMENTS */
#endif
#ifdef SEMAPHORE
{
char name[7];
sprintf(name, "MEM%d", i);
SEMAPHORECREATE(name, top[i].semaphore_id);
/* doesn't matter if it failed, we continue anyway ;-( */
}
#endif
}
initialized = 1;
}
/****************************************************************************
*
* FragFromBlock()
*
* This should return a fragment from the block and mark it as used
* accordingly.
*
***************************************************************************/
static void *FragFromBlock(struct MemBlock *block)
{
/* make frag point to the first free FRAGMENT */
struct MemFrag *frag = block->first;
struct MemInfo *mem = (struct MemInfo *)frag;
/*
* Remove the FRAGMENT from the list and decrease the free counters.
*/
block->first = frag->next; /* new first free FRAGMENT */
block->nfree--; /* BLOCK counter */
block->top->nfree--; /* TOP counter */
/* heal the FRAGMENT list */
if(frag->prev) {
frag->prev->next = frag->next;
}
if(frag->next) {
frag->next->prev = frag->prev;
}
mem->block = block; /* no block bit set here */
return ((char *)mem)+sizeof(struct MemInfo);
}
/***************************************************************************
*
* dmalloc()
*
* This needs no explanation. A malloc() look-alike.
*
**************************************************************************/
void *dmalloc(size_t size)
{
void *mem;
DBG(("dmalloc(%d)\n", size));
if(!initialized)
initialize();
/* First, we make room for the space needed in every allocation */
size += sizeof(struct MemInfo);
if(size < DMEM_LARGESTSIZE) {
/* get a FRAGMENT */
struct MemBlock *block=NULL; /* SAFE */
struct MemBlock *newblock=NULL; /* SAFE */
struct MemTop *memtop=NULL; /* SAFE */
/* Determine which queue to use */
int queue;
for(queue=0; size > qinfo[queue]; queue++)
;
do {
/* This is the head master of our chain: */
memtop = &top[queue];
DBG(("Top info: %p %d %d %d\n",
memtop->chain,
memtop->nfree,
memtop->nmax,
memtop->fragsize));
#ifdef SEMAPHORE
if(SEMAPHOREOBTAIN(memtop->semaphore_id))
return NULL; /* failed somehow */
#endif
/* get the first BLOCK in the chain */
block = memtop->chain;
/* check if we have a free FRAGMENT */
if(memtop->nfree) {
/* there exists a free FRAGMENT in this chain */
/* I WANT THIS LOOP OUT OF HERE! */
/* search for the free FRAGMENT */
while(!block->nfree)
block = block->next; /* check next BLOCK */
/*
* Now 'block' is the first BLOCK with a free FRAGMENT
*/
mem = FragFromBlock(block);
}
else {
/* we do *not* have a free FRAGMENT but need to get us a new BLOCK */
DMEM_OSALLOCMEM(DMEM_BLOCKSIZE + sizeof(struct MemBlock),
newblock,
struct MemBlock *);
if(!newblock) {
if(++queue < sizeof(qinfo)/sizeof(qinfo[0])) {
/* There are queues for bigger FRAGMENTS that we should check
before we fail this for real */
#ifdef DEBUG
printf("*** " __FILE__ " Trying a bigger Q: %d\n", queue);
#endif
mem = NULL;
}
else {
dmalloc_failed(size- sizeof(struct MemInfo));
return NULL; /* not enough memory */
}
}
else {
/* allocation of big BLOCK was successful */
MEMINCR(newblock, DMEM_BLOCKSIZE + sizeof(struct MemBlock));
memtop->chain = newblock; /* attach this BLOCK to the chain */
newblock->next = block; /* point to the previous first BLOCK */
if(block)
block->prev = newblock; /* point back on this new BLOCK */
newblock->prev = NULL; /* no previous */
newblock->top = memtop; /* our head master */
/* point to the new first FRAGMENT */
newblock->first = (struct MemFrag *)
((char *)newblock+sizeof(struct MemBlock));
/* create FRAGMENTS of the BLOCK: */
FragBlock((char *)newblock->first, memtop->fragsize);
#if defined(DEBUG) && !defined(BMALLOC)
checkmem((char *)newblock);
#endif
/* fix the nfree counters */
newblock->nfree = memtop->nmax;
memtop->nfree += memtop->nmax;
/* get a FRAGMENT from the BLOCK */
mem = FragFromBlock(newblock);
}
}
#ifdef SEMAPHORE
SEMAPHORERETURN(memtop->semaphore_id); /* let it go */
#endif
} while(NULL == mem); /* if we should retry a larger FRAGMENT */
}
else {
/* get a stand-alone BLOCK */
struct MemInfo *meminfo;
if(size&1)
/* don't leave this with an odd size since we'll use that bit for
information */
size++;
DMEM_OSALLOCMEM(size, meminfo, struct MemInfo *);
if(meminfo) {
MEMINCR(meminfo, size);
meminfo->block = (void *)(size|BLOCK_BIT);
mem = (char *)meminfo + sizeof(struct MemInfo);
}
else {
dmalloc_failed(size);
mem = NULL;
}
}
return (void *)mem;
}
/***************************************************************************
*
* dfree()
*
* This needs no explanation. A free() look-alike.
*
**************************************************************************/
void dfree(void *memp)
{
struct MemInfo *meminfo = (struct MemInfo *)
((char *)memp- sizeof(struct MemInfo));
DBG(("dfree(%p)\n", memp));
if(!((size_t)meminfo->block&BLOCK_BIT)) {
/* this is a FRAGMENT we have to deal with */
struct MemBlock *block=meminfo->block;
struct MemTop *memtop = block->top;
#ifdef SEMAPHORE
SEMAPHOREOBTAIN(memtop->semaphore_id);
#endif
/* increase counters */
block->nfree++;
memtop->nfree++;
/* is this BLOCK completely empty now? */
if(block->nfree == memtop->nmax) {
/* yes, return the BLOCK to the system */
if(block->prev)
block->prev->next = block->next;
else
memtop->chain = block->next;
if(block->next)
block->next->prev = block->prev;
memtop->nfree -= memtop->nmax; /* total counter subtraction */
MEMDECR(block, DMEM_BLOCKSIZE + sizeof(struct MemBlock));
DMEM_OSFREEMEM((void *)block); /* return the whole block */
}
else {
/* there are still used FRAGMENTS in the BLOCK, link this one
into the chain of free ones */
struct MemFrag *frag = (struct MemFrag *)meminfo;
frag->prev = NULL;
frag->next = block->first;
if(block->first)
block->first->prev = frag;
block->first = frag;
}
#ifdef SEMAPHORE
SEMAPHORERETURN(memtop->semaphore_id);
#endif
}
else {
/* big stand-alone block, just give it back to the OS: */
MEMDECR(&meminfo->block, (size_t)meminfo->block&~BLOCK_BIT); /* clean BLOCK_BIT */
DMEM_OSFREEMEM((void *)meminfo);
}
}
/***************************************************************************
*
* drealloc()
*
* This needs no explanation. A realloc() look-alike.
*
**************************************************************************/
void *drealloc(char *ptr, size_t size)
{
struct MemInfo *meminfo = (struct MemInfo *)
((char *)ptr- sizeof(struct MemInfo));
/*
* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
* NOTE: the ->size field of the meminfo will now contain the MemInfo
* struct size too!
* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
*/
void *mem=NULL; /* SAFE */
size_t prevsize;
/* NOTE that this is only valid if BLOCK_BIT isn't set: */
struct MemBlock *block;
DBG(("drealloc(%p, %d)\n", ptr, size));
if(NULL == ptr)
return dmalloc( size );
block = meminfo->block;
if(!((size_t)meminfo->block&BLOCK_BIT) &&
(size + sizeof(struct MemInfo) <
(prevsize = block->top->fragsize) )) {
/* This is a FRAGMENT and new size is possible to retain within the same
FRAGMENT */
if((prevsize > qinfo[0]) &&
/* this is not the smallest memory Q */
(size < (block->top-1)->fragsize))
/* this fits in a smaller Q */
;
else
mem = ptr; /* Just return the same pointer as we got in. */
}
if(!mem) {
/* This is a stand-alone BLOCK or a realloc that no longer fits within
the same FRAGMENT */
if((size_t)meminfo->block&BLOCK_BIT) {
prevsize = ((size_t)meminfo->block&~BLOCK_BIT) -
sizeof(struct MemInfo);
}
else
prevsize -= sizeof(struct MemInfo);
/* No tricks involved here, just grab a new bite of memory, copy the data
* from the old place and free the old memory again. */
mem = dmalloc(size);
if(mem) {
memcpy(mem, ptr, MIN(size, prevsize) );
dfree(ptr);
}
}
return mem;
}
/***************************************************************************
*
* dcalloc()
*
* This needs no explanation. A calloc() look-alike.
*
**************************************************************************/
/* Allocate an array of NMEMB elements each SIZE bytes long.
The entire array is initialized to zeros. */
void *
dcalloc (size_t nmemb, size_t size)
{
void *result = dmalloc (nmemb * size);
if (result != NULL)
memset (result, 0, nmemb * size);
return result;
}
|
the_stack_data/22332.c | //@ ltl invariant negative: (<> (X (<> ([] AP(x_34 - x_26 >= -2)))));
float x_0;
float x_1;
float x_2;
float x_3;
float x_4;
float x_5;
float x_6;
float x_7;
float x_8;
float x_9;
float x_10;
float x_11;
float x_12;
float x_13;
float x_14;
float x_15;
float x_16;
float x_17;
float x_18;
float x_19;
float x_20;
float x_21;
float x_22;
float x_23;
float x_24;
float x_25;
float x_26;
float x_27;
float x_28;
float x_29;
float x_30;
float x_31;
float x_32;
float x_33;
float x_34;
float x_35;
float x_36;
float x_37;
float x_38;
float x_39;
int main()
{
float x_0_;
float x_1_;
float x_2_;
float x_3_;
float x_4_;
float x_5_;
float x_6_;
float x_7_;
float x_8_;
float x_9_;
float x_10_;
float x_11_;
float x_12_;
float x_13_;
float x_14_;
float x_15_;
float x_16_;
float x_17_;
float x_18_;
float x_19_;
float x_20_;
float x_21_;
float x_22_;
float x_23_;
float x_24_;
float x_25_;
float x_26_;
float x_27_;
float x_28_;
float x_29_;
float x_30_;
float x_31_;
float x_32_;
float x_33_;
float x_34_;
float x_35_;
float x_36_;
float x_37_;
float x_38_;
float x_39_;
while(1) {
x_0_ = (((((5.0 + x_1) > (13.0 + x_7)? (5.0 + x_1) : (13.0 + x_7)) > ((7.0 + x_10) > ((2.0 + x_11) > (12.0 + x_12)? (2.0 + x_11) : (12.0 + x_12))? (7.0 + x_10) : ((2.0 + x_11) > (12.0 + x_12)? (2.0 + x_11) : (12.0 + x_12)))? ((5.0 + x_1) > (13.0 + x_7)? (5.0 + x_1) : (13.0 + x_7)) : ((7.0 + x_10) > ((2.0 + x_11) > (12.0 + x_12)? (2.0 + x_11) : (12.0 + x_12))? (7.0 + x_10) : ((2.0 + x_11) > (12.0 + x_12)? (2.0 + x_11) : (12.0 + x_12)))) > (((7.0 + x_13) > (16.0 + x_14)? (7.0 + x_13) : (16.0 + x_14)) > ((19.0 + x_15) > ((7.0 + x_19) > (8.0 + x_21)? (7.0 + x_19) : (8.0 + x_21))? (19.0 + x_15) : ((7.0 + x_19) > (8.0 + x_21)? (7.0 + x_19) : (8.0 + x_21)))? ((7.0 + x_13) > (16.0 + x_14)? (7.0 + x_13) : (16.0 + x_14)) : ((19.0 + x_15) > ((7.0 + x_19) > (8.0 + x_21)? (7.0 + x_19) : (8.0 + x_21))? (19.0 + x_15) : ((7.0 + x_19) > (8.0 + x_21)? (7.0 + x_19) : (8.0 + x_21))))? (((5.0 + x_1) > (13.0 + x_7)? (5.0 + x_1) : (13.0 + x_7)) > ((7.0 + x_10) > ((2.0 + x_11) > (12.0 + x_12)? (2.0 + x_11) : (12.0 + x_12))? (7.0 + x_10) : ((2.0 + x_11) > (12.0 + x_12)? (2.0 + x_11) : (12.0 + x_12)))? ((5.0 + x_1) > (13.0 + x_7)? (5.0 + x_1) : (13.0 + x_7)) : ((7.0 + x_10) > ((2.0 + x_11) > (12.0 + x_12)? (2.0 + x_11) : (12.0 + x_12))? (7.0 + x_10) : ((2.0 + x_11) > (12.0 + x_12)? (2.0 + x_11) : (12.0 + x_12)))) : (((7.0 + x_13) > (16.0 + x_14)? (7.0 + x_13) : (16.0 + x_14)) > ((19.0 + x_15) > ((7.0 + x_19) > (8.0 + x_21)? (7.0 + x_19) : (8.0 + x_21))? (19.0 + x_15) : ((7.0 + x_19) > (8.0 + x_21)? (7.0 + x_19) : (8.0 + x_21)))? ((7.0 + x_13) > (16.0 + x_14)? (7.0 + x_13) : (16.0 + x_14)) : ((19.0 + x_15) > ((7.0 + x_19) > (8.0 + x_21)? (7.0 + x_19) : (8.0 + x_21))? (19.0 + x_15) : ((7.0 + x_19) > (8.0 + x_21)? (7.0 + x_19) : (8.0 + x_21))))) > ((((16.0 + x_23) > (8.0 + x_24)? (16.0 + x_23) : (8.0 + x_24)) > ((15.0 + x_26) > ((13.0 + x_27) > (12.0 + x_29)? (13.0 + x_27) : (12.0 + x_29))? (15.0 + x_26) : ((13.0 + x_27) > (12.0 + x_29)? (13.0 + x_27) : (12.0 + x_29)))? ((16.0 + x_23) > (8.0 + x_24)? (16.0 + x_23) : (8.0 + x_24)) : ((15.0 + x_26) > ((13.0 + x_27) > (12.0 + x_29)? (13.0 + x_27) : (12.0 + x_29))? (15.0 + x_26) : ((13.0 + x_27) > (12.0 + x_29)? (13.0 + x_27) : (12.0 + x_29)))) > (((17.0 + x_32) > (10.0 + x_35)? (17.0 + x_32) : (10.0 + x_35)) > ((1.0 + x_36) > ((17.0 + x_37) > (18.0 + x_38)? (17.0 + x_37) : (18.0 + x_38))? (1.0 + x_36) : ((17.0 + x_37) > (18.0 + x_38)? (17.0 + x_37) : (18.0 + x_38)))? ((17.0 + x_32) > (10.0 + x_35)? (17.0 + x_32) : (10.0 + x_35)) : ((1.0 + x_36) > ((17.0 + x_37) > (18.0 + x_38)? (17.0 + x_37) : (18.0 + x_38))? (1.0 + x_36) : ((17.0 + x_37) > (18.0 + x_38)? (17.0 + x_37) : (18.0 + x_38))))? (((16.0 + x_23) > (8.0 + x_24)? (16.0 + x_23) : (8.0 + x_24)) > ((15.0 + x_26) > ((13.0 + x_27) > (12.0 + x_29)? (13.0 + x_27) : (12.0 + x_29))? (15.0 + x_26) : ((13.0 + x_27) > (12.0 + x_29)? (13.0 + x_27) : (12.0 + x_29)))? ((16.0 + x_23) > (8.0 + x_24)? (16.0 + x_23) : (8.0 + x_24)) : ((15.0 + x_26) > ((13.0 + x_27) > (12.0 + x_29)? (13.0 + x_27) : (12.0 + x_29))? (15.0 + x_26) : ((13.0 + x_27) > (12.0 + x_29)? (13.0 + x_27) : (12.0 + x_29)))) : (((17.0 + x_32) > (10.0 + x_35)? (17.0 + x_32) : (10.0 + x_35)) > ((1.0 + x_36) > ((17.0 + x_37) > (18.0 + x_38)? (17.0 + x_37) : (18.0 + x_38))? (1.0 + x_36) : ((17.0 + x_37) > (18.0 + x_38)? (17.0 + x_37) : (18.0 + x_38)))? ((17.0 + x_32) > (10.0 + x_35)? (17.0 + x_32) : (10.0 + x_35)) : ((1.0 + x_36) > ((17.0 + x_37) > (18.0 + x_38)? (17.0 + x_37) : (18.0 + x_38))? (1.0 + x_36) : ((17.0 + x_37) > (18.0 + x_38)? (17.0 + x_37) : (18.0 + x_38)))))? ((((5.0 + x_1) > (13.0 + x_7)? (5.0 + x_1) : (13.0 + x_7)) > ((7.0 + x_10) > ((2.0 + x_11) > (12.0 + x_12)? (2.0 + x_11) : (12.0 + x_12))? (7.0 + x_10) : ((2.0 + x_11) > (12.0 + x_12)? (2.0 + x_11) : (12.0 + x_12)))? ((5.0 + x_1) > (13.0 + x_7)? (5.0 + x_1) : (13.0 + x_7)) : ((7.0 + x_10) > ((2.0 + x_11) > (12.0 + x_12)? (2.0 + x_11) : (12.0 + x_12))? (7.0 + x_10) : ((2.0 + x_11) > (12.0 + x_12)? (2.0 + x_11) : (12.0 + x_12)))) > (((7.0 + x_13) > (16.0 + x_14)? (7.0 + x_13) : (16.0 + x_14)) > ((19.0 + x_15) > ((7.0 + x_19) > (8.0 + x_21)? (7.0 + x_19) : (8.0 + x_21))? (19.0 + x_15) : ((7.0 + x_19) > (8.0 + x_21)? (7.0 + x_19) : (8.0 + x_21)))? ((7.0 + x_13) > (16.0 + x_14)? (7.0 + x_13) : (16.0 + x_14)) : ((19.0 + x_15) > ((7.0 + x_19) > (8.0 + x_21)? (7.0 + x_19) : (8.0 + x_21))? (19.0 + x_15) : ((7.0 + x_19) > (8.0 + x_21)? (7.0 + x_19) : (8.0 + x_21))))? (((5.0 + x_1) > (13.0 + x_7)? (5.0 + x_1) : (13.0 + x_7)) > ((7.0 + x_10) > ((2.0 + x_11) > (12.0 + x_12)? (2.0 + x_11) : (12.0 + x_12))? (7.0 + x_10) : ((2.0 + x_11) > (12.0 + x_12)? (2.0 + x_11) : (12.0 + x_12)))? ((5.0 + x_1) > (13.0 + x_7)? (5.0 + x_1) : (13.0 + x_7)) : ((7.0 + x_10) > ((2.0 + x_11) > (12.0 + x_12)? (2.0 + x_11) : (12.0 + x_12))? (7.0 + x_10) : ((2.0 + x_11) > (12.0 + x_12)? (2.0 + x_11) : (12.0 + x_12)))) : (((7.0 + x_13) > (16.0 + x_14)? (7.0 + x_13) : (16.0 + x_14)) > ((19.0 + x_15) > ((7.0 + x_19) > (8.0 + x_21)? (7.0 + x_19) : (8.0 + x_21))? (19.0 + x_15) : ((7.0 + x_19) > (8.0 + x_21)? (7.0 + x_19) : (8.0 + x_21)))? ((7.0 + x_13) > (16.0 + x_14)? (7.0 + x_13) : (16.0 + x_14)) : ((19.0 + x_15) > ((7.0 + x_19) > (8.0 + x_21)? (7.0 + x_19) : (8.0 + x_21))? (19.0 + x_15) : ((7.0 + x_19) > (8.0 + x_21)? (7.0 + x_19) : (8.0 + x_21))))) : ((((16.0 + x_23) > (8.0 + x_24)? (16.0 + x_23) : (8.0 + x_24)) > ((15.0 + x_26) > ((13.0 + x_27) > (12.0 + x_29)? (13.0 + x_27) : (12.0 + x_29))? (15.0 + x_26) : ((13.0 + x_27) > (12.0 + x_29)? (13.0 + x_27) : (12.0 + x_29)))? ((16.0 + x_23) > (8.0 + x_24)? (16.0 + x_23) : (8.0 + x_24)) : ((15.0 + x_26) > ((13.0 + x_27) > (12.0 + x_29)? (13.0 + x_27) : (12.0 + x_29))? (15.0 + x_26) : ((13.0 + x_27) > (12.0 + x_29)? (13.0 + x_27) : (12.0 + x_29)))) > (((17.0 + x_32) > (10.0 + x_35)? (17.0 + x_32) : (10.0 + x_35)) > ((1.0 + x_36) > ((17.0 + x_37) > (18.0 + x_38)? (17.0 + x_37) : (18.0 + x_38))? (1.0 + x_36) : ((17.0 + x_37) > (18.0 + x_38)? (17.0 + x_37) : (18.0 + x_38)))? ((17.0 + x_32) > (10.0 + x_35)? (17.0 + x_32) : (10.0 + x_35)) : ((1.0 + x_36) > ((17.0 + x_37) > (18.0 + x_38)? (17.0 + x_37) : (18.0 + x_38))? (1.0 + x_36) : ((17.0 + x_37) > (18.0 + x_38)? (17.0 + x_37) : (18.0 + x_38))))? (((16.0 + x_23) > (8.0 + x_24)? (16.0 + x_23) : (8.0 + x_24)) > ((15.0 + x_26) > ((13.0 + x_27) > (12.0 + x_29)? (13.0 + x_27) : (12.0 + x_29))? (15.0 + x_26) : ((13.0 + x_27) > (12.0 + x_29)? (13.0 + x_27) : (12.0 + x_29)))? ((16.0 + x_23) > (8.0 + x_24)? (16.0 + x_23) : (8.0 + x_24)) : ((15.0 + x_26) > ((13.0 + x_27) > (12.0 + x_29)? (13.0 + x_27) : (12.0 + x_29))? (15.0 + x_26) : ((13.0 + x_27) > (12.0 + x_29)? (13.0 + x_27) : (12.0 + x_29)))) : (((17.0 + x_32) > (10.0 + x_35)? (17.0 + x_32) : (10.0 + x_35)) > ((1.0 + x_36) > ((17.0 + x_37) > (18.0 + x_38)? (17.0 + x_37) : (18.0 + x_38))? (1.0 + x_36) : ((17.0 + x_37) > (18.0 + x_38)? (17.0 + x_37) : (18.0 + x_38)))? ((17.0 + x_32) > (10.0 + x_35)? (17.0 + x_32) : (10.0 + x_35)) : ((1.0 + x_36) > ((17.0 + x_37) > (18.0 + x_38)? (17.0 + x_37) : (18.0 + x_38))? (1.0 + x_36) : ((17.0 + x_37) > (18.0 + x_38)? (17.0 + x_37) : (18.0 + x_38))))));
x_1_ = (((((10.0 + x_0) > (17.0 + x_2)? (10.0 + x_0) : (17.0 + x_2)) > ((18.0 + x_3) > ((19.0 + x_4) > (19.0 + x_7)? (19.0 + x_4) : (19.0 + x_7))? (18.0 + x_3) : ((19.0 + x_4) > (19.0 + x_7)? (19.0 + x_4) : (19.0 + x_7)))? ((10.0 + x_0) > (17.0 + x_2)? (10.0 + x_0) : (17.0 + x_2)) : ((18.0 + x_3) > ((19.0 + x_4) > (19.0 + x_7)? (19.0 + x_4) : (19.0 + x_7))? (18.0 + x_3) : ((19.0 + x_4) > (19.0 + x_7)? (19.0 + x_4) : (19.0 + x_7)))) > (((6.0 + x_12) > (2.0 + x_13)? (6.0 + x_12) : (2.0 + x_13)) > ((11.0 + x_17) > ((7.0 + x_18) > (12.0 + x_22)? (7.0 + x_18) : (12.0 + x_22))? (11.0 + x_17) : ((7.0 + x_18) > (12.0 + x_22)? (7.0 + x_18) : (12.0 + x_22)))? ((6.0 + x_12) > (2.0 + x_13)? (6.0 + x_12) : (2.0 + x_13)) : ((11.0 + x_17) > ((7.0 + x_18) > (12.0 + x_22)? (7.0 + x_18) : (12.0 + x_22))? (11.0 + x_17) : ((7.0 + x_18) > (12.0 + x_22)? (7.0 + x_18) : (12.0 + x_22))))? (((10.0 + x_0) > (17.0 + x_2)? (10.0 + x_0) : (17.0 + x_2)) > ((18.0 + x_3) > ((19.0 + x_4) > (19.0 + x_7)? (19.0 + x_4) : (19.0 + x_7))? (18.0 + x_3) : ((19.0 + x_4) > (19.0 + x_7)? (19.0 + x_4) : (19.0 + x_7)))? ((10.0 + x_0) > (17.0 + x_2)? (10.0 + x_0) : (17.0 + x_2)) : ((18.0 + x_3) > ((19.0 + x_4) > (19.0 + x_7)? (19.0 + x_4) : (19.0 + x_7))? (18.0 + x_3) : ((19.0 + x_4) > (19.0 + x_7)? (19.0 + x_4) : (19.0 + x_7)))) : (((6.0 + x_12) > (2.0 + x_13)? (6.0 + x_12) : (2.0 + x_13)) > ((11.0 + x_17) > ((7.0 + x_18) > (12.0 + x_22)? (7.0 + x_18) : (12.0 + x_22))? (11.0 + x_17) : ((7.0 + x_18) > (12.0 + x_22)? (7.0 + x_18) : (12.0 + x_22)))? ((6.0 + x_12) > (2.0 + x_13)? (6.0 + x_12) : (2.0 + x_13)) : ((11.0 + x_17) > ((7.0 + x_18) > (12.0 + x_22)? (7.0 + x_18) : (12.0 + x_22))? (11.0 + x_17) : ((7.0 + x_18) > (12.0 + x_22)? (7.0 + x_18) : (12.0 + x_22))))) > ((((14.0 + x_24) > (13.0 + x_26)? (14.0 + x_24) : (13.0 + x_26)) > ((16.0 + x_27) > ((13.0 + x_28) > (18.0 + x_30)? (13.0 + x_28) : (18.0 + x_30))? (16.0 + x_27) : ((13.0 + x_28) > (18.0 + x_30)? (13.0 + x_28) : (18.0 + x_30)))? ((14.0 + x_24) > (13.0 + x_26)? (14.0 + x_24) : (13.0 + x_26)) : ((16.0 + x_27) > ((13.0 + x_28) > (18.0 + x_30)? (13.0 + x_28) : (18.0 + x_30))? (16.0 + x_27) : ((13.0 + x_28) > (18.0 + x_30)? (13.0 + x_28) : (18.0 + x_30)))) > (((3.0 + x_31) > (16.0 + x_32)? (3.0 + x_31) : (16.0 + x_32)) > ((10.0 + x_34) > ((1.0 + x_36) > (20.0 + x_39)? (1.0 + x_36) : (20.0 + x_39))? (10.0 + x_34) : ((1.0 + x_36) > (20.0 + x_39)? (1.0 + x_36) : (20.0 + x_39)))? ((3.0 + x_31) > (16.0 + x_32)? (3.0 + x_31) : (16.0 + x_32)) : ((10.0 + x_34) > ((1.0 + x_36) > (20.0 + x_39)? (1.0 + x_36) : (20.0 + x_39))? (10.0 + x_34) : ((1.0 + x_36) > (20.0 + x_39)? (1.0 + x_36) : (20.0 + x_39))))? (((14.0 + x_24) > (13.0 + x_26)? (14.0 + x_24) : (13.0 + x_26)) > ((16.0 + x_27) > ((13.0 + x_28) > (18.0 + x_30)? (13.0 + x_28) : (18.0 + x_30))? (16.0 + x_27) : ((13.0 + x_28) > (18.0 + x_30)? (13.0 + x_28) : (18.0 + x_30)))? ((14.0 + x_24) > (13.0 + x_26)? (14.0 + x_24) : (13.0 + x_26)) : ((16.0 + x_27) > ((13.0 + x_28) > (18.0 + x_30)? (13.0 + x_28) : (18.0 + x_30))? (16.0 + x_27) : ((13.0 + x_28) > (18.0 + x_30)? (13.0 + x_28) : (18.0 + x_30)))) : (((3.0 + x_31) > (16.0 + x_32)? (3.0 + x_31) : (16.0 + x_32)) > ((10.0 + x_34) > ((1.0 + x_36) > (20.0 + x_39)? (1.0 + x_36) : (20.0 + x_39))? (10.0 + x_34) : ((1.0 + x_36) > (20.0 + x_39)? (1.0 + x_36) : (20.0 + x_39)))? ((3.0 + x_31) > (16.0 + x_32)? (3.0 + x_31) : (16.0 + x_32)) : ((10.0 + x_34) > ((1.0 + x_36) > (20.0 + x_39)? (1.0 + x_36) : (20.0 + x_39))? (10.0 + x_34) : ((1.0 + x_36) > (20.0 + x_39)? (1.0 + x_36) : (20.0 + x_39)))))? ((((10.0 + x_0) > (17.0 + x_2)? (10.0 + x_0) : (17.0 + x_2)) > ((18.0 + x_3) > ((19.0 + x_4) > (19.0 + x_7)? (19.0 + x_4) : (19.0 + x_7))? (18.0 + x_3) : ((19.0 + x_4) > (19.0 + x_7)? (19.0 + x_4) : (19.0 + x_7)))? ((10.0 + x_0) > (17.0 + x_2)? (10.0 + x_0) : (17.0 + x_2)) : ((18.0 + x_3) > ((19.0 + x_4) > (19.0 + x_7)? (19.0 + x_4) : (19.0 + x_7))? (18.0 + x_3) : ((19.0 + x_4) > (19.0 + x_7)? (19.0 + x_4) : (19.0 + x_7)))) > (((6.0 + x_12) > (2.0 + x_13)? (6.0 + x_12) : (2.0 + x_13)) > ((11.0 + x_17) > ((7.0 + x_18) > (12.0 + x_22)? (7.0 + x_18) : (12.0 + x_22))? (11.0 + x_17) : ((7.0 + x_18) > (12.0 + x_22)? (7.0 + x_18) : (12.0 + x_22)))? ((6.0 + x_12) > (2.0 + x_13)? (6.0 + x_12) : (2.0 + x_13)) : ((11.0 + x_17) > ((7.0 + x_18) > (12.0 + x_22)? (7.0 + x_18) : (12.0 + x_22))? (11.0 + x_17) : ((7.0 + x_18) > (12.0 + x_22)? (7.0 + x_18) : (12.0 + x_22))))? (((10.0 + x_0) > (17.0 + x_2)? (10.0 + x_0) : (17.0 + x_2)) > ((18.0 + x_3) > ((19.0 + x_4) > (19.0 + x_7)? (19.0 + x_4) : (19.0 + x_7))? (18.0 + x_3) : ((19.0 + x_4) > (19.0 + x_7)? (19.0 + x_4) : (19.0 + x_7)))? ((10.0 + x_0) > (17.0 + x_2)? (10.0 + x_0) : (17.0 + x_2)) : ((18.0 + x_3) > ((19.0 + x_4) > (19.0 + x_7)? (19.0 + x_4) : (19.0 + x_7))? (18.0 + x_3) : ((19.0 + x_4) > (19.0 + x_7)? (19.0 + x_4) : (19.0 + x_7)))) : (((6.0 + x_12) > (2.0 + x_13)? (6.0 + x_12) : (2.0 + x_13)) > ((11.0 + x_17) > ((7.0 + x_18) > (12.0 + x_22)? (7.0 + x_18) : (12.0 + x_22))? (11.0 + x_17) : ((7.0 + x_18) > (12.0 + x_22)? (7.0 + x_18) : (12.0 + x_22)))? ((6.0 + x_12) > (2.0 + x_13)? (6.0 + x_12) : (2.0 + x_13)) : ((11.0 + x_17) > ((7.0 + x_18) > (12.0 + x_22)? (7.0 + x_18) : (12.0 + x_22))? (11.0 + x_17) : ((7.0 + x_18) > (12.0 + x_22)? (7.0 + x_18) : (12.0 + x_22))))) : ((((14.0 + x_24) > (13.0 + x_26)? (14.0 + x_24) : (13.0 + x_26)) > ((16.0 + x_27) > ((13.0 + x_28) > (18.0 + x_30)? (13.0 + x_28) : (18.0 + x_30))? (16.0 + x_27) : ((13.0 + x_28) > (18.0 + x_30)? (13.0 + x_28) : (18.0 + x_30)))? ((14.0 + x_24) > (13.0 + x_26)? (14.0 + x_24) : (13.0 + x_26)) : ((16.0 + x_27) > ((13.0 + x_28) > (18.0 + x_30)? (13.0 + x_28) : (18.0 + x_30))? (16.0 + x_27) : ((13.0 + x_28) > (18.0 + x_30)? (13.0 + x_28) : (18.0 + x_30)))) > (((3.0 + x_31) > (16.0 + x_32)? (3.0 + x_31) : (16.0 + x_32)) > ((10.0 + x_34) > ((1.0 + x_36) > (20.0 + x_39)? (1.0 + x_36) : (20.0 + x_39))? (10.0 + x_34) : ((1.0 + x_36) > (20.0 + x_39)? (1.0 + x_36) : (20.0 + x_39)))? ((3.0 + x_31) > (16.0 + x_32)? (3.0 + x_31) : (16.0 + x_32)) : ((10.0 + x_34) > ((1.0 + x_36) > (20.0 + x_39)? (1.0 + x_36) : (20.0 + x_39))? (10.0 + x_34) : ((1.0 + x_36) > (20.0 + x_39)? (1.0 + x_36) : (20.0 + x_39))))? (((14.0 + x_24) > (13.0 + x_26)? (14.0 + x_24) : (13.0 + x_26)) > ((16.0 + x_27) > ((13.0 + x_28) > (18.0 + x_30)? (13.0 + x_28) : (18.0 + x_30))? (16.0 + x_27) : ((13.0 + x_28) > (18.0 + x_30)? (13.0 + x_28) : (18.0 + x_30)))? ((14.0 + x_24) > (13.0 + x_26)? (14.0 + x_24) : (13.0 + x_26)) : ((16.0 + x_27) > ((13.0 + x_28) > (18.0 + x_30)? (13.0 + x_28) : (18.0 + x_30))? (16.0 + x_27) : ((13.0 + x_28) > (18.0 + x_30)? (13.0 + x_28) : (18.0 + x_30)))) : (((3.0 + x_31) > (16.0 + x_32)? (3.0 + x_31) : (16.0 + x_32)) > ((10.0 + x_34) > ((1.0 + x_36) > (20.0 + x_39)? (1.0 + x_36) : (20.0 + x_39))? (10.0 + x_34) : ((1.0 + x_36) > (20.0 + x_39)? (1.0 + x_36) : (20.0 + x_39)))? ((3.0 + x_31) > (16.0 + x_32)? (3.0 + x_31) : (16.0 + x_32)) : ((10.0 + x_34) > ((1.0 + x_36) > (20.0 + x_39)? (1.0 + x_36) : (20.0 + x_39))? (10.0 + x_34) : ((1.0 + x_36) > (20.0 + x_39)? (1.0 + x_36) : (20.0 + x_39))))));
x_2_ = (((((2.0 + x_0) > (5.0 + x_1)? (2.0 + x_0) : (5.0 + x_1)) > ((20.0 + x_4) > ((2.0 + x_5) > (9.0 + x_9)? (2.0 + x_5) : (9.0 + x_9))? (20.0 + x_4) : ((2.0 + x_5) > (9.0 + x_9)? (2.0 + x_5) : (9.0 + x_9)))? ((2.0 + x_0) > (5.0 + x_1)? (2.0 + x_0) : (5.0 + x_1)) : ((20.0 + x_4) > ((2.0 + x_5) > (9.0 + x_9)? (2.0 + x_5) : (9.0 + x_9))? (20.0 + x_4) : ((2.0 + x_5) > (9.0 + x_9)? (2.0 + x_5) : (9.0 + x_9)))) > (((9.0 + x_14) > (18.0 + x_15)? (9.0 + x_14) : (18.0 + x_15)) > ((11.0 + x_18) > ((1.0 + x_19) > (9.0 + x_20)? (1.0 + x_19) : (9.0 + x_20))? (11.0 + x_18) : ((1.0 + x_19) > (9.0 + x_20)? (1.0 + x_19) : (9.0 + x_20)))? ((9.0 + x_14) > (18.0 + x_15)? (9.0 + x_14) : (18.0 + x_15)) : ((11.0 + x_18) > ((1.0 + x_19) > (9.0 + x_20)? (1.0 + x_19) : (9.0 + x_20))? (11.0 + x_18) : ((1.0 + x_19) > (9.0 + x_20)? (1.0 + x_19) : (9.0 + x_20))))? (((2.0 + x_0) > (5.0 + x_1)? (2.0 + x_0) : (5.0 + x_1)) > ((20.0 + x_4) > ((2.0 + x_5) > (9.0 + x_9)? (2.0 + x_5) : (9.0 + x_9))? (20.0 + x_4) : ((2.0 + x_5) > (9.0 + x_9)? (2.0 + x_5) : (9.0 + x_9)))? ((2.0 + x_0) > (5.0 + x_1)? (2.0 + x_0) : (5.0 + x_1)) : ((20.0 + x_4) > ((2.0 + x_5) > (9.0 + x_9)? (2.0 + x_5) : (9.0 + x_9))? (20.0 + x_4) : ((2.0 + x_5) > (9.0 + x_9)? (2.0 + x_5) : (9.0 + x_9)))) : (((9.0 + x_14) > (18.0 + x_15)? (9.0 + x_14) : (18.0 + x_15)) > ((11.0 + x_18) > ((1.0 + x_19) > (9.0 + x_20)? (1.0 + x_19) : (9.0 + x_20))? (11.0 + x_18) : ((1.0 + x_19) > (9.0 + x_20)? (1.0 + x_19) : (9.0 + x_20)))? ((9.0 + x_14) > (18.0 + x_15)? (9.0 + x_14) : (18.0 + x_15)) : ((11.0 + x_18) > ((1.0 + x_19) > (9.0 + x_20)? (1.0 + x_19) : (9.0 + x_20))? (11.0 + x_18) : ((1.0 + x_19) > (9.0 + x_20)? (1.0 + x_19) : (9.0 + x_20))))) > ((((11.0 + x_21) > (11.0 + x_22)? (11.0 + x_21) : (11.0 + x_22)) > ((16.0 + x_23) > ((10.0 + x_26) > (2.0 + x_28)? (10.0 + x_26) : (2.0 + x_28))? (16.0 + x_23) : ((10.0 + x_26) > (2.0 + x_28)? (10.0 + x_26) : (2.0 + x_28)))? ((11.0 + x_21) > (11.0 + x_22)? (11.0 + x_21) : (11.0 + x_22)) : ((16.0 + x_23) > ((10.0 + x_26) > (2.0 + x_28)? (10.0 + x_26) : (2.0 + x_28))? (16.0 + x_23) : ((10.0 + x_26) > (2.0 + x_28)? (10.0 + x_26) : (2.0 + x_28)))) > (((15.0 + x_29) > (19.0 + x_30)? (15.0 + x_29) : (19.0 + x_30)) > ((17.0 + x_34) > ((5.0 + x_35) > (12.0 + x_38)? (5.0 + x_35) : (12.0 + x_38))? (17.0 + x_34) : ((5.0 + x_35) > (12.0 + x_38)? (5.0 + x_35) : (12.0 + x_38)))? ((15.0 + x_29) > (19.0 + x_30)? (15.0 + x_29) : (19.0 + x_30)) : ((17.0 + x_34) > ((5.0 + x_35) > (12.0 + x_38)? (5.0 + x_35) : (12.0 + x_38))? (17.0 + x_34) : ((5.0 + x_35) > (12.0 + x_38)? (5.0 + x_35) : (12.0 + x_38))))? (((11.0 + x_21) > (11.0 + x_22)? (11.0 + x_21) : (11.0 + x_22)) > ((16.0 + x_23) > ((10.0 + x_26) > (2.0 + x_28)? (10.0 + x_26) : (2.0 + x_28))? (16.0 + x_23) : ((10.0 + x_26) > (2.0 + x_28)? (10.0 + x_26) : (2.0 + x_28)))? ((11.0 + x_21) > (11.0 + x_22)? (11.0 + x_21) : (11.0 + x_22)) : ((16.0 + x_23) > ((10.0 + x_26) > (2.0 + x_28)? (10.0 + x_26) : (2.0 + x_28))? (16.0 + x_23) : ((10.0 + x_26) > (2.0 + x_28)? (10.0 + x_26) : (2.0 + x_28)))) : (((15.0 + x_29) > (19.0 + x_30)? (15.0 + x_29) : (19.0 + x_30)) > ((17.0 + x_34) > ((5.0 + x_35) > (12.0 + x_38)? (5.0 + x_35) : (12.0 + x_38))? (17.0 + x_34) : ((5.0 + x_35) > (12.0 + x_38)? (5.0 + x_35) : (12.0 + x_38)))? ((15.0 + x_29) > (19.0 + x_30)? (15.0 + x_29) : (19.0 + x_30)) : ((17.0 + x_34) > ((5.0 + x_35) > (12.0 + x_38)? (5.0 + x_35) : (12.0 + x_38))? (17.0 + x_34) : ((5.0 + x_35) > (12.0 + x_38)? (5.0 + x_35) : (12.0 + x_38)))))? ((((2.0 + x_0) > (5.0 + x_1)? (2.0 + x_0) : (5.0 + x_1)) > ((20.0 + x_4) > ((2.0 + x_5) > (9.0 + x_9)? (2.0 + x_5) : (9.0 + x_9))? (20.0 + x_4) : ((2.0 + x_5) > (9.0 + x_9)? (2.0 + x_5) : (9.0 + x_9)))? ((2.0 + x_0) > (5.0 + x_1)? (2.0 + x_0) : (5.0 + x_1)) : ((20.0 + x_4) > ((2.0 + x_5) > (9.0 + x_9)? (2.0 + x_5) : (9.0 + x_9))? (20.0 + x_4) : ((2.0 + x_5) > (9.0 + x_9)? (2.0 + x_5) : (9.0 + x_9)))) > (((9.0 + x_14) > (18.0 + x_15)? (9.0 + x_14) : (18.0 + x_15)) > ((11.0 + x_18) > ((1.0 + x_19) > (9.0 + x_20)? (1.0 + x_19) : (9.0 + x_20))? (11.0 + x_18) : ((1.0 + x_19) > (9.0 + x_20)? (1.0 + x_19) : (9.0 + x_20)))? ((9.0 + x_14) > (18.0 + x_15)? (9.0 + x_14) : (18.0 + x_15)) : ((11.0 + x_18) > ((1.0 + x_19) > (9.0 + x_20)? (1.0 + x_19) : (9.0 + x_20))? (11.0 + x_18) : ((1.0 + x_19) > (9.0 + x_20)? (1.0 + x_19) : (9.0 + x_20))))? (((2.0 + x_0) > (5.0 + x_1)? (2.0 + x_0) : (5.0 + x_1)) > ((20.0 + x_4) > ((2.0 + x_5) > (9.0 + x_9)? (2.0 + x_5) : (9.0 + x_9))? (20.0 + x_4) : ((2.0 + x_5) > (9.0 + x_9)? (2.0 + x_5) : (9.0 + x_9)))? ((2.0 + x_0) > (5.0 + x_1)? (2.0 + x_0) : (5.0 + x_1)) : ((20.0 + x_4) > ((2.0 + x_5) > (9.0 + x_9)? (2.0 + x_5) : (9.0 + x_9))? (20.0 + x_4) : ((2.0 + x_5) > (9.0 + x_9)? (2.0 + x_5) : (9.0 + x_9)))) : (((9.0 + x_14) > (18.0 + x_15)? (9.0 + x_14) : (18.0 + x_15)) > ((11.0 + x_18) > ((1.0 + x_19) > (9.0 + x_20)? (1.0 + x_19) : (9.0 + x_20))? (11.0 + x_18) : ((1.0 + x_19) > (9.0 + x_20)? (1.0 + x_19) : (9.0 + x_20)))? ((9.0 + x_14) > (18.0 + x_15)? (9.0 + x_14) : (18.0 + x_15)) : ((11.0 + x_18) > ((1.0 + x_19) > (9.0 + x_20)? (1.0 + x_19) : (9.0 + x_20))? (11.0 + x_18) : ((1.0 + x_19) > (9.0 + x_20)? (1.0 + x_19) : (9.0 + x_20))))) : ((((11.0 + x_21) > (11.0 + x_22)? (11.0 + x_21) : (11.0 + x_22)) > ((16.0 + x_23) > ((10.0 + x_26) > (2.0 + x_28)? (10.0 + x_26) : (2.0 + x_28))? (16.0 + x_23) : ((10.0 + x_26) > (2.0 + x_28)? (10.0 + x_26) : (2.0 + x_28)))? ((11.0 + x_21) > (11.0 + x_22)? (11.0 + x_21) : (11.0 + x_22)) : ((16.0 + x_23) > ((10.0 + x_26) > (2.0 + x_28)? (10.0 + x_26) : (2.0 + x_28))? (16.0 + x_23) : ((10.0 + x_26) > (2.0 + x_28)? (10.0 + x_26) : (2.0 + x_28)))) > (((15.0 + x_29) > (19.0 + x_30)? (15.0 + x_29) : (19.0 + x_30)) > ((17.0 + x_34) > ((5.0 + x_35) > (12.0 + x_38)? (5.0 + x_35) : (12.0 + x_38))? (17.0 + x_34) : ((5.0 + x_35) > (12.0 + x_38)? (5.0 + x_35) : (12.0 + x_38)))? ((15.0 + x_29) > (19.0 + x_30)? (15.0 + x_29) : (19.0 + x_30)) : ((17.0 + x_34) > ((5.0 + x_35) > (12.0 + x_38)? (5.0 + x_35) : (12.0 + x_38))? (17.0 + x_34) : ((5.0 + x_35) > (12.0 + x_38)? (5.0 + x_35) : (12.0 + x_38))))? (((11.0 + x_21) > (11.0 + x_22)? (11.0 + x_21) : (11.0 + x_22)) > ((16.0 + x_23) > ((10.0 + x_26) > (2.0 + x_28)? (10.0 + x_26) : (2.0 + x_28))? (16.0 + x_23) : ((10.0 + x_26) > (2.0 + x_28)? (10.0 + x_26) : (2.0 + x_28)))? ((11.0 + x_21) > (11.0 + x_22)? (11.0 + x_21) : (11.0 + x_22)) : ((16.0 + x_23) > ((10.0 + x_26) > (2.0 + x_28)? (10.0 + x_26) : (2.0 + x_28))? (16.0 + x_23) : ((10.0 + x_26) > (2.0 + x_28)? (10.0 + x_26) : (2.0 + x_28)))) : (((15.0 + x_29) > (19.0 + x_30)? (15.0 + x_29) : (19.0 + x_30)) > ((17.0 + x_34) > ((5.0 + x_35) > (12.0 + x_38)? (5.0 + x_35) : (12.0 + x_38))? (17.0 + x_34) : ((5.0 + x_35) > (12.0 + x_38)? (5.0 + x_35) : (12.0 + x_38)))? ((15.0 + x_29) > (19.0 + x_30)? (15.0 + x_29) : (19.0 + x_30)) : ((17.0 + x_34) > ((5.0 + x_35) > (12.0 + x_38)? (5.0 + x_35) : (12.0 + x_38))? (17.0 + x_34) : ((5.0 + x_35) > (12.0 + x_38)? (5.0 + x_35) : (12.0 + x_38))))));
x_3_ = (((((3.0 + x_0) > (14.0 + x_1)? (3.0 + x_0) : (14.0 + x_1)) > ((6.0 + x_4) > ((16.0 + x_5) > (10.0 + x_6)? (16.0 + x_5) : (10.0 + x_6))? (6.0 + x_4) : ((16.0 + x_5) > (10.0 + x_6)? (16.0 + x_5) : (10.0 + x_6)))? ((3.0 + x_0) > (14.0 + x_1)? (3.0 + x_0) : (14.0 + x_1)) : ((6.0 + x_4) > ((16.0 + x_5) > (10.0 + x_6)? (16.0 + x_5) : (10.0 + x_6))? (6.0 + x_4) : ((16.0 + x_5) > (10.0 + x_6)? (16.0 + x_5) : (10.0 + x_6)))) > (((14.0 + x_7) > (7.0 + x_11)? (14.0 + x_7) : (7.0 + x_11)) > ((7.0 + x_13) > ((4.0 + x_15) > (12.0 + x_16)? (4.0 + x_15) : (12.0 + x_16))? (7.0 + x_13) : ((4.0 + x_15) > (12.0 + x_16)? (4.0 + x_15) : (12.0 + x_16)))? ((14.0 + x_7) > (7.0 + x_11)? (14.0 + x_7) : (7.0 + x_11)) : ((7.0 + x_13) > ((4.0 + x_15) > (12.0 + x_16)? (4.0 + x_15) : (12.0 + x_16))? (7.0 + x_13) : ((4.0 + x_15) > (12.0 + x_16)? (4.0 + x_15) : (12.0 + x_16))))? (((3.0 + x_0) > (14.0 + x_1)? (3.0 + x_0) : (14.0 + x_1)) > ((6.0 + x_4) > ((16.0 + x_5) > (10.0 + x_6)? (16.0 + x_5) : (10.0 + x_6))? (6.0 + x_4) : ((16.0 + x_5) > (10.0 + x_6)? (16.0 + x_5) : (10.0 + x_6)))? ((3.0 + x_0) > (14.0 + x_1)? (3.0 + x_0) : (14.0 + x_1)) : ((6.0 + x_4) > ((16.0 + x_5) > (10.0 + x_6)? (16.0 + x_5) : (10.0 + x_6))? (6.0 + x_4) : ((16.0 + x_5) > (10.0 + x_6)? (16.0 + x_5) : (10.0 + x_6)))) : (((14.0 + x_7) > (7.0 + x_11)? (14.0 + x_7) : (7.0 + x_11)) > ((7.0 + x_13) > ((4.0 + x_15) > (12.0 + x_16)? (4.0 + x_15) : (12.0 + x_16))? (7.0 + x_13) : ((4.0 + x_15) > (12.0 + x_16)? (4.0 + x_15) : (12.0 + x_16)))? ((14.0 + x_7) > (7.0 + x_11)? (14.0 + x_7) : (7.0 + x_11)) : ((7.0 + x_13) > ((4.0 + x_15) > (12.0 + x_16)? (4.0 + x_15) : (12.0 + x_16))? (7.0 + x_13) : ((4.0 + x_15) > (12.0 + x_16)? (4.0 + x_15) : (12.0 + x_16))))) > ((((19.0 + x_19) > (8.0 + x_20)? (19.0 + x_19) : (8.0 + x_20)) > ((6.0 + x_21) > ((13.0 + x_24) > (4.0 + x_26)? (13.0 + x_24) : (4.0 + x_26))? (6.0 + x_21) : ((13.0 + x_24) > (4.0 + x_26)? (13.0 + x_24) : (4.0 + x_26)))? ((19.0 + x_19) > (8.0 + x_20)? (19.0 + x_19) : (8.0 + x_20)) : ((6.0 + x_21) > ((13.0 + x_24) > (4.0 + x_26)? (13.0 + x_24) : (4.0 + x_26))? (6.0 + x_21) : ((13.0 + x_24) > (4.0 + x_26)? (13.0 + x_24) : (4.0 + x_26)))) > (((14.0 + x_30) > (10.0 + x_32)? (14.0 + x_30) : (10.0 + x_32)) > ((8.0 + x_34) > ((6.0 + x_35) > (19.0 + x_37)? (6.0 + x_35) : (19.0 + x_37))? (8.0 + x_34) : ((6.0 + x_35) > (19.0 + x_37)? (6.0 + x_35) : (19.0 + x_37)))? ((14.0 + x_30) > (10.0 + x_32)? (14.0 + x_30) : (10.0 + x_32)) : ((8.0 + x_34) > ((6.0 + x_35) > (19.0 + x_37)? (6.0 + x_35) : (19.0 + x_37))? (8.0 + x_34) : ((6.0 + x_35) > (19.0 + x_37)? (6.0 + x_35) : (19.0 + x_37))))? (((19.0 + x_19) > (8.0 + x_20)? (19.0 + x_19) : (8.0 + x_20)) > ((6.0 + x_21) > ((13.0 + x_24) > (4.0 + x_26)? (13.0 + x_24) : (4.0 + x_26))? (6.0 + x_21) : ((13.0 + x_24) > (4.0 + x_26)? (13.0 + x_24) : (4.0 + x_26)))? ((19.0 + x_19) > (8.0 + x_20)? (19.0 + x_19) : (8.0 + x_20)) : ((6.0 + x_21) > ((13.0 + x_24) > (4.0 + x_26)? (13.0 + x_24) : (4.0 + x_26))? (6.0 + x_21) : ((13.0 + x_24) > (4.0 + x_26)? (13.0 + x_24) : (4.0 + x_26)))) : (((14.0 + x_30) > (10.0 + x_32)? (14.0 + x_30) : (10.0 + x_32)) > ((8.0 + x_34) > ((6.0 + x_35) > (19.0 + x_37)? (6.0 + x_35) : (19.0 + x_37))? (8.0 + x_34) : ((6.0 + x_35) > (19.0 + x_37)? (6.0 + x_35) : (19.0 + x_37)))? ((14.0 + x_30) > (10.0 + x_32)? (14.0 + x_30) : (10.0 + x_32)) : ((8.0 + x_34) > ((6.0 + x_35) > (19.0 + x_37)? (6.0 + x_35) : (19.0 + x_37))? (8.0 + x_34) : ((6.0 + x_35) > (19.0 + x_37)? (6.0 + x_35) : (19.0 + x_37)))))? ((((3.0 + x_0) > (14.0 + x_1)? (3.0 + x_0) : (14.0 + x_1)) > ((6.0 + x_4) > ((16.0 + x_5) > (10.0 + x_6)? (16.0 + x_5) : (10.0 + x_6))? (6.0 + x_4) : ((16.0 + x_5) > (10.0 + x_6)? (16.0 + x_5) : (10.0 + x_6)))? ((3.0 + x_0) > (14.0 + x_1)? (3.0 + x_0) : (14.0 + x_1)) : ((6.0 + x_4) > ((16.0 + x_5) > (10.0 + x_6)? (16.0 + x_5) : (10.0 + x_6))? (6.0 + x_4) : ((16.0 + x_5) > (10.0 + x_6)? (16.0 + x_5) : (10.0 + x_6)))) > (((14.0 + x_7) > (7.0 + x_11)? (14.0 + x_7) : (7.0 + x_11)) > ((7.0 + x_13) > ((4.0 + x_15) > (12.0 + x_16)? (4.0 + x_15) : (12.0 + x_16))? (7.0 + x_13) : ((4.0 + x_15) > (12.0 + x_16)? (4.0 + x_15) : (12.0 + x_16)))? ((14.0 + x_7) > (7.0 + x_11)? (14.0 + x_7) : (7.0 + x_11)) : ((7.0 + x_13) > ((4.0 + x_15) > (12.0 + x_16)? (4.0 + x_15) : (12.0 + x_16))? (7.0 + x_13) : ((4.0 + x_15) > (12.0 + x_16)? (4.0 + x_15) : (12.0 + x_16))))? (((3.0 + x_0) > (14.0 + x_1)? (3.0 + x_0) : (14.0 + x_1)) > ((6.0 + x_4) > ((16.0 + x_5) > (10.0 + x_6)? (16.0 + x_5) : (10.0 + x_6))? (6.0 + x_4) : ((16.0 + x_5) > (10.0 + x_6)? (16.0 + x_5) : (10.0 + x_6)))? ((3.0 + x_0) > (14.0 + x_1)? (3.0 + x_0) : (14.0 + x_1)) : ((6.0 + x_4) > ((16.0 + x_5) > (10.0 + x_6)? (16.0 + x_5) : (10.0 + x_6))? (6.0 + x_4) : ((16.0 + x_5) > (10.0 + x_6)? (16.0 + x_5) : (10.0 + x_6)))) : (((14.0 + x_7) > (7.0 + x_11)? (14.0 + x_7) : (7.0 + x_11)) > ((7.0 + x_13) > ((4.0 + x_15) > (12.0 + x_16)? (4.0 + x_15) : (12.0 + x_16))? (7.0 + x_13) : ((4.0 + x_15) > (12.0 + x_16)? (4.0 + x_15) : (12.0 + x_16)))? ((14.0 + x_7) > (7.0 + x_11)? (14.0 + x_7) : (7.0 + x_11)) : ((7.0 + x_13) > ((4.0 + x_15) > (12.0 + x_16)? (4.0 + x_15) : (12.0 + x_16))? (7.0 + x_13) : ((4.0 + x_15) > (12.0 + x_16)? (4.0 + x_15) : (12.0 + x_16))))) : ((((19.0 + x_19) > (8.0 + x_20)? (19.0 + x_19) : (8.0 + x_20)) > ((6.0 + x_21) > ((13.0 + x_24) > (4.0 + x_26)? (13.0 + x_24) : (4.0 + x_26))? (6.0 + x_21) : ((13.0 + x_24) > (4.0 + x_26)? (13.0 + x_24) : (4.0 + x_26)))? ((19.0 + x_19) > (8.0 + x_20)? (19.0 + x_19) : (8.0 + x_20)) : ((6.0 + x_21) > ((13.0 + x_24) > (4.0 + x_26)? (13.0 + x_24) : (4.0 + x_26))? (6.0 + x_21) : ((13.0 + x_24) > (4.0 + x_26)? (13.0 + x_24) : (4.0 + x_26)))) > (((14.0 + x_30) > (10.0 + x_32)? (14.0 + x_30) : (10.0 + x_32)) > ((8.0 + x_34) > ((6.0 + x_35) > (19.0 + x_37)? (6.0 + x_35) : (19.0 + x_37))? (8.0 + x_34) : ((6.0 + x_35) > (19.0 + x_37)? (6.0 + x_35) : (19.0 + x_37)))? ((14.0 + x_30) > (10.0 + x_32)? (14.0 + x_30) : (10.0 + x_32)) : ((8.0 + x_34) > ((6.0 + x_35) > (19.0 + x_37)? (6.0 + x_35) : (19.0 + x_37))? (8.0 + x_34) : ((6.0 + x_35) > (19.0 + x_37)? (6.0 + x_35) : (19.0 + x_37))))? (((19.0 + x_19) > (8.0 + x_20)? (19.0 + x_19) : (8.0 + x_20)) > ((6.0 + x_21) > ((13.0 + x_24) > (4.0 + x_26)? (13.0 + x_24) : (4.0 + x_26))? (6.0 + x_21) : ((13.0 + x_24) > (4.0 + x_26)? (13.0 + x_24) : (4.0 + x_26)))? ((19.0 + x_19) > (8.0 + x_20)? (19.0 + x_19) : (8.0 + x_20)) : ((6.0 + x_21) > ((13.0 + x_24) > (4.0 + x_26)? (13.0 + x_24) : (4.0 + x_26))? (6.0 + x_21) : ((13.0 + x_24) > (4.0 + x_26)? (13.0 + x_24) : (4.0 + x_26)))) : (((14.0 + x_30) > (10.0 + x_32)? (14.0 + x_30) : (10.0 + x_32)) > ((8.0 + x_34) > ((6.0 + x_35) > (19.0 + x_37)? (6.0 + x_35) : (19.0 + x_37))? (8.0 + x_34) : ((6.0 + x_35) > (19.0 + x_37)? (6.0 + x_35) : (19.0 + x_37)))? ((14.0 + x_30) > (10.0 + x_32)? (14.0 + x_30) : (10.0 + x_32)) : ((8.0 + x_34) > ((6.0 + x_35) > (19.0 + x_37)? (6.0 + x_35) : (19.0 + x_37))? (8.0 + x_34) : ((6.0 + x_35) > (19.0 + x_37)? (6.0 + x_35) : (19.0 + x_37))))));
x_4_ = (((((11.0 + x_1) > (2.0 + x_3)? (11.0 + x_1) : (2.0 + x_3)) > ((18.0 + x_4) > ((13.0 + x_7) > (4.0 + x_8)? (13.0 + x_7) : (4.0 + x_8))? (18.0 + x_4) : ((13.0 + x_7) > (4.0 + x_8)? (13.0 + x_7) : (4.0 + x_8)))? ((11.0 + x_1) > (2.0 + x_3)? (11.0 + x_1) : (2.0 + x_3)) : ((18.0 + x_4) > ((13.0 + x_7) > (4.0 + x_8)? (13.0 + x_7) : (4.0 + x_8))? (18.0 + x_4) : ((13.0 + x_7) > (4.0 + x_8)? (13.0 + x_7) : (4.0 + x_8)))) > (((19.0 + x_9) > (17.0 + x_11)? (19.0 + x_9) : (17.0 + x_11)) > ((12.0 + x_14) > ((15.0 + x_15) > (19.0 + x_16)? (15.0 + x_15) : (19.0 + x_16))? (12.0 + x_14) : ((15.0 + x_15) > (19.0 + x_16)? (15.0 + x_15) : (19.0 + x_16)))? ((19.0 + x_9) > (17.0 + x_11)? (19.0 + x_9) : (17.0 + x_11)) : ((12.0 + x_14) > ((15.0 + x_15) > (19.0 + x_16)? (15.0 + x_15) : (19.0 + x_16))? (12.0 + x_14) : ((15.0 + x_15) > (19.0 + x_16)? (15.0 + x_15) : (19.0 + x_16))))? (((11.0 + x_1) > (2.0 + x_3)? (11.0 + x_1) : (2.0 + x_3)) > ((18.0 + x_4) > ((13.0 + x_7) > (4.0 + x_8)? (13.0 + x_7) : (4.0 + x_8))? (18.0 + x_4) : ((13.0 + x_7) > (4.0 + x_8)? (13.0 + x_7) : (4.0 + x_8)))? ((11.0 + x_1) > (2.0 + x_3)? (11.0 + x_1) : (2.0 + x_3)) : ((18.0 + x_4) > ((13.0 + x_7) > (4.0 + x_8)? (13.0 + x_7) : (4.0 + x_8))? (18.0 + x_4) : ((13.0 + x_7) > (4.0 + x_8)? (13.0 + x_7) : (4.0 + x_8)))) : (((19.0 + x_9) > (17.0 + x_11)? (19.0 + x_9) : (17.0 + x_11)) > ((12.0 + x_14) > ((15.0 + x_15) > (19.0 + x_16)? (15.0 + x_15) : (19.0 + x_16))? (12.0 + x_14) : ((15.0 + x_15) > (19.0 + x_16)? (15.0 + x_15) : (19.0 + x_16)))? ((19.0 + x_9) > (17.0 + x_11)? (19.0 + x_9) : (17.0 + x_11)) : ((12.0 + x_14) > ((15.0 + x_15) > (19.0 + x_16)? (15.0 + x_15) : (19.0 + x_16))? (12.0 + x_14) : ((15.0 + x_15) > (19.0 + x_16)? (15.0 + x_15) : (19.0 + x_16))))) > ((((19.0 + x_21) > (11.0 + x_22)? (19.0 + x_21) : (11.0 + x_22)) > ((18.0 + x_24) > ((10.0 + x_26) > (6.0 + x_28)? (10.0 + x_26) : (6.0 + x_28))? (18.0 + x_24) : ((10.0 + x_26) > (6.0 + x_28)? (10.0 + x_26) : (6.0 + x_28)))? ((19.0 + x_21) > (11.0 + x_22)? (19.0 + x_21) : (11.0 + x_22)) : ((18.0 + x_24) > ((10.0 + x_26) > (6.0 + x_28)? (10.0 + x_26) : (6.0 + x_28))? (18.0 + x_24) : ((10.0 + x_26) > (6.0 + x_28)? (10.0 + x_26) : (6.0 + x_28)))) > (((20.0 + x_29) > (7.0 + x_30)? (20.0 + x_29) : (7.0 + x_30)) > ((4.0 + x_33) > ((4.0 + x_34) > (10.0 + x_35)? (4.0 + x_34) : (10.0 + x_35))? (4.0 + x_33) : ((4.0 + x_34) > (10.0 + x_35)? (4.0 + x_34) : (10.0 + x_35)))? ((20.0 + x_29) > (7.0 + x_30)? (20.0 + x_29) : (7.0 + x_30)) : ((4.0 + x_33) > ((4.0 + x_34) > (10.0 + x_35)? (4.0 + x_34) : (10.0 + x_35))? (4.0 + x_33) : ((4.0 + x_34) > (10.0 + x_35)? (4.0 + x_34) : (10.0 + x_35))))? (((19.0 + x_21) > (11.0 + x_22)? (19.0 + x_21) : (11.0 + x_22)) > ((18.0 + x_24) > ((10.0 + x_26) > (6.0 + x_28)? (10.0 + x_26) : (6.0 + x_28))? (18.0 + x_24) : ((10.0 + x_26) > (6.0 + x_28)? (10.0 + x_26) : (6.0 + x_28)))? ((19.0 + x_21) > (11.0 + x_22)? (19.0 + x_21) : (11.0 + x_22)) : ((18.0 + x_24) > ((10.0 + x_26) > (6.0 + x_28)? (10.0 + x_26) : (6.0 + x_28))? (18.0 + x_24) : ((10.0 + x_26) > (6.0 + x_28)? (10.0 + x_26) : (6.0 + x_28)))) : (((20.0 + x_29) > (7.0 + x_30)? (20.0 + x_29) : (7.0 + x_30)) > ((4.0 + x_33) > ((4.0 + x_34) > (10.0 + x_35)? (4.0 + x_34) : (10.0 + x_35))? (4.0 + x_33) : ((4.0 + x_34) > (10.0 + x_35)? (4.0 + x_34) : (10.0 + x_35)))? ((20.0 + x_29) > (7.0 + x_30)? (20.0 + x_29) : (7.0 + x_30)) : ((4.0 + x_33) > ((4.0 + x_34) > (10.0 + x_35)? (4.0 + x_34) : (10.0 + x_35))? (4.0 + x_33) : ((4.0 + x_34) > (10.0 + x_35)? (4.0 + x_34) : (10.0 + x_35)))))? ((((11.0 + x_1) > (2.0 + x_3)? (11.0 + x_1) : (2.0 + x_3)) > ((18.0 + x_4) > ((13.0 + x_7) > (4.0 + x_8)? (13.0 + x_7) : (4.0 + x_8))? (18.0 + x_4) : ((13.0 + x_7) > (4.0 + x_8)? (13.0 + x_7) : (4.0 + x_8)))? ((11.0 + x_1) > (2.0 + x_3)? (11.0 + x_1) : (2.0 + x_3)) : ((18.0 + x_4) > ((13.0 + x_7) > (4.0 + x_8)? (13.0 + x_7) : (4.0 + x_8))? (18.0 + x_4) : ((13.0 + x_7) > (4.0 + x_8)? (13.0 + x_7) : (4.0 + x_8)))) > (((19.0 + x_9) > (17.0 + x_11)? (19.0 + x_9) : (17.0 + x_11)) > ((12.0 + x_14) > ((15.0 + x_15) > (19.0 + x_16)? (15.0 + x_15) : (19.0 + x_16))? (12.0 + x_14) : ((15.0 + x_15) > (19.0 + x_16)? (15.0 + x_15) : (19.0 + x_16)))? ((19.0 + x_9) > (17.0 + x_11)? (19.0 + x_9) : (17.0 + x_11)) : ((12.0 + x_14) > ((15.0 + x_15) > (19.0 + x_16)? (15.0 + x_15) : (19.0 + x_16))? (12.0 + x_14) : ((15.0 + x_15) > (19.0 + x_16)? (15.0 + x_15) : (19.0 + x_16))))? (((11.0 + x_1) > (2.0 + x_3)? (11.0 + x_1) : (2.0 + x_3)) > ((18.0 + x_4) > ((13.0 + x_7) > (4.0 + x_8)? (13.0 + x_7) : (4.0 + x_8))? (18.0 + x_4) : ((13.0 + x_7) > (4.0 + x_8)? (13.0 + x_7) : (4.0 + x_8)))? ((11.0 + x_1) > (2.0 + x_3)? (11.0 + x_1) : (2.0 + x_3)) : ((18.0 + x_4) > ((13.0 + x_7) > (4.0 + x_8)? (13.0 + x_7) : (4.0 + x_8))? (18.0 + x_4) : ((13.0 + x_7) > (4.0 + x_8)? (13.0 + x_7) : (4.0 + x_8)))) : (((19.0 + x_9) > (17.0 + x_11)? (19.0 + x_9) : (17.0 + x_11)) > ((12.0 + x_14) > ((15.0 + x_15) > (19.0 + x_16)? (15.0 + x_15) : (19.0 + x_16))? (12.0 + x_14) : ((15.0 + x_15) > (19.0 + x_16)? (15.0 + x_15) : (19.0 + x_16)))? ((19.0 + x_9) > (17.0 + x_11)? (19.0 + x_9) : (17.0 + x_11)) : ((12.0 + x_14) > ((15.0 + x_15) > (19.0 + x_16)? (15.0 + x_15) : (19.0 + x_16))? (12.0 + x_14) : ((15.0 + x_15) > (19.0 + x_16)? (15.0 + x_15) : (19.0 + x_16))))) : ((((19.0 + x_21) > (11.0 + x_22)? (19.0 + x_21) : (11.0 + x_22)) > ((18.0 + x_24) > ((10.0 + x_26) > (6.0 + x_28)? (10.0 + x_26) : (6.0 + x_28))? (18.0 + x_24) : ((10.0 + x_26) > (6.0 + x_28)? (10.0 + x_26) : (6.0 + x_28)))? ((19.0 + x_21) > (11.0 + x_22)? (19.0 + x_21) : (11.0 + x_22)) : ((18.0 + x_24) > ((10.0 + x_26) > (6.0 + x_28)? (10.0 + x_26) : (6.0 + x_28))? (18.0 + x_24) : ((10.0 + x_26) > (6.0 + x_28)? (10.0 + x_26) : (6.0 + x_28)))) > (((20.0 + x_29) > (7.0 + x_30)? (20.0 + x_29) : (7.0 + x_30)) > ((4.0 + x_33) > ((4.0 + x_34) > (10.0 + x_35)? (4.0 + x_34) : (10.0 + x_35))? (4.0 + x_33) : ((4.0 + x_34) > (10.0 + x_35)? (4.0 + x_34) : (10.0 + x_35)))? ((20.0 + x_29) > (7.0 + x_30)? (20.0 + x_29) : (7.0 + x_30)) : ((4.0 + x_33) > ((4.0 + x_34) > (10.0 + x_35)? (4.0 + x_34) : (10.0 + x_35))? (4.0 + x_33) : ((4.0 + x_34) > (10.0 + x_35)? (4.0 + x_34) : (10.0 + x_35))))? (((19.0 + x_21) > (11.0 + x_22)? (19.0 + x_21) : (11.0 + x_22)) > ((18.0 + x_24) > ((10.0 + x_26) > (6.0 + x_28)? (10.0 + x_26) : (6.0 + x_28))? (18.0 + x_24) : ((10.0 + x_26) > (6.0 + x_28)? (10.0 + x_26) : (6.0 + x_28)))? ((19.0 + x_21) > (11.0 + x_22)? (19.0 + x_21) : (11.0 + x_22)) : ((18.0 + x_24) > ((10.0 + x_26) > (6.0 + x_28)? (10.0 + x_26) : (6.0 + x_28))? (18.0 + x_24) : ((10.0 + x_26) > (6.0 + x_28)? (10.0 + x_26) : (6.0 + x_28)))) : (((20.0 + x_29) > (7.0 + x_30)? (20.0 + x_29) : (7.0 + x_30)) > ((4.0 + x_33) > ((4.0 + x_34) > (10.0 + x_35)? (4.0 + x_34) : (10.0 + x_35))? (4.0 + x_33) : ((4.0 + x_34) > (10.0 + x_35)? (4.0 + x_34) : (10.0 + x_35)))? ((20.0 + x_29) > (7.0 + x_30)? (20.0 + x_29) : (7.0 + x_30)) : ((4.0 + x_33) > ((4.0 + x_34) > (10.0 + x_35)? (4.0 + x_34) : (10.0 + x_35))? (4.0 + x_33) : ((4.0 + x_34) > (10.0 + x_35)? (4.0 + x_34) : (10.0 + x_35))))));
x_5_ = (((((15.0 + x_0) > (4.0 + x_3)? (15.0 + x_0) : (4.0 + x_3)) > ((14.0 + x_5) > ((12.0 + x_8) > (17.0 + x_9)? (12.0 + x_8) : (17.0 + x_9))? (14.0 + x_5) : ((12.0 + x_8) > (17.0 + x_9)? (12.0 + x_8) : (17.0 + x_9)))? ((15.0 + x_0) > (4.0 + x_3)? (15.0 + x_0) : (4.0 + x_3)) : ((14.0 + x_5) > ((12.0 + x_8) > (17.0 + x_9)? (12.0 + x_8) : (17.0 + x_9))? (14.0 + x_5) : ((12.0 + x_8) > (17.0 + x_9)? (12.0 + x_8) : (17.0 + x_9)))) > (((3.0 + x_10) > (12.0 + x_13)? (3.0 + x_10) : (12.0 + x_13)) > ((9.0 + x_15) > ((11.0 + x_18) > (1.0 + x_21)? (11.0 + x_18) : (1.0 + x_21))? (9.0 + x_15) : ((11.0 + x_18) > (1.0 + x_21)? (11.0 + x_18) : (1.0 + x_21)))? ((3.0 + x_10) > (12.0 + x_13)? (3.0 + x_10) : (12.0 + x_13)) : ((9.0 + x_15) > ((11.0 + x_18) > (1.0 + x_21)? (11.0 + x_18) : (1.0 + x_21))? (9.0 + x_15) : ((11.0 + x_18) > (1.0 + x_21)? (11.0 + x_18) : (1.0 + x_21))))? (((15.0 + x_0) > (4.0 + x_3)? (15.0 + x_0) : (4.0 + x_3)) > ((14.0 + x_5) > ((12.0 + x_8) > (17.0 + x_9)? (12.0 + x_8) : (17.0 + x_9))? (14.0 + x_5) : ((12.0 + x_8) > (17.0 + x_9)? (12.0 + x_8) : (17.0 + x_9)))? ((15.0 + x_0) > (4.0 + x_3)? (15.0 + x_0) : (4.0 + x_3)) : ((14.0 + x_5) > ((12.0 + x_8) > (17.0 + x_9)? (12.0 + x_8) : (17.0 + x_9))? (14.0 + x_5) : ((12.0 + x_8) > (17.0 + x_9)? (12.0 + x_8) : (17.0 + x_9)))) : (((3.0 + x_10) > (12.0 + x_13)? (3.0 + x_10) : (12.0 + x_13)) > ((9.0 + x_15) > ((11.0 + x_18) > (1.0 + x_21)? (11.0 + x_18) : (1.0 + x_21))? (9.0 + x_15) : ((11.0 + x_18) > (1.0 + x_21)? (11.0 + x_18) : (1.0 + x_21)))? ((3.0 + x_10) > (12.0 + x_13)? (3.0 + x_10) : (12.0 + x_13)) : ((9.0 + x_15) > ((11.0 + x_18) > (1.0 + x_21)? (11.0 + x_18) : (1.0 + x_21))? (9.0 + x_15) : ((11.0 + x_18) > (1.0 + x_21)? (11.0 + x_18) : (1.0 + x_21))))) > ((((6.0 + x_22) > (10.0 + x_25)? (6.0 + x_22) : (10.0 + x_25)) > ((15.0 + x_28) > ((8.0 + x_29) > (2.0 + x_30)? (8.0 + x_29) : (2.0 + x_30))? (15.0 + x_28) : ((8.0 + x_29) > (2.0 + x_30)? (8.0 + x_29) : (2.0 + x_30)))? ((6.0 + x_22) > (10.0 + x_25)? (6.0 + x_22) : (10.0 + x_25)) : ((15.0 + x_28) > ((8.0 + x_29) > (2.0 + x_30)? (8.0 + x_29) : (2.0 + x_30))? (15.0 + x_28) : ((8.0 + x_29) > (2.0 + x_30)? (8.0 + x_29) : (2.0 + x_30)))) > (((4.0 + x_32) > (16.0 + x_35)? (4.0 + x_32) : (16.0 + x_35)) > ((15.0 + x_36) > ((12.0 + x_38) > (19.0 + x_39)? (12.0 + x_38) : (19.0 + x_39))? (15.0 + x_36) : ((12.0 + x_38) > (19.0 + x_39)? (12.0 + x_38) : (19.0 + x_39)))? ((4.0 + x_32) > (16.0 + x_35)? (4.0 + x_32) : (16.0 + x_35)) : ((15.0 + x_36) > ((12.0 + x_38) > (19.0 + x_39)? (12.0 + x_38) : (19.0 + x_39))? (15.0 + x_36) : ((12.0 + x_38) > (19.0 + x_39)? (12.0 + x_38) : (19.0 + x_39))))? (((6.0 + x_22) > (10.0 + x_25)? (6.0 + x_22) : (10.0 + x_25)) > ((15.0 + x_28) > ((8.0 + x_29) > (2.0 + x_30)? (8.0 + x_29) : (2.0 + x_30))? (15.0 + x_28) : ((8.0 + x_29) > (2.0 + x_30)? (8.0 + x_29) : (2.0 + x_30)))? ((6.0 + x_22) > (10.0 + x_25)? (6.0 + x_22) : (10.0 + x_25)) : ((15.0 + x_28) > ((8.0 + x_29) > (2.0 + x_30)? (8.0 + x_29) : (2.0 + x_30))? (15.0 + x_28) : ((8.0 + x_29) > (2.0 + x_30)? (8.0 + x_29) : (2.0 + x_30)))) : (((4.0 + x_32) > (16.0 + x_35)? (4.0 + x_32) : (16.0 + x_35)) > ((15.0 + x_36) > ((12.0 + x_38) > (19.0 + x_39)? (12.0 + x_38) : (19.0 + x_39))? (15.0 + x_36) : ((12.0 + x_38) > (19.0 + x_39)? (12.0 + x_38) : (19.0 + x_39)))? ((4.0 + x_32) > (16.0 + x_35)? (4.0 + x_32) : (16.0 + x_35)) : ((15.0 + x_36) > ((12.0 + x_38) > (19.0 + x_39)? (12.0 + x_38) : (19.0 + x_39))? (15.0 + x_36) : ((12.0 + x_38) > (19.0 + x_39)? (12.0 + x_38) : (19.0 + x_39)))))? ((((15.0 + x_0) > (4.0 + x_3)? (15.0 + x_0) : (4.0 + x_3)) > ((14.0 + x_5) > ((12.0 + x_8) > (17.0 + x_9)? (12.0 + x_8) : (17.0 + x_9))? (14.0 + x_5) : ((12.0 + x_8) > (17.0 + x_9)? (12.0 + x_8) : (17.0 + x_9)))? ((15.0 + x_0) > (4.0 + x_3)? (15.0 + x_0) : (4.0 + x_3)) : ((14.0 + x_5) > ((12.0 + x_8) > (17.0 + x_9)? (12.0 + x_8) : (17.0 + x_9))? (14.0 + x_5) : ((12.0 + x_8) > (17.0 + x_9)? (12.0 + x_8) : (17.0 + x_9)))) > (((3.0 + x_10) > (12.0 + x_13)? (3.0 + x_10) : (12.0 + x_13)) > ((9.0 + x_15) > ((11.0 + x_18) > (1.0 + x_21)? (11.0 + x_18) : (1.0 + x_21))? (9.0 + x_15) : ((11.0 + x_18) > (1.0 + x_21)? (11.0 + x_18) : (1.0 + x_21)))? ((3.0 + x_10) > (12.0 + x_13)? (3.0 + x_10) : (12.0 + x_13)) : ((9.0 + x_15) > ((11.0 + x_18) > (1.0 + x_21)? (11.0 + x_18) : (1.0 + x_21))? (9.0 + x_15) : ((11.0 + x_18) > (1.0 + x_21)? (11.0 + x_18) : (1.0 + x_21))))? (((15.0 + x_0) > (4.0 + x_3)? (15.0 + x_0) : (4.0 + x_3)) > ((14.0 + x_5) > ((12.0 + x_8) > (17.0 + x_9)? (12.0 + x_8) : (17.0 + x_9))? (14.0 + x_5) : ((12.0 + x_8) > (17.0 + x_9)? (12.0 + x_8) : (17.0 + x_9)))? ((15.0 + x_0) > (4.0 + x_3)? (15.0 + x_0) : (4.0 + x_3)) : ((14.0 + x_5) > ((12.0 + x_8) > (17.0 + x_9)? (12.0 + x_8) : (17.0 + x_9))? (14.0 + x_5) : ((12.0 + x_8) > (17.0 + x_9)? (12.0 + x_8) : (17.0 + x_9)))) : (((3.0 + x_10) > (12.0 + x_13)? (3.0 + x_10) : (12.0 + x_13)) > ((9.0 + x_15) > ((11.0 + x_18) > (1.0 + x_21)? (11.0 + x_18) : (1.0 + x_21))? (9.0 + x_15) : ((11.0 + x_18) > (1.0 + x_21)? (11.0 + x_18) : (1.0 + x_21)))? ((3.0 + x_10) > (12.0 + x_13)? (3.0 + x_10) : (12.0 + x_13)) : ((9.0 + x_15) > ((11.0 + x_18) > (1.0 + x_21)? (11.0 + x_18) : (1.0 + x_21))? (9.0 + x_15) : ((11.0 + x_18) > (1.0 + x_21)? (11.0 + x_18) : (1.0 + x_21))))) : ((((6.0 + x_22) > (10.0 + x_25)? (6.0 + x_22) : (10.0 + x_25)) > ((15.0 + x_28) > ((8.0 + x_29) > (2.0 + x_30)? (8.0 + x_29) : (2.0 + x_30))? (15.0 + x_28) : ((8.0 + x_29) > (2.0 + x_30)? (8.0 + x_29) : (2.0 + x_30)))? ((6.0 + x_22) > (10.0 + x_25)? (6.0 + x_22) : (10.0 + x_25)) : ((15.0 + x_28) > ((8.0 + x_29) > (2.0 + x_30)? (8.0 + x_29) : (2.0 + x_30))? (15.0 + x_28) : ((8.0 + x_29) > (2.0 + x_30)? (8.0 + x_29) : (2.0 + x_30)))) > (((4.0 + x_32) > (16.0 + x_35)? (4.0 + x_32) : (16.0 + x_35)) > ((15.0 + x_36) > ((12.0 + x_38) > (19.0 + x_39)? (12.0 + x_38) : (19.0 + x_39))? (15.0 + x_36) : ((12.0 + x_38) > (19.0 + x_39)? (12.0 + x_38) : (19.0 + x_39)))? ((4.0 + x_32) > (16.0 + x_35)? (4.0 + x_32) : (16.0 + x_35)) : ((15.0 + x_36) > ((12.0 + x_38) > (19.0 + x_39)? (12.0 + x_38) : (19.0 + x_39))? (15.0 + x_36) : ((12.0 + x_38) > (19.0 + x_39)? (12.0 + x_38) : (19.0 + x_39))))? (((6.0 + x_22) > (10.0 + x_25)? (6.0 + x_22) : (10.0 + x_25)) > ((15.0 + x_28) > ((8.0 + x_29) > (2.0 + x_30)? (8.0 + x_29) : (2.0 + x_30))? (15.0 + x_28) : ((8.0 + x_29) > (2.0 + x_30)? (8.0 + x_29) : (2.0 + x_30)))? ((6.0 + x_22) > (10.0 + x_25)? (6.0 + x_22) : (10.0 + x_25)) : ((15.0 + x_28) > ((8.0 + x_29) > (2.0 + x_30)? (8.0 + x_29) : (2.0 + x_30))? (15.0 + x_28) : ((8.0 + x_29) > (2.0 + x_30)? (8.0 + x_29) : (2.0 + x_30)))) : (((4.0 + x_32) > (16.0 + x_35)? (4.0 + x_32) : (16.0 + x_35)) > ((15.0 + x_36) > ((12.0 + x_38) > (19.0 + x_39)? (12.0 + x_38) : (19.0 + x_39))? (15.0 + x_36) : ((12.0 + x_38) > (19.0 + x_39)? (12.0 + x_38) : (19.0 + x_39)))? ((4.0 + x_32) > (16.0 + x_35)? (4.0 + x_32) : (16.0 + x_35)) : ((15.0 + x_36) > ((12.0 + x_38) > (19.0 + x_39)? (12.0 + x_38) : (19.0 + x_39))? (15.0 + x_36) : ((12.0 + x_38) > (19.0 + x_39)? (12.0 + x_38) : (19.0 + x_39))))));
x_6_ = (((((8.0 + x_0) > (6.0 + x_3)? (8.0 + x_0) : (6.0 + x_3)) > ((5.0 + x_4) > ((5.0 + x_7) > (8.0 + x_8)? (5.0 + x_7) : (8.0 + x_8))? (5.0 + x_4) : ((5.0 + x_7) > (8.0 + x_8)? (5.0 + x_7) : (8.0 + x_8)))? ((8.0 + x_0) > (6.0 + x_3)? (8.0 + x_0) : (6.0 + x_3)) : ((5.0 + x_4) > ((5.0 + x_7) > (8.0 + x_8)? (5.0 + x_7) : (8.0 + x_8))? (5.0 + x_4) : ((5.0 + x_7) > (8.0 + x_8)? (5.0 + x_7) : (8.0 + x_8)))) > (((14.0 + x_10) > (2.0 + x_11)? (14.0 + x_10) : (2.0 + x_11)) > ((7.0 + x_12) > ((16.0 + x_14) > (10.0 + x_15)? (16.0 + x_14) : (10.0 + x_15))? (7.0 + x_12) : ((16.0 + x_14) > (10.0 + x_15)? (16.0 + x_14) : (10.0 + x_15)))? ((14.0 + x_10) > (2.0 + x_11)? (14.0 + x_10) : (2.0 + x_11)) : ((7.0 + x_12) > ((16.0 + x_14) > (10.0 + x_15)? (16.0 + x_14) : (10.0 + x_15))? (7.0 + x_12) : ((16.0 + x_14) > (10.0 + x_15)? (16.0 + x_14) : (10.0 + x_15))))? (((8.0 + x_0) > (6.0 + x_3)? (8.0 + x_0) : (6.0 + x_3)) > ((5.0 + x_4) > ((5.0 + x_7) > (8.0 + x_8)? (5.0 + x_7) : (8.0 + x_8))? (5.0 + x_4) : ((5.0 + x_7) > (8.0 + x_8)? (5.0 + x_7) : (8.0 + x_8)))? ((8.0 + x_0) > (6.0 + x_3)? (8.0 + x_0) : (6.0 + x_3)) : ((5.0 + x_4) > ((5.0 + x_7) > (8.0 + x_8)? (5.0 + x_7) : (8.0 + x_8))? (5.0 + x_4) : ((5.0 + x_7) > (8.0 + x_8)? (5.0 + x_7) : (8.0 + x_8)))) : (((14.0 + x_10) > (2.0 + x_11)? (14.0 + x_10) : (2.0 + x_11)) > ((7.0 + x_12) > ((16.0 + x_14) > (10.0 + x_15)? (16.0 + x_14) : (10.0 + x_15))? (7.0 + x_12) : ((16.0 + x_14) > (10.0 + x_15)? (16.0 + x_14) : (10.0 + x_15)))? ((14.0 + x_10) > (2.0 + x_11)? (14.0 + x_10) : (2.0 + x_11)) : ((7.0 + x_12) > ((16.0 + x_14) > (10.0 + x_15)? (16.0 + x_14) : (10.0 + x_15))? (7.0 + x_12) : ((16.0 + x_14) > (10.0 + x_15)? (16.0 + x_14) : (10.0 + x_15))))) > ((((17.0 + x_16) > (11.0 + x_17)? (17.0 + x_16) : (11.0 + x_17)) > ((12.0 + x_18) > ((14.0 + x_20) > (19.0 + x_27)? (14.0 + x_20) : (19.0 + x_27))? (12.0 + x_18) : ((14.0 + x_20) > (19.0 + x_27)? (14.0 + x_20) : (19.0 + x_27)))? ((17.0 + x_16) > (11.0 + x_17)? (17.0 + x_16) : (11.0 + x_17)) : ((12.0 + x_18) > ((14.0 + x_20) > (19.0 + x_27)? (14.0 + x_20) : (19.0 + x_27))? (12.0 + x_18) : ((14.0 + x_20) > (19.0 + x_27)? (14.0 + x_20) : (19.0 + x_27)))) > (((17.0 + x_28) > (6.0 + x_29)? (17.0 + x_28) : (6.0 + x_29)) > ((2.0 + x_31) > ((20.0 + x_33) > (12.0 + x_34)? (20.0 + x_33) : (12.0 + x_34))? (2.0 + x_31) : ((20.0 + x_33) > (12.0 + x_34)? (20.0 + x_33) : (12.0 + x_34)))? ((17.0 + x_28) > (6.0 + x_29)? (17.0 + x_28) : (6.0 + x_29)) : ((2.0 + x_31) > ((20.0 + x_33) > (12.0 + x_34)? (20.0 + x_33) : (12.0 + x_34))? (2.0 + x_31) : ((20.0 + x_33) > (12.0 + x_34)? (20.0 + x_33) : (12.0 + x_34))))? (((17.0 + x_16) > (11.0 + x_17)? (17.0 + x_16) : (11.0 + x_17)) > ((12.0 + x_18) > ((14.0 + x_20) > (19.0 + x_27)? (14.0 + x_20) : (19.0 + x_27))? (12.0 + x_18) : ((14.0 + x_20) > (19.0 + x_27)? (14.0 + x_20) : (19.0 + x_27)))? ((17.0 + x_16) > (11.0 + x_17)? (17.0 + x_16) : (11.0 + x_17)) : ((12.0 + x_18) > ((14.0 + x_20) > (19.0 + x_27)? (14.0 + x_20) : (19.0 + x_27))? (12.0 + x_18) : ((14.0 + x_20) > (19.0 + x_27)? (14.0 + x_20) : (19.0 + x_27)))) : (((17.0 + x_28) > (6.0 + x_29)? (17.0 + x_28) : (6.0 + x_29)) > ((2.0 + x_31) > ((20.0 + x_33) > (12.0 + x_34)? (20.0 + x_33) : (12.0 + x_34))? (2.0 + x_31) : ((20.0 + x_33) > (12.0 + x_34)? (20.0 + x_33) : (12.0 + x_34)))? ((17.0 + x_28) > (6.0 + x_29)? (17.0 + x_28) : (6.0 + x_29)) : ((2.0 + x_31) > ((20.0 + x_33) > (12.0 + x_34)? (20.0 + x_33) : (12.0 + x_34))? (2.0 + x_31) : ((20.0 + x_33) > (12.0 + x_34)? (20.0 + x_33) : (12.0 + x_34)))))? ((((8.0 + x_0) > (6.0 + x_3)? (8.0 + x_0) : (6.0 + x_3)) > ((5.0 + x_4) > ((5.0 + x_7) > (8.0 + x_8)? (5.0 + x_7) : (8.0 + x_8))? (5.0 + x_4) : ((5.0 + x_7) > (8.0 + x_8)? (5.0 + x_7) : (8.0 + x_8)))? ((8.0 + x_0) > (6.0 + x_3)? (8.0 + x_0) : (6.0 + x_3)) : ((5.0 + x_4) > ((5.0 + x_7) > (8.0 + x_8)? (5.0 + x_7) : (8.0 + x_8))? (5.0 + x_4) : ((5.0 + x_7) > (8.0 + x_8)? (5.0 + x_7) : (8.0 + x_8)))) > (((14.0 + x_10) > (2.0 + x_11)? (14.0 + x_10) : (2.0 + x_11)) > ((7.0 + x_12) > ((16.0 + x_14) > (10.0 + x_15)? (16.0 + x_14) : (10.0 + x_15))? (7.0 + x_12) : ((16.0 + x_14) > (10.0 + x_15)? (16.0 + x_14) : (10.0 + x_15)))? ((14.0 + x_10) > (2.0 + x_11)? (14.0 + x_10) : (2.0 + x_11)) : ((7.0 + x_12) > ((16.0 + x_14) > (10.0 + x_15)? (16.0 + x_14) : (10.0 + x_15))? (7.0 + x_12) : ((16.0 + x_14) > (10.0 + x_15)? (16.0 + x_14) : (10.0 + x_15))))? (((8.0 + x_0) > (6.0 + x_3)? (8.0 + x_0) : (6.0 + x_3)) > ((5.0 + x_4) > ((5.0 + x_7) > (8.0 + x_8)? (5.0 + x_7) : (8.0 + x_8))? (5.0 + x_4) : ((5.0 + x_7) > (8.0 + x_8)? (5.0 + x_7) : (8.0 + x_8)))? ((8.0 + x_0) > (6.0 + x_3)? (8.0 + x_0) : (6.0 + x_3)) : ((5.0 + x_4) > ((5.0 + x_7) > (8.0 + x_8)? (5.0 + x_7) : (8.0 + x_8))? (5.0 + x_4) : ((5.0 + x_7) > (8.0 + x_8)? (5.0 + x_7) : (8.0 + x_8)))) : (((14.0 + x_10) > (2.0 + x_11)? (14.0 + x_10) : (2.0 + x_11)) > ((7.0 + x_12) > ((16.0 + x_14) > (10.0 + x_15)? (16.0 + x_14) : (10.0 + x_15))? (7.0 + x_12) : ((16.0 + x_14) > (10.0 + x_15)? (16.0 + x_14) : (10.0 + x_15)))? ((14.0 + x_10) > (2.0 + x_11)? (14.0 + x_10) : (2.0 + x_11)) : ((7.0 + x_12) > ((16.0 + x_14) > (10.0 + x_15)? (16.0 + x_14) : (10.0 + x_15))? (7.0 + x_12) : ((16.0 + x_14) > (10.0 + x_15)? (16.0 + x_14) : (10.0 + x_15))))) : ((((17.0 + x_16) > (11.0 + x_17)? (17.0 + x_16) : (11.0 + x_17)) > ((12.0 + x_18) > ((14.0 + x_20) > (19.0 + x_27)? (14.0 + x_20) : (19.0 + x_27))? (12.0 + x_18) : ((14.0 + x_20) > (19.0 + x_27)? (14.0 + x_20) : (19.0 + x_27)))? ((17.0 + x_16) > (11.0 + x_17)? (17.0 + x_16) : (11.0 + x_17)) : ((12.0 + x_18) > ((14.0 + x_20) > (19.0 + x_27)? (14.0 + x_20) : (19.0 + x_27))? (12.0 + x_18) : ((14.0 + x_20) > (19.0 + x_27)? (14.0 + x_20) : (19.0 + x_27)))) > (((17.0 + x_28) > (6.0 + x_29)? (17.0 + x_28) : (6.0 + x_29)) > ((2.0 + x_31) > ((20.0 + x_33) > (12.0 + x_34)? (20.0 + x_33) : (12.0 + x_34))? (2.0 + x_31) : ((20.0 + x_33) > (12.0 + x_34)? (20.0 + x_33) : (12.0 + x_34)))? ((17.0 + x_28) > (6.0 + x_29)? (17.0 + x_28) : (6.0 + x_29)) : ((2.0 + x_31) > ((20.0 + x_33) > (12.0 + x_34)? (20.0 + x_33) : (12.0 + x_34))? (2.0 + x_31) : ((20.0 + x_33) > (12.0 + x_34)? (20.0 + x_33) : (12.0 + x_34))))? (((17.0 + x_16) > (11.0 + x_17)? (17.0 + x_16) : (11.0 + x_17)) > ((12.0 + x_18) > ((14.0 + x_20) > (19.0 + x_27)? (14.0 + x_20) : (19.0 + x_27))? (12.0 + x_18) : ((14.0 + x_20) > (19.0 + x_27)? (14.0 + x_20) : (19.0 + x_27)))? ((17.0 + x_16) > (11.0 + x_17)? (17.0 + x_16) : (11.0 + x_17)) : ((12.0 + x_18) > ((14.0 + x_20) > (19.0 + x_27)? (14.0 + x_20) : (19.0 + x_27))? (12.0 + x_18) : ((14.0 + x_20) > (19.0 + x_27)? (14.0 + x_20) : (19.0 + x_27)))) : (((17.0 + x_28) > (6.0 + x_29)? (17.0 + x_28) : (6.0 + x_29)) > ((2.0 + x_31) > ((20.0 + x_33) > (12.0 + x_34)? (20.0 + x_33) : (12.0 + x_34))? (2.0 + x_31) : ((20.0 + x_33) > (12.0 + x_34)? (20.0 + x_33) : (12.0 + x_34)))? ((17.0 + x_28) > (6.0 + x_29)? (17.0 + x_28) : (6.0 + x_29)) : ((2.0 + x_31) > ((20.0 + x_33) > (12.0 + x_34)? (20.0 + x_33) : (12.0 + x_34))? (2.0 + x_31) : ((20.0 + x_33) > (12.0 + x_34)? (20.0 + x_33) : (12.0 + x_34))))));
x_7_ = (((((19.0 + x_0) > (3.0 + x_1)? (19.0 + x_0) : (3.0 + x_1)) > ((3.0 + x_6) > ((13.0 + x_7) > (5.0 + x_9)? (13.0 + x_7) : (5.0 + x_9))? (3.0 + x_6) : ((13.0 + x_7) > (5.0 + x_9)? (13.0 + x_7) : (5.0 + x_9)))? ((19.0 + x_0) > (3.0 + x_1)? (19.0 + x_0) : (3.0 + x_1)) : ((3.0 + x_6) > ((13.0 + x_7) > (5.0 + x_9)? (13.0 + x_7) : (5.0 + x_9))? (3.0 + x_6) : ((13.0 + x_7) > (5.0 + x_9)? (13.0 + x_7) : (5.0 + x_9)))) > (((12.0 + x_10) > (12.0 + x_11)? (12.0 + x_10) : (12.0 + x_11)) > ((3.0 + x_12) > ((8.0 + x_14) > (18.0 + x_15)? (8.0 + x_14) : (18.0 + x_15))? (3.0 + x_12) : ((8.0 + x_14) > (18.0 + x_15)? (8.0 + x_14) : (18.0 + x_15)))? ((12.0 + x_10) > (12.0 + x_11)? (12.0 + x_10) : (12.0 + x_11)) : ((3.0 + x_12) > ((8.0 + x_14) > (18.0 + x_15)? (8.0 + x_14) : (18.0 + x_15))? (3.0 + x_12) : ((8.0 + x_14) > (18.0 + x_15)? (8.0 + x_14) : (18.0 + x_15))))? (((19.0 + x_0) > (3.0 + x_1)? (19.0 + x_0) : (3.0 + x_1)) > ((3.0 + x_6) > ((13.0 + x_7) > (5.0 + x_9)? (13.0 + x_7) : (5.0 + x_9))? (3.0 + x_6) : ((13.0 + x_7) > (5.0 + x_9)? (13.0 + x_7) : (5.0 + x_9)))? ((19.0 + x_0) > (3.0 + x_1)? (19.0 + x_0) : (3.0 + x_1)) : ((3.0 + x_6) > ((13.0 + x_7) > (5.0 + x_9)? (13.0 + x_7) : (5.0 + x_9))? (3.0 + x_6) : ((13.0 + x_7) > (5.0 + x_9)? (13.0 + x_7) : (5.0 + x_9)))) : (((12.0 + x_10) > (12.0 + x_11)? (12.0 + x_10) : (12.0 + x_11)) > ((3.0 + x_12) > ((8.0 + x_14) > (18.0 + x_15)? (8.0 + x_14) : (18.0 + x_15))? (3.0 + x_12) : ((8.0 + x_14) > (18.0 + x_15)? (8.0 + x_14) : (18.0 + x_15)))? ((12.0 + x_10) > (12.0 + x_11)? (12.0 + x_10) : (12.0 + x_11)) : ((3.0 + x_12) > ((8.0 + x_14) > (18.0 + x_15)? (8.0 + x_14) : (18.0 + x_15))? (3.0 + x_12) : ((8.0 + x_14) > (18.0 + x_15)? (8.0 + x_14) : (18.0 + x_15))))) > ((((9.0 + x_20) > (10.0 + x_21)? (9.0 + x_20) : (10.0 + x_21)) > ((8.0 + x_22) > ((11.0 + x_23) > (10.0 + x_24)? (11.0 + x_23) : (10.0 + x_24))? (8.0 + x_22) : ((11.0 + x_23) > (10.0 + x_24)? (11.0 + x_23) : (10.0 + x_24)))? ((9.0 + x_20) > (10.0 + x_21)? (9.0 + x_20) : (10.0 + x_21)) : ((8.0 + x_22) > ((11.0 + x_23) > (10.0 + x_24)? (11.0 + x_23) : (10.0 + x_24))? (8.0 + x_22) : ((11.0 + x_23) > (10.0 + x_24)? (11.0 + x_23) : (10.0 + x_24)))) > (((4.0 + x_27) > (8.0 + x_29)? (4.0 + x_27) : (8.0 + x_29)) > ((4.0 + x_32) > ((20.0 + x_33) > (13.0 + x_36)? (20.0 + x_33) : (13.0 + x_36))? (4.0 + x_32) : ((20.0 + x_33) > (13.0 + x_36)? (20.0 + x_33) : (13.0 + x_36)))? ((4.0 + x_27) > (8.0 + x_29)? (4.0 + x_27) : (8.0 + x_29)) : ((4.0 + x_32) > ((20.0 + x_33) > (13.0 + x_36)? (20.0 + x_33) : (13.0 + x_36))? (4.0 + x_32) : ((20.0 + x_33) > (13.0 + x_36)? (20.0 + x_33) : (13.0 + x_36))))? (((9.0 + x_20) > (10.0 + x_21)? (9.0 + x_20) : (10.0 + x_21)) > ((8.0 + x_22) > ((11.0 + x_23) > (10.0 + x_24)? (11.0 + x_23) : (10.0 + x_24))? (8.0 + x_22) : ((11.0 + x_23) > (10.0 + x_24)? (11.0 + x_23) : (10.0 + x_24)))? ((9.0 + x_20) > (10.0 + x_21)? (9.0 + x_20) : (10.0 + x_21)) : ((8.0 + x_22) > ((11.0 + x_23) > (10.0 + x_24)? (11.0 + x_23) : (10.0 + x_24))? (8.0 + x_22) : ((11.0 + x_23) > (10.0 + x_24)? (11.0 + x_23) : (10.0 + x_24)))) : (((4.0 + x_27) > (8.0 + x_29)? (4.0 + x_27) : (8.0 + x_29)) > ((4.0 + x_32) > ((20.0 + x_33) > (13.0 + x_36)? (20.0 + x_33) : (13.0 + x_36))? (4.0 + x_32) : ((20.0 + x_33) > (13.0 + x_36)? (20.0 + x_33) : (13.0 + x_36)))? ((4.0 + x_27) > (8.0 + x_29)? (4.0 + x_27) : (8.0 + x_29)) : ((4.0 + x_32) > ((20.0 + x_33) > (13.0 + x_36)? (20.0 + x_33) : (13.0 + x_36))? (4.0 + x_32) : ((20.0 + x_33) > (13.0 + x_36)? (20.0 + x_33) : (13.0 + x_36)))))? ((((19.0 + x_0) > (3.0 + x_1)? (19.0 + x_0) : (3.0 + x_1)) > ((3.0 + x_6) > ((13.0 + x_7) > (5.0 + x_9)? (13.0 + x_7) : (5.0 + x_9))? (3.0 + x_6) : ((13.0 + x_7) > (5.0 + x_9)? (13.0 + x_7) : (5.0 + x_9)))? ((19.0 + x_0) > (3.0 + x_1)? (19.0 + x_0) : (3.0 + x_1)) : ((3.0 + x_6) > ((13.0 + x_7) > (5.0 + x_9)? (13.0 + x_7) : (5.0 + x_9))? (3.0 + x_6) : ((13.0 + x_7) > (5.0 + x_9)? (13.0 + x_7) : (5.0 + x_9)))) > (((12.0 + x_10) > (12.0 + x_11)? (12.0 + x_10) : (12.0 + x_11)) > ((3.0 + x_12) > ((8.0 + x_14) > (18.0 + x_15)? (8.0 + x_14) : (18.0 + x_15))? (3.0 + x_12) : ((8.0 + x_14) > (18.0 + x_15)? (8.0 + x_14) : (18.0 + x_15)))? ((12.0 + x_10) > (12.0 + x_11)? (12.0 + x_10) : (12.0 + x_11)) : ((3.0 + x_12) > ((8.0 + x_14) > (18.0 + x_15)? (8.0 + x_14) : (18.0 + x_15))? (3.0 + x_12) : ((8.0 + x_14) > (18.0 + x_15)? (8.0 + x_14) : (18.0 + x_15))))? (((19.0 + x_0) > (3.0 + x_1)? (19.0 + x_0) : (3.0 + x_1)) > ((3.0 + x_6) > ((13.0 + x_7) > (5.0 + x_9)? (13.0 + x_7) : (5.0 + x_9))? (3.0 + x_6) : ((13.0 + x_7) > (5.0 + x_9)? (13.0 + x_7) : (5.0 + x_9)))? ((19.0 + x_0) > (3.0 + x_1)? (19.0 + x_0) : (3.0 + x_1)) : ((3.0 + x_6) > ((13.0 + x_7) > (5.0 + x_9)? (13.0 + x_7) : (5.0 + x_9))? (3.0 + x_6) : ((13.0 + x_7) > (5.0 + x_9)? (13.0 + x_7) : (5.0 + x_9)))) : (((12.0 + x_10) > (12.0 + x_11)? (12.0 + x_10) : (12.0 + x_11)) > ((3.0 + x_12) > ((8.0 + x_14) > (18.0 + x_15)? (8.0 + x_14) : (18.0 + x_15))? (3.0 + x_12) : ((8.0 + x_14) > (18.0 + x_15)? (8.0 + x_14) : (18.0 + x_15)))? ((12.0 + x_10) > (12.0 + x_11)? (12.0 + x_10) : (12.0 + x_11)) : ((3.0 + x_12) > ((8.0 + x_14) > (18.0 + x_15)? (8.0 + x_14) : (18.0 + x_15))? (3.0 + x_12) : ((8.0 + x_14) > (18.0 + x_15)? (8.0 + x_14) : (18.0 + x_15))))) : ((((9.0 + x_20) > (10.0 + x_21)? (9.0 + x_20) : (10.0 + x_21)) > ((8.0 + x_22) > ((11.0 + x_23) > (10.0 + x_24)? (11.0 + x_23) : (10.0 + x_24))? (8.0 + x_22) : ((11.0 + x_23) > (10.0 + x_24)? (11.0 + x_23) : (10.0 + x_24)))? ((9.0 + x_20) > (10.0 + x_21)? (9.0 + x_20) : (10.0 + x_21)) : ((8.0 + x_22) > ((11.0 + x_23) > (10.0 + x_24)? (11.0 + x_23) : (10.0 + x_24))? (8.0 + x_22) : ((11.0 + x_23) > (10.0 + x_24)? (11.0 + x_23) : (10.0 + x_24)))) > (((4.0 + x_27) > (8.0 + x_29)? (4.0 + x_27) : (8.0 + x_29)) > ((4.0 + x_32) > ((20.0 + x_33) > (13.0 + x_36)? (20.0 + x_33) : (13.0 + x_36))? (4.0 + x_32) : ((20.0 + x_33) > (13.0 + x_36)? (20.0 + x_33) : (13.0 + x_36)))? ((4.0 + x_27) > (8.0 + x_29)? (4.0 + x_27) : (8.0 + x_29)) : ((4.0 + x_32) > ((20.0 + x_33) > (13.0 + x_36)? (20.0 + x_33) : (13.0 + x_36))? (4.0 + x_32) : ((20.0 + x_33) > (13.0 + x_36)? (20.0 + x_33) : (13.0 + x_36))))? (((9.0 + x_20) > (10.0 + x_21)? (9.0 + x_20) : (10.0 + x_21)) > ((8.0 + x_22) > ((11.0 + x_23) > (10.0 + x_24)? (11.0 + x_23) : (10.0 + x_24))? (8.0 + x_22) : ((11.0 + x_23) > (10.0 + x_24)? (11.0 + x_23) : (10.0 + x_24)))? ((9.0 + x_20) > (10.0 + x_21)? (9.0 + x_20) : (10.0 + x_21)) : ((8.0 + x_22) > ((11.0 + x_23) > (10.0 + x_24)? (11.0 + x_23) : (10.0 + x_24))? (8.0 + x_22) : ((11.0 + x_23) > (10.0 + x_24)? (11.0 + x_23) : (10.0 + x_24)))) : (((4.0 + x_27) > (8.0 + x_29)? (4.0 + x_27) : (8.0 + x_29)) > ((4.0 + x_32) > ((20.0 + x_33) > (13.0 + x_36)? (20.0 + x_33) : (13.0 + x_36))? (4.0 + x_32) : ((20.0 + x_33) > (13.0 + x_36)? (20.0 + x_33) : (13.0 + x_36)))? ((4.0 + x_27) > (8.0 + x_29)? (4.0 + x_27) : (8.0 + x_29)) : ((4.0 + x_32) > ((20.0 + x_33) > (13.0 + x_36)? (20.0 + x_33) : (13.0 + x_36))? (4.0 + x_32) : ((20.0 + x_33) > (13.0 + x_36)? (20.0 + x_33) : (13.0 + x_36))))));
x_8_ = (((((16.0 + x_3) > (6.0 + x_8)? (16.0 + x_3) : (6.0 + x_8)) > ((10.0 + x_9) > ((13.0 + x_11) > (17.0 + x_12)? (13.0 + x_11) : (17.0 + x_12))? (10.0 + x_9) : ((13.0 + x_11) > (17.0 + x_12)? (13.0 + x_11) : (17.0 + x_12)))? ((16.0 + x_3) > (6.0 + x_8)? (16.0 + x_3) : (6.0 + x_8)) : ((10.0 + x_9) > ((13.0 + x_11) > (17.0 + x_12)? (13.0 + x_11) : (17.0 + x_12))? (10.0 + x_9) : ((13.0 + x_11) > (17.0 + x_12)? (13.0 + x_11) : (17.0 + x_12)))) > (((6.0 + x_15) > (13.0 + x_17)? (6.0 + x_15) : (13.0 + x_17)) > ((6.0 + x_18) > ((11.0 + x_20) > (16.0 + x_21)? (11.0 + x_20) : (16.0 + x_21))? (6.0 + x_18) : ((11.0 + x_20) > (16.0 + x_21)? (11.0 + x_20) : (16.0 + x_21)))? ((6.0 + x_15) > (13.0 + x_17)? (6.0 + x_15) : (13.0 + x_17)) : ((6.0 + x_18) > ((11.0 + x_20) > (16.0 + x_21)? (11.0 + x_20) : (16.0 + x_21))? (6.0 + x_18) : ((11.0 + x_20) > (16.0 + x_21)? (11.0 + x_20) : (16.0 + x_21))))? (((16.0 + x_3) > (6.0 + x_8)? (16.0 + x_3) : (6.0 + x_8)) > ((10.0 + x_9) > ((13.0 + x_11) > (17.0 + x_12)? (13.0 + x_11) : (17.0 + x_12))? (10.0 + x_9) : ((13.0 + x_11) > (17.0 + x_12)? (13.0 + x_11) : (17.0 + x_12)))? ((16.0 + x_3) > (6.0 + x_8)? (16.0 + x_3) : (6.0 + x_8)) : ((10.0 + x_9) > ((13.0 + x_11) > (17.0 + x_12)? (13.0 + x_11) : (17.0 + x_12))? (10.0 + x_9) : ((13.0 + x_11) > (17.0 + x_12)? (13.0 + x_11) : (17.0 + x_12)))) : (((6.0 + x_15) > (13.0 + x_17)? (6.0 + x_15) : (13.0 + x_17)) > ((6.0 + x_18) > ((11.0 + x_20) > (16.0 + x_21)? (11.0 + x_20) : (16.0 + x_21))? (6.0 + x_18) : ((11.0 + x_20) > (16.0 + x_21)? (11.0 + x_20) : (16.0 + x_21)))? ((6.0 + x_15) > (13.0 + x_17)? (6.0 + x_15) : (13.0 + x_17)) : ((6.0 + x_18) > ((11.0 + x_20) > (16.0 + x_21)? (11.0 + x_20) : (16.0 + x_21))? (6.0 + x_18) : ((11.0 + x_20) > (16.0 + x_21)? (11.0 + x_20) : (16.0 + x_21))))) > ((((9.0 + x_25) > (5.0 + x_28)? (9.0 + x_25) : (5.0 + x_28)) > ((9.0 + x_29) > ((3.0 + x_30) > (10.0 + x_31)? (3.0 + x_30) : (10.0 + x_31))? (9.0 + x_29) : ((3.0 + x_30) > (10.0 + x_31)? (3.0 + x_30) : (10.0 + x_31)))? ((9.0 + x_25) > (5.0 + x_28)? (9.0 + x_25) : (5.0 + x_28)) : ((9.0 + x_29) > ((3.0 + x_30) > (10.0 + x_31)? (3.0 + x_30) : (10.0 + x_31))? (9.0 + x_29) : ((3.0 + x_30) > (10.0 + x_31)? (3.0 + x_30) : (10.0 + x_31)))) > (((7.0 + x_32) > (10.0 + x_35)? (7.0 + x_32) : (10.0 + x_35)) > ((14.0 + x_36) > ((18.0 + x_38) > (7.0 + x_39)? (18.0 + x_38) : (7.0 + x_39))? (14.0 + x_36) : ((18.0 + x_38) > (7.0 + x_39)? (18.0 + x_38) : (7.0 + x_39)))? ((7.0 + x_32) > (10.0 + x_35)? (7.0 + x_32) : (10.0 + x_35)) : ((14.0 + x_36) > ((18.0 + x_38) > (7.0 + x_39)? (18.0 + x_38) : (7.0 + x_39))? (14.0 + x_36) : ((18.0 + x_38) > (7.0 + x_39)? (18.0 + x_38) : (7.0 + x_39))))? (((9.0 + x_25) > (5.0 + x_28)? (9.0 + x_25) : (5.0 + x_28)) > ((9.0 + x_29) > ((3.0 + x_30) > (10.0 + x_31)? (3.0 + x_30) : (10.0 + x_31))? (9.0 + x_29) : ((3.0 + x_30) > (10.0 + x_31)? (3.0 + x_30) : (10.0 + x_31)))? ((9.0 + x_25) > (5.0 + x_28)? (9.0 + x_25) : (5.0 + x_28)) : ((9.0 + x_29) > ((3.0 + x_30) > (10.0 + x_31)? (3.0 + x_30) : (10.0 + x_31))? (9.0 + x_29) : ((3.0 + x_30) > (10.0 + x_31)? (3.0 + x_30) : (10.0 + x_31)))) : (((7.0 + x_32) > (10.0 + x_35)? (7.0 + x_32) : (10.0 + x_35)) > ((14.0 + x_36) > ((18.0 + x_38) > (7.0 + x_39)? (18.0 + x_38) : (7.0 + x_39))? (14.0 + x_36) : ((18.0 + x_38) > (7.0 + x_39)? (18.0 + x_38) : (7.0 + x_39)))? ((7.0 + x_32) > (10.0 + x_35)? (7.0 + x_32) : (10.0 + x_35)) : ((14.0 + x_36) > ((18.0 + x_38) > (7.0 + x_39)? (18.0 + x_38) : (7.0 + x_39))? (14.0 + x_36) : ((18.0 + x_38) > (7.0 + x_39)? (18.0 + x_38) : (7.0 + x_39)))))? ((((16.0 + x_3) > (6.0 + x_8)? (16.0 + x_3) : (6.0 + x_8)) > ((10.0 + x_9) > ((13.0 + x_11) > (17.0 + x_12)? (13.0 + x_11) : (17.0 + x_12))? (10.0 + x_9) : ((13.0 + x_11) > (17.0 + x_12)? (13.0 + x_11) : (17.0 + x_12)))? ((16.0 + x_3) > (6.0 + x_8)? (16.0 + x_3) : (6.0 + x_8)) : ((10.0 + x_9) > ((13.0 + x_11) > (17.0 + x_12)? (13.0 + x_11) : (17.0 + x_12))? (10.0 + x_9) : ((13.0 + x_11) > (17.0 + x_12)? (13.0 + x_11) : (17.0 + x_12)))) > (((6.0 + x_15) > (13.0 + x_17)? (6.0 + x_15) : (13.0 + x_17)) > ((6.0 + x_18) > ((11.0 + x_20) > (16.0 + x_21)? (11.0 + x_20) : (16.0 + x_21))? (6.0 + x_18) : ((11.0 + x_20) > (16.0 + x_21)? (11.0 + x_20) : (16.0 + x_21)))? ((6.0 + x_15) > (13.0 + x_17)? (6.0 + x_15) : (13.0 + x_17)) : ((6.0 + x_18) > ((11.0 + x_20) > (16.0 + x_21)? (11.0 + x_20) : (16.0 + x_21))? (6.0 + x_18) : ((11.0 + x_20) > (16.0 + x_21)? (11.0 + x_20) : (16.0 + x_21))))? (((16.0 + x_3) > (6.0 + x_8)? (16.0 + x_3) : (6.0 + x_8)) > ((10.0 + x_9) > ((13.0 + x_11) > (17.0 + x_12)? (13.0 + x_11) : (17.0 + x_12))? (10.0 + x_9) : ((13.0 + x_11) > (17.0 + x_12)? (13.0 + x_11) : (17.0 + x_12)))? ((16.0 + x_3) > (6.0 + x_8)? (16.0 + x_3) : (6.0 + x_8)) : ((10.0 + x_9) > ((13.0 + x_11) > (17.0 + x_12)? (13.0 + x_11) : (17.0 + x_12))? (10.0 + x_9) : ((13.0 + x_11) > (17.0 + x_12)? (13.0 + x_11) : (17.0 + x_12)))) : (((6.0 + x_15) > (13.0 + x_17)? (6.0 + x_15) : (13.0 + x_17)) > ((6.0 + x_18) > ((11.0 + x_20) > (16.0 + x_21)? (11.0 + x_20) : (16.0 + x_21))? (6.0 + x_18) : ((11.0 + x_20) > (16.0 + x_21)? (11.0 + x_20) : (16.0 + x_21)))? ((6.0 + x_15) > (13.0 + x_17)? (6.0 + x_15) : (13.0 + x_17)) : ((6.0 + x_18) > ((11.0 + x_20) > (16.0 + x_21)? (11.0 + x_20) : (16.0 + x_21))? (6.0 + x_18) : ((11.0 + x_20) > (16.0 + x_21)? (11.0 + x_20) : (16.0 + x_21))))) : ((((9.0 + x_25) > (5.0 + x_28)? (9.0 + x_25) : (5.0 + x_28)) > ((9.0 + x_29) > ((3.0 + x_30) > (10.0 + x_31)? (3.0 + x_30) : (10.0 + x_31))? (9.0 + x_29) : ((3.0 + x_30) > (10.0 + x_31)? (3.0 + x_30) : (10.0 + x_31)))? ((9.0 + x_25) > (5.0 + x_28)? (9.0 + x_25) : (5.0 + x_28)) : ((9.0 + x_29) > ((3.0 + x_30) > (10.0 + x_31)? (3.0 + x_30) : (10.0 + x_31))? (9.0 + x_29) : ((3.0 + x_30) > (10.0 + x_31)? (3.0 + x_30) : (10.0 + x_31)))) > (((7.0 + x_32) > (10.0 + x_35)? (7.0 + x_32) : (10.0 + x_35)) > ((14.0 + x_36) > ((18.0 + x_38) > (7.0 + x_39)? (18.0 + x_38) : (7.0 + x_39))? (14.0 + x_36) : ((18.0 + x_38) > (7.0 + x_39)? (18.0 + x_38) : (7.0 + x_39)))? ((7.0 + x_32) > (10.0 + x_35)? (7.0 + x_32) : (10.0 + x_35)) : ((14.0 + x_36) > ((18.0 + x_38) > (7.0 + x_39)? (18.0 + x_38) : (7.0 + x_39))? (14.0 + x_36) : ((18.0 + x_38) > (7.0 + x_39)? (18.0 + x_38) : (7.0 + x_39))))? (((9.0 + x_25) > (5.0 + x_28)? (9.0 + x_25) : (5.0 + x_28)) > ((9.0 + x_29) > ((3.0 + x_30) > (10.0 + x_31)? (3.0 + x_30) : (10.0 + x_31))? (9.0 + x_29) : ((3.0 + x_30) > (10.0 + x_31)? (3.0 + x_30) : (10.0 + x_31)))? ((9.0 + x_25) > (5.0 + x_28)? (9.0 + x_25) : (5.0 + x_28)) : ((9.0 + x_29) > ((3.0 + x_30) > (10.0 + x_31)? (3.0 + x_30) : (10.0 + x_31))? (9.0 + x_29) : ((3.0 + x_30) > (10.0 + x_31)? (3.0 + x_30) : (10.0 + x_31)))) : (((7.0 + x_32) > (10.0 + x_35)? (7.0 + x_32) : (10.0 + x_35)) > ((14.0 + x_36) > ((18.0 + x_38) > (7.0 + x_39)? (18.0 + x_38) : (7.0 + x_39))? (14.0 + x_36) : ((18.0 + x_38) > (7.0 + x_39)? (18.0 + x_38) : (7.0 + x_39)))? ((7.0 + x_32) > (10.0 + x_35)? (7.0 + x_32) : (10.0 + x_35)) : ((14.0 + x_36) > ((18.0 + x_38) > (7.0 + x_39)? (18.0 + x_38) : (7.0 + x_39))? (14.0 + x_36) : ((18.0 + x_38) > (7.0 + x_39)? (18.0 + x_38) : (7.0 + x_39))))));
x_9_ = (((((20.0 + x_0) > (5.0 + x_2)? (20.0 + x_0) : (5.0 + x_2)) > ((1.0 + x_4) > ((14.0 + x_5) > (10.0 + x_9)? (14.0 + x_5) : (10.0 + x_9))? (1.0 + x_4) : ((14.0 + x_5) > (10.0 + x_9)? (14.0 + x_5) : (10.0 + x_9)))? ((20.0 + x_0) > (5.0 + x_2)? (20.0 + x_0) : (5.0 + x_2)) : ((1.0 + x_4) > ((14.0 + x_5) > (10.0 + x_9)? (14.0 + x_5) : (10.0 + x_9))? (1.0 + x_4) : ((14.0 + x_5) > (10.0 + x_9)? (14.0 + x_5) : (10.0 + x_9)))) > (((16.0 + x_10) > (6.0 + x_12)? (16.0 + x_10) : (6.0 + x_12)) > ((19.0 + x_13) > ((11.0 + x_14) > (3.0 + x_15)? (11.0 + x_14) : (3.0 + x_15))? (19.0 + x_13) : ((11.0 + x_14) > (3.0 + x_15)? (11.0 + x_14) : (3.0 + x_15)))? ((16.0 + x_10) > (6.0 + x_12)? (16.0 + x_10) : (6.0 + x_12)) : ((19.0 + x_13) > ((11.0 + x_14) > (3.0 + x_15)? (11.0 + x_14) : (3.0 + x_15))? (19.0 + x_13) : ((11.0 + x_14) > (3.0 + x_15)? (11.0 + x_14) : (3.0 + x_15))))? (((20.0 + x_0) > (5.0 + x_2)? (20.0 + x_0) : (5.0 + x_2)) > ((1.0 + x_4) > ((14.0 + x_5) > (10.0 + x_9)? (14.0 + x_5) : (10.0 + x_9))? (1.0 + x_4) : ((14.0 + x_5) > (10.0 + x_9)? (14.0 + x_5) : (10.0 + x_9)))? ((20.0 + x_0) > (5.0 + x_2)? (20.0 + x_0) : (5.0 + x_2)) : ((1.0 + x_4) > ((14.0 + x_5) > (10.0 + x_9)? (14.0 + x_5) : (10.0 + x_9))? (1.0 + x_4) : ((14.0 + x_5) > (10.0 + x_9)? (14.0 + x_5) : (10.0 + x_9)))) : (((16.0 + x_10) > (6.0 + x_12)? (16.0 + x_10) : (6.0 + x_12)) > ((19.0 + x_13) > ((11.0 + x_14) > (3.0 + x_15)? (11.0 + x_14) : (3.0 + x_15))? (19.0 + x_13) : ((11.0 + x_14) > (3.0 + x_15)? (11.0 + x_14) : (3.0 + x_15)))? ((16.0 + x_10) > (6.0 + x_12)? (16.0 + x_10) : (6.0 + x_12)) : ((19.0 + x_13) > ((11.0 + x_14) > (3.0 + x_15)? (11.0 + x_14) : (3.0 + x_15))? (19.0 + x_13) : ((11.0 + x_14) > (3.0 + x_15)? (11.0 + x_14) : (3.0 + x_15))))) > ((((12.0 + x_18) > (5.0 + x_20)? (12.0 + x_18) : (5.0 + x_20)) > ((19.0 + x_23) > ((2.0 + x_25) > (8.0 + x_28)? (2.0 + x_25) : (8.0 + x_28))? (19.0 + x_23) : ((2.0 + x_25) > (8.0 + x_28)? (2.0 + x_25) : (8.0 + x_28)))? ((12.0 + x_18) > (5.0 + x_20)? (12.0 + x_18) : (5.0 + x_20)) : ((19.0 + x_23) > ((2.0 + x_25) > (8.0 + x_28)? (2.0 + x_25) : (8.0 + x_28))? (19.0 + x_23) : ((2.0 + x_25) > (8.0 + x_28)? (2.0 + x_25) : (8.0 + x_28)))) > (((7.0 + x_30) > (16.0 + x_34)? (7.0 + x_30) : (16.0 + x_34)) > ((12.0 + x_35) > ((8.0 + x_37) > (19.0 + x_38)? (8.0 + x_37) : (19.0 + x_38))? (12.0 + x_35) : ((8.0 + x_37) > (19.0 + x_38)? (8.0 + x_37) : (19.0 + x_38)))? ((7.0 + x_30) > (16.0 + x_34)? (7.0 + x_30) : (16.0 + x_34)) : ((12.0 + x_35) > ((8.0 + x_37) > (19.0 + x_38)? (8.0 + x_37) : (19.0 + x_38))? (12.0 + x_35) : ((8.0 + x_37) > (19.0 + x_38)? (8.0 + x_37) : (19.0 + x_38))))? (((12.0 + x_18) > (5.0 + x_20)? (12.0 + x_18) : (5.0 + x_20)) > ((19.0 + x_23) > ((2.0 + x_25) > (8.0 + x_28)? (2.0 + x_25) : (8.0 + x_28))? (19.0 + x_23) : ((2.0 + x_25) > (8.0 + x_28)? (2.0 + x_25) : (8.0 + x_28)))? ((12.0 + x_18) > (5.0 + x_20)? (12.0 + x_18) : (5.0 + x_20)) : ((19.0 + x_23) > ((2.0 + x_25) > (8.0 + x_28)? (2.0 + x_25) : (8.0 + x_28))? (19.0 + x_23) : ((2.0 + x_25) > (8.0 + x_28)? (2.0 + x_25) : (8.0 + x_28)))) : (((7.0 + x_30) > (16.0 + x_34)? (7.0 + x_30) : (16.0 + x_34)) > ((12.0 + x_35) > ((8.0 + x_37) > (19.0 + x_38)? (8.0 + x_37) : (19.0 + x_38))? (12.0 + x_35) : ((8.0 + x_37) > (19.0 + x_38)? (8.0 + x_37) : (19.0 + x_38)))? ((7.0 + x_30) > (16.0 + x_34)? (7.0 + x_30) : (16.0 + x_34)) : ((12.0 + x_35) > ((8.0 + x_37) > (19.0 + x_38)? (8.0 + x_37) : (19.0 + x_38))? (12.0 + x_35) : ((8.0 + x_37) > (19.0 + x_38)? (8.0 + x_37) : (19.0 + x_38)))))? ((((20.0 + x_0) > (5.0 + x_2)? (20.0 + x_0) : (5.0 + x_2)) > ((1.0 + x_4) > ((14.0 + x_5) > (10.0 + x_9)? (14.0 + x_5) : (10.0 + x_9))? (1.0 + x_4) : ((14.0 + x_5) > (10.0 + x_9)? (14.0 + x_5) : (10.0 + x_9)))? ((20.0 + x_0) > (5.0 + x_2)? (20.0 + x_0) : (5.0 + x_2)) : ((1.0 + x_4) > ((14.0 + x_5) > (10.0 + x_9)? (14.0 + x_5) : (10.0 + x_9))? (1.0 + x_4) : ((14.0 + x_5) > (10.0 + x_9)? (14.0 + x_5) : (10.0 + x_9)))) > (((16.0 + x_10) > (6.0 + x_12)? (16.0 + x_10) : (6.0 + x_12)) > ((19.0 + x_13) > ((11.0 + x_14) > (3.0 + x_15)? (11.0 + x_14) : (3.0 + x_15))? (19.0 + x_13) : ((11.0 + x_14) > (3.0 + x_15)? (11.0 + x_14) : (3.0 + x_15)))? ((16.0 + x_10) > (6.0 + x_12)? (16.0 + x_10) : (6.0 + x_12)) : ((19.0 + x_13) > ((11.0 + x_14) > (3.0 + x_15)? (11.0 + x_14) : (3.0 + x_15))? (19.0 + x_13) : ((11.0 + x_14) > (3.0 + x_15)? (11.0 + x_14) : (3.0 + x_15))))? (((20.0 + x_0) > (5.0 + x_2)? (20.0 + x_0) : (5.0 + x_2)) > ((1.0 + x_4) > ((14.0 + x_5) > (10.0 + x_9)? (14.0 + x_5) : (10.0 + x_9))? (1.0 + x_4) : ((14.0 + x_5) > (10.0 + x_9)? (14.0 + x_5) : (10.0 + x_9)))? ((20.0 + x_0) > (5.0 + x_2)? (20.0 + x_0) : (5.0 + x_2)) : ((1.0 + x_4) > ((14.0 + x_5) > (10.0 + x_9)? (14.0 + x_5) : (10.0 + x_9))? (1.0 + x_4) : ((14.0 + x_5) > (10.0 + x_9)? (14.0 + x_5) : (10.0 + x_9)))) : (((16.0 + x_10) > (6.0 + x_12)? (16.0 + x_10) : (6.0 + x_12)) > ((19.0 + x_13) > ((11.0 + x_14) > (3.0 + x_15)? (11.0 + x_14) : (3.0 + x_15))? (19.0 + x_13) : ((11.0 + x_14) > (3.0 + x_15)? (11.0 + x_14) : (3.0 + x_15)))? ((16.0 + x_10) > (6.0 + x_12)? (16.0 + x_10) : (6.0 + x_12)) : ((19.0 + x_13) > ((11.0 + x_14) > (3.0 + x_15)? (11.0 + x_14) : (3.0 + x_15))? (19.0 + x_13) : ((11.0 + x_14) > (3.0 + x_15)? (11.0 + x_14) : (3.0 + x_15))))) : ((((12.0 + x_18) > (5.0 + x_20)? (12.0 + x_18) : (5.0 + x_20)) > ((19.0 + x_23) > ((2.0 + x_25) > (8.0 + x_28)? (2.0 + x_25) : (8.0 + x_28))? (19.0 + x_23) : ((2.0 + x_25) > (8.0 + x_28)? (2.0 + x_25) : (8.0 + x_28)))? ((12.0 + x_18) > (5.0 + x_20)? (12.0 + x_18) : (5.0 + x_20)) : ((19.0 + x_23) > ((2.0 + x_25) > (8.0 + x_28)? (2.0 + x_25) : (8.0 + x_28))? (19.0 + x_23) : ((2.0 + x_25) > (8.0 + x_28)? (2.0 + x_25) : (8.0 + x_28)))) > (((7.0 + x_30) > (16.0 + x_34)? (7.0 + x_30) : (16.0 + x_34)) > ((12.0 + x_35) > ((8.0 + x_37) > (19.0 + x_38)? (8.0 + x_37) : (19.0 + x_38))? (12.0 + x_35) : ((8.0 + x_37) > (19.0 + x_38)? (8.0 + x_37) : (19.0 + x_38)))? ((7.0 + x_30) > (16.0 + x_34)? (7.0 + x_30) : (16.0 + x_34)) : ((12.0 + x_35) > ((8.0 + x_37) > (19.0 + x_38)? (8.0 + x_37) : (19.0 + x_38))? (12.0 + x_35) : ((8.0 + x_37) > (19.0 + x_38)? (8.0 + x_37) : (19.0 + x_38))))? (((12.0 + x_18) > (5.0 + x_20)? (12.0 + x_18) : (5.0 + x_20)) > ((19.0 + x_23) > ((2.0 + x_25) > (8.0 + x_28)? (2.0 + x_25) : (8.0 + x_28))? (19.0 + x_23) : ((2.0 + x_25) > (8.0 + x_28)? (2.0 + x_25) : (8.0 + x_28)))? ((12.0 + x_18) > (5.0 + x_20)? (12.0 + x_18) : (5.0 + x_20)) : ((19.0 + x_23) > ((2.0 + x_25) > (8.0 + x_28)? (2.0 + x_25) : (8.0 + x_28))? (19.0 + x_23) : ((2.0 + x_25) > (8.0 + x_28)? (2.0 + x_25) : (8.0 + x_28)))) : (((7.0 + x_30) > (16.0 + x_34)? (7.0 + x_30) : (16.0 + x_34)) > ((12.0 + x_35) > ((8.0 + x_37) > (19.0 + x_38)? (8.0 + x_37) : (19.0 + x_38))? (12.0 + x_35) : ((8.0 + x_37) > (19.0 + x_38)? (8.0 + x_37) : (19.0 + x_38)))? ((7.0 + x_30) > (16.0 + x_34)? (7.0 + x_30) : (16.0 + x_34)) : ((12.0 + x_35) > ((8.0 + x_37) > (19.0 + x_38)? (8.0 + x_37) : (19.0 + x_38))? (12.0 + x_35) : ((8.0 + x_37) > (19.0 + x_38)? (8.0 + x_37) : (19.0 + x_38))))));
x_10_ = (((((12.0 + x_0) > (12.0 + x_2)? (12.0 + x_0) : (12.0 + x_2)) > ((12.0 + x_4) > ((16.0 + x_7) > (11.0 + x_8)? (16.0 + x_7) : (11.0 + x_8))? (12.0 + x_4) : ((16.0 + x_7) > (11.0 + x_8)? (16.0 + x_7) : (11.0 + x_8)))? ((12.0 + x_0) > (12.0 + x_2)? (12.0 + x_0) : (12.0 + x_2)) : ((12.0 + x_4) > ((16.0 + x_7) > (11.0 + x_8)? (16.0 + x_7) : (11.0 + x_8))? (12.0 + x_4) : ((16.0 + x_7) > (11.0 + x_8)? (16.0 + x_7) : (11.0 + x_8)))) > (((6.0 + x_9) > (14.0 + x_10)? (6.0 + x_9) : (14.0 + x_10)) > ((4.0 + x_11) > ((4.0 + x_19) > (5.0 + x_21)? (4.0 + x_19) : (5.0 + x_21))? (4.0 + x_11) : ((4.0 + x_19) > (5.0 + x_21)? (4.0 + x_19) : (5.0 + x_21)))? ((6.0 + x_9) > (14.0 + x_10)? (6.0 + x_9) : (14.0 + x_10)) : ((4.0 + x_11) > ((4.0 + x_19) > (5.0 + x_21)? (4.0 + x_19) : (5.0 + x_21))? (4.0 + x_11) : ((4.0 + x_19) > (5.0 + x_21)? (4.0 + x_19) : (5.0 + x_21))))? (((12.0 + x_0) > (12.0 + x_2)? (12.0 + x_0) : (12.0 + x_2)) > ((12.0 + x_4) > ((16.0 + x_7) > (11.0 + x_8)? (16.0 + x_7) : (11.0 + x_8))? (12.0 + x_4) : ((16.0 + x_7) > (11.0 + x_8)? (16.0 + x_7) : (11.0 + x_8)))? ((12.0 + x_0) > (12.0 + x_2)? (12.0 + x_0) : (12.0 + x_2)) : ((12.0 + x_4) > ((16.0 + x_7) > (11.0 + x_8)? (16.0 + x_7) : (11.0 + x_8))? (12.0 + x_4) : ((16.0 + x_7) > (11.0 + x_8)? (16.0 + x_7) : (11.0 + x_8)))) : (((6.0 + x_9) > (14.0 + x_10)? (6.0 + x_9) : (14.0 + x_10)) > ((4.0 + x_11) > ((4.0 + x_19) > (5.0 + x_21)? (4.0 + x_19) : (5.0 + x_21))? (4.0 + x_11) : ((4.0 + x_19) > (5.0 + x_21)? (4.0 + x_19) : (5.0 + x_21)))? ((6.0 + x_9) > (14.0 + x_10)? (6.0 + x_9) : (14.0 + x_10)) : ((4.0 + x_11) > ((4.0 + x_19) > (5.0 + x_21)? (4.0 + x_19) : (5.0 + x_21))? (4.0 + x_11) : ((4.0 + x_19) > (5.0 + x_21)? (4.0 + x_19) : (5.0 + x_21))))) > ((((2.0 + x_23) > (16.0 + x_24)? (2.0 + x_23) : (16.0 + x_24)) > ((9.0 + x_26) > ((4.0 + x_28) > (6.0 + x_30)? (4.0 + x_28) : (6.0 + x_30))? (9.0 + x_26) : ((4.0 + x_28) > (6.0 + x_30)? (4.0 + x_28) : (6.0 + x_30)))? ((2.0 + x_23) > (16.0 + x_24)? (2.0 + x_23) : (16.0 + x_24)) : ((9.0 + x_26) > ((4.0 + x_28) > (6.0 + x_30)? (4.0 + x_28) : (6.0 + x_30))? (9.0 + x_26) : ((4.0 + x_28) > (6.0 + x_30)? (4.0 + x_28) : (6.0 + x_30)))) > (((5.0 + x_31) > (10.0 + x_33)? (5.0 + x_31) : (10.0 + x_33)) > ((1.0 + x_35) > ((11.0 + x_38) > (20.0 + x_39)? (11.0 + x_38) : (20.0 + x_39))? (1.0 + x_35) : ((11.0 + x_38) > (20.0 + x_39)? (11.0 + x_38) : (20.0 + x_39)))? ((5.0 + x_31) > (10.0 + x_33)? (5.0 + x_31) : (10.0 + x_33)) : ((1.0 + x_35) > ((11.0 + x_38) > (20.0 + x_39)? (11.0 + x_38) : (20.0 + x_39))? (1.0 + x_35) : ((11.0 + x_38) > (20.0 + x_39)? (11.0 + x_38) : (20.0 + x_39))))? (((2.0 + x_23) > (16.0 + x_24)? (2.0 + x_23) : (16.0 + x_24)) > ((9.0 + x_26) > ((4.0 + x_28) > (6.0 + x_30)? (4.0 + x_28) : (6.0 + x_30))? (9.0 + x_26) : ((4.0 + x_28) > (6.0 + x_30)? (4.0 + x_28) : (6.0 + x_30)))? ((2.0 + x_23) > (16.0 + x_24)? (2.0 + x_23) : (16.0 + x_24)) : ((9.0 + x_26) > ((4.0 + x_28) > (6.0 + x_30)? (4.0 + x_28) : (6.0 + x_30))? (9.0 + x_26) : ((4.0 + x_28) > (6.0 + x_30)? (4.0 + x_28) : (6.0 + x_30)))) : (((5.0 + x_31) > (10.0 + x_33)? (5.0 + x_31) : (10.0 + x_33)) > ((1.0 + x_35) > ((11.0 + x_38) > (20.0 + x_39)? (11.0 + x_38) : (20.0 + x_39))? (1.0 + x_35) : ((11.0 + x_38) > (20.0 + x_39)? (11.0 + x_38) : (20.0 + x_39)))? ((5.0 + x_31) > (10.0 + x_33)? (5.0 + x_31) : (10.0 + x_33)) : ((1.0 + x_35) > ((11.0 + x_38) > (20.0 + x_39)? (11.0 + x_38) : (20.0 + x_39))? (1.0 + x_35) : ((11.0 + x_38) > (20.0 + x_39)? (11.0 + x_38) : (20.0 + x_39)))))? ((((12.0 + x_0) > (12.0 + x_2)? (12.0 + x_0) : (12.0 + x_2)) > ((12.0 + x_4) > ((16.0 + x_7) > (11.0 + x_8)? (16.0 + x_7) : (11.0 + x_8))? (12.0 + x_4) : ((16.0 + x_7) > (11.0 + x_8)? (16.0 + x_7) : (11.0 + x_8)))? ((12.0 + x_0) > (12.0 + x_2)? (12.0 + x_0) : (12.0 + x_2)) : ((12.0 + x_4) > ((16.0 + x_7) > (11.0 + x_8)? (16.0 + x_7) : (11.0 + x_8))? (12.0 + x_4) : ((16.0 + x_7) > (11.0 + x_8)? (16.0 + x_7) : (11.0 + x_8)))) > (((6.0 + x_9) > (14.0 + x_10)? (6.0 + x_9) : (14.0 + x_10)) > ((4.0 + x_11) > ((4.0 + x_19) > (5.0 + x_21)? (4.0 + x_19) : (5.0 + x_21))? (4.0 + x_11) : ((4.0 + x_19) > (5.0 + x_21)? (4.0 + x_19) : (5.0 + x_21)))? ((6.0 + x_9) > (14.0 + x_10)? (6.0 + x_9) : (14.0 + x_10)) : ((4.0 + x_11) > ((4.0 + x_19) > (5.0 + x_21)? (4.0 + x_19) : (5.0 + x_21))? (4.0 + x_11) : ((4.0 + x_19) > (5.0 + x_21)? (4.0 + x_19) : (5.0 + x_21))))? (((12.0 + x_0) > (12.0 + x_2)? (12.0 + x_0) : (12.0 + x_2)) > ((12.0 + x_4) > ((16.0 + x_7) > (11.0 + x_8)? (16.0 + x_7) : (11.0 + x_8))? (12.0 + x_4) : ((16.0 + x_7) > (11.0 + x_8)? (16.0 + x_7) : (11.0 + x_8)))? ((12.0 + x_0) > (12.0 + x_2)? (12.0 + x_0) : (12.0 + x_2)) : ((12.0 + x_4) > ((16.0 + x_7) > (11.0 + x_8)? (16.0 + x_7) : (11.0 + x_8))? (12.0 + x_4) : ((16.0 + x_7) > (11.0 + x_8)? (16.0 + x_7) : (11.0 + x_8)))) : (((6.0 + x_9) > (14.0 + x_10)? (6.0 + x_9) : (14.0 + x_10)) > ((4.0 + x_11) > ((4.0 + x_19) > (5.0 + x_21)? (4.0 + x_19) : (5.0 + x_21))? (4.0 + x_11) : ((4.0 + x_19) > (5.0 + x_21)? (4.0 + x_19) : (5.0 + x_21)))? ((6.0 + x_9) > (14.0 + x_10)? (6.0 + x_9) : (14.0 + x_10)) : ((4.0 + x_11) > ((4.0 + x_19) > (5.0 + x_21)? (4.0 + x_19) : (5.0 + x_21))? (4.0 + x_11) : ((4.0 + x_19) > (5.0 + x_21)? (4.0 + x_19) : (5.0 + x_21))))) : ((((2.0 + x_23) > (16.0 + x_24)? (2.0 + x_23) : (16.0 + x_24)) > ((9.0 + x_26) > ((4.0 + x_28) > (6.0 + x_30)? (4.0 + x_28) : (6.0 + x_30))? (9.0 + x_26) : ((4.0 + x_28) > (6.0 + x_30)? (4.0 + x_28) : (6.0 + x_30)))? ((2.0 + x_23) > (16.0 + x_24)? (2.0 + x_23) : (16.0 + x_24)) : ((9.0 + x_26) > ((4.0 + x_28) > (6.0 + x_30)? (4.0 + x_28) : (6.0 + x_30))? (9.0 + x_26) : ((4.0 + x_28) > (6.0 + x_30)? (4.0 + x_28) : (6.0 + x_30)))) > (((5.0 + x_31) > (10.0 + x_33)? (5.0 + x_31) : (10.0 + x_33)) > ((1.0 + x_35) > ((11.0 + x_38) > (20.0 + x_39)? (11.0 + x_38) : (20.0 + x_39))? (1.0 + x_35) : ((11.0 + x_38) > (20.0 + x_39)? (11.0 + x_38) : (20.0 + x_39)))? ((5.0 + x_31) > (10.0 + x_33)? (5.0 + x_31) : (10.0 + x_33)) : ((1.0 + x_35) > ((11.0 + x_38) > (20.0 + x_39)? (11.0 + x_38) : (20.0 + x_39))? (1.0 + x_35) : ((11.0 + x_38) > (20.0 + x_39)? (11.0 + x_38) : (20.0 + x_39))))? (((2.0 + x_23) > (16.0 + x_24)? (2.0 + x_23) : (16.0 + x_24)) > ((9.0 + x_26) > ((4.0 + x_28) > (6.0 + x_30)? (4.0 + x_28) : (6.0 + x_30))? (9.0 + x_26) : ((4.0 + x_28) > (6.0 + x_30)? (4.0 + x_28) : (6.0 + x_30)))? ((2.0 + x_23) > (16.0 + x_24)? (2.0 + x_23) : (16.0 + x_24)) : ((9.0 + x_26) > ((4.0 + x_28) > (6.0 + x_30)? (4.0 + x_28) : (6.0 + x_30))? (9.0 + x_26) : ((4.0 + x_28) > (6.0 + x_30)? (4.0 + x_28) : (6.0 + x_30)))) : (((5.0 + x_31) > (10.0 + x_33)? (5.0 + x_31) : (10.0 + x_33)) > ((1.0 + x_35) > ((11.0 + x_38) > (20.0 + x_39)? (11.0 + x_38) : (20.0 + x_39))? (1.0 + x_35) : ((11.0 + x_38) > (20.0 + x_39)? (11.0 + x_38) : (20.0 + x_39)))? ((5.0 + x_31) > (10.0 + x_33)? (5.0 + x_31) : (10.0 + x_33)) : ((1.0 + x_35) > ((11.0 + x_38) > (20.0 + x_39)? (11.0 + x_38) : (20.0 + x_39))? (1.0 + x_35) : ((11.0 + x_38) > (20.0 + x_39)? (11.0 + x_38) : (20.0 + x_39))))));
x_11_ = (((((8.0 + x_1) > (4.0 + x_3)? (8.0 + x_1) : (4.0 + x_3)) > ((15.0 + x_4) > ((12.0 + x_6) > (20.0 + x_8)? (12.0 + x_6) : (20.0 + x_8))? (15.0 + x_4) : ((12.0 + x_6) > (20.0 + x_8)? (12.0 + x_6) : (20.0 + x_8)))? ((8.0 + x_1) > (4.0 + x_3)? (8.0 + x_1) : (4.0 + x_3)) : ((15.0 + x_4) > ((12.0 + x_6) > (20.0 + x_8)? (12.0 + x_6) : (20.0 + x_8))? (15.0 + x_4) : ((12.0 + x_6) > (20.0 + x_8)? (12.0 + x_6) : (20.0 + x_8)))) > (((13.0 + x_9) > (12.0 + x_10)? (13.0 + x_9) : (12.0 + x_10)) > ((19.0 + x_11) > ((2.0 + x_12) > (4.0 + x_13)? (2.0 + x_12) : (4.0 + x_13))? (19.0 + x_11) : ((2.0 + x_12) > (4.0 + x_13)? (2.0 + x_12) : (4.0 + x_13)))? ((13.0 + x_9) > (12.0 + x_10)? (13.0 + x_9) : (12.0 + x_10)) : ((19.0 + x_11) > ((2.0 + x_12) > (4.0 + x_13)? (2.0 + x_12) : (4.0 + x_13))? (19.0 + x_11) : ((2.0 + x_12) > (4.0 + x_13)? (2.0 + x_12) : (4.0 + x_13))))? (((8.0 + x_1) > (4.0 + x_3)? (8.0 + x_1) : (4.0 + x_3)) > ((15.0 + x_4) > ((12.0 + x_6) > (20.0 + x_8)? (12.0 + x_6) : (20.0 + x_8))? (15.0 + x_4) : ((12.0 + x_6) > (20.0 + x_8)? (12.0 + x_6) : (20.0 + x_8)))? ((8.0 + x_1) > (4.0 + x_3)? (8.0 + x_1) : (4.0 + x_3)) : ((15.0 + x_4) > ((12.0 + x_6) > (20.0 + x_8)? (12.0 + x_6) : (20.0 + x_8))? (15.0 + x_4) : ((12.0 + x_6) > (20.0 + x_8)? (12.0 + x_6) : (20.0 + x_8)))) : (((13.0 + x_9) > (12.0 + x_10)? (13.0 + x_9) : (12.0 + x_10)) > ((19.0 + x_11) > ((2.0 + x_12) > (4.0 + x_13)? (2.0 + x_12) : (4.0 + x_13))? (19.0 + x_11) : ((2.0 + x_12) > (4.0 + x_13)? (2.0 + x_12) : (4.0 + x_13)))? ((13.0 + x_9) > (12.0 + x_10)? (13.0 + x_9) : (12.0 + x_10)) : ((19.0 + x_11) > ((2.0 + x_12) > (4.0 + x_13)? (2.0 + x_12) : (4.0 + x_13))? (19.0 + x_11) : ((2.0 + x_12) > (4.0 + x_13)? (2.0 + x_12) : (4.0 + x_13))))) > ((((13.0 + x_15) > (10.0 + x_18)? (13.0 + x_15) : (10.0 + x_18)) > ((8.0 + x_21) > ((1.0 + x_22) > (8.0 + x_23)? (1.0 + x_22) : (8.0 + x_23))? (8.0 + x_21) : ((1.0 + x_22) > (8.0 + x_23)? (1.0 + x_22) : (8.0 + x_23)))? ((13.0 + x_15) > (10.0 + x_18)? (13.0 + x_15) : (10.0 + x_18)) : ((8.0 + x_21) > ((1.0 + x_22) > (8.0 + x_23)? (1.0 + x_22) : (8.0 + x_23))? (8.0 + x_21) : ((1.0 + x_22) > (8.0 + x_23)? (1.0 + x_22) : (8.0 + x_23)))) > (((1.0 + x_25) > (5.0 + x_30)? (1.0 + x_25) : (5.0 + x_30)) > ((18.0 + x_34) > ((9.0 + x_38) > (3.0 + x_39)? (9.0 + x_38) : (3.0 + x_39))? (18.0 + x_34) : ((9.0 + x_38) > (3.0 + x_39)? (9.0 + x_38) : (3.0 + x_39)))? ((1.0 + x_25) > (5.0 + x_30)? (1.0 + x_25) : (5.0 + x_30)) : ((18.0 + x_34) > ((9.0 + x_38) > (3.0 + x_39)? (9.0 + x_38) : (3.0 + x_39))? (18.0 + x_34) : ((9.0 + x_38) > (3.0 + x_39)? (9.0 + x_38) : (3.0 + x_39))))? (((13.0 + x_15) > (10.0 + x_18)? (13.0 + x_15) : (10.0 + x_18)) > ((8.0 + x_21) > ((1.0 + x_22) > (8.0 + x_23)? (1.0 + x_22) : (8.0 + x_23))? (8.0 + x_21) : ((1.0 + x_22) > (8.0 + x_23)? (1.0 + x_22) : (8.0 + x_23)))? ((13.0 + x_15) > (10.0 + x_18)? (13.0 + x_15) : (10.0 + x_18)) : ((8.0 + x_21) > ((1.0 + x_22) > (8.0 + x_23)? (1.0 + x_22) : (8.0 + x_23))? (8.0 + x_21) : ((1.0 + x_22) > (8.0 + x_23)? (1.0 + x_22) : (8.0 + x_23)))) : (((1.0 + x_25) > (5.0 + x_30)? (1.0 + x_25) : (5.0 + x_30)) > ((18.0 + x_34) > ((9.0 + x_38) > (3.0 + x_39)? (9.0 + x_38) : (3.0 + x_39))? (18.0 + x_34) : ((9.0 + x_38) > (3.0 + x_39)? (9.0 + x_38) : (3.0 + x_39)))? ((1.0 + x_25) > (5.0 + x_30)? (1.0 + x_25) : (5.0 + x_30)) : ((18.0 + x_34) > ((9.0 + x_38) > (3.0 + x_39)? (9.0 + x_38) : (3.0 + x_39))? (18.0 + x_34) : ((9.0 + x_38) > (3.0 + x_39)? (9.0 + x_38) : (3.0 + x_39)))))? ((((8.0 + x_1) > (4.0 + x_3)? (8.0 + x_1) : (4.0 + x_3)) > ((15.0 + x_4) > ((12.0 + x_6) > (20.0 + x_8)? (12.0 + x_6) : (20.0 + x_8))? (15.0 + x_4) : ((12.0 + x_6) > (20.0 + x_8)? (12.0 + x_6) : (20.0 + x_8)))? ((8.0 + x_1) > (4.0 + x_3)? (8.0 + x_1) : (4.0 + x_3)) : ((15.0 + x_4) > ((12.0 + x_6) > (20.0 + x_8)? (12.0 + x_6) : (20.0 + x_8))? (15.0 + x_4) : ((12.0 + x_6) > (20.0 + x_8)? (12.0 + x_6) : (20.0 + x_8)))) > (((13.0 + x_9) > (12.0 + x_10)? (13.0 + x_9) : (12.0 + x_10)) > ((19.0 + x_11) > ((2.0 + x_12) > (4.0 + x_13)? (2.0 + x_12) : (4.0 + x_13))? (19.0 + x_11) : ((2.0 + x_12) > (4.0 + x_13)? (2.0 + x_12) : (4.0 + x_13)))? ((13.0 + x_9) > (12.0 + x_10)? (13.0 + x_9) : (12.0 + x_10)) : ((19.0 + x_11) > ((2.0 + x_12) > (4.0 + x_13)? (2.0 + x_12) : (4.0 + x_13))? (19.0 + x_11) : ((2.0 + x_12) > (4.0 + x_13)? (2.0 + x_12) : (4.0 + x_13))))? (((8.0 + x_1) > (4.0 + x_3)? (8.0 + x_1) : (4.0 + x_3)) > ((15.0 + x_4) > ((12.0 + x_6) > (20.0 + x_8)? (12.0 + x_6) : (20.0 + x_8))? (15.0 + x_4) : ((12.0 + x_6) > (20.0 + x_8)? (12.0 + x_6) : (20.0 + x_8)))? ((8.0 + x_1) > (4.0 + x_3)? (8.0 + x_1) : (4.0 + x_3)) : ((15.0 + x_4) > ((12.0 + x_6) > (20.0 + x_8)? (12.0 + x_6) : (20.0 + x_8))? (15.0 + x_4) : ((12.0 + x_6) > (20.0 + x_8)? (12.0 + x_6) : (20.0 + x_8)))) : (((13.0 + x_9) > (12.0 + x_10)? (13.0 + x_9) : (12.0 + x_10)) > ((19.0 + x_11) > ((2.0 + x_12) > (4.0 + x_13)? (2.0 + x_12) : (4.0 + x_13))? (19.0 + x_11) : ((2.0 + x_12) > (4.0 + x_13)? (2.0 + x_12) : (4.0 + x_13)))? ((13.0 + x_9) > (12.0 + x_10)? (13.0 + x_9) : (12.0 + x_10)) : ((19.0 + x_11) > ((2.0 + x_12) > (4.0 + x_13)? (2.0 + x_12) : (4.0 + x_13))? (19.0 + x_11) : ((2.0 + x_12) > (4.0 + x_13)? (2.0 + x_12) : (4.0 + x_13))))) : ((((13.0 + x_15) > (10.0 + x_18)? (13.0 + x_15) : (10.0 + x_18)) > ((8.0 + x_21) > ((1.0 + x_22) > (8.0 + x_23)? (1.0 + x_22) : (8.0 + x_23))? (8.0 + x_21) : ((1.0 + x_22) > (8.0 + x_23)? (1.0 + x_22) : (8.0 + x_23)))? ((13.0 + x_15) > (10.0 + x_18)? (13.0 + x_15) : (10.0 + x_18)) : ((8.0 + x_21) > ((1.0 + x_22) > (8.0 + x_23)? (1.0 + x_22) : (8.0 + x_23))? (8.0 + x_21) : ((1.0 + x_22) > (8.0 + x_23)? (1.0 + x_22) : (8.0 + x_23)))) > (((1.0 + x_25) > (5.0 + x_30)? (1.0 + x_25) : (5.0 + x_30)) > ((18.0 + x_34) > ((9.0 + x_38) > (3.0 + x_39)? (9.0 + x_38) : (3.0 + x_39))? (18.0 + x_34) : ((9.0 + x_38) > (3.0 + x_39)? (9.0 + x_38) : (3.0 + x_39)))? ((1.0 + x_25) > (5.0 + x_30)? (1.0 + x_25) : (5.0 + x_30)) : ((18.0 + x_34) > ((9.0 + x_38) > (3.0 + x_39)? (9.0 + x_38) : (3.0 + x_39))? (18.0 + x_34) : ((9.0 + x_38) > (3.0 + x_39)? (9.0 + x_38) : (3.0 + x_39))))? (((13.0 + x_15) > (10.0 + x_18)? (13.0 + x_15) : (10.0 + x_18)) > ((8.0 + x_21) > ((1.0 + x_22) > (8.0 + x_23)? (1.0 + x_22) : (8.0 + x_23))? (8.0 + x_21) : ((1.0 + x_22) > (8.0 + x_23)? (1.0 + x_22) : (8.0 + x_23)))? ((13.0 + x_15) > (10.0 + x_18)? (13.0 + x_15) : (10.0 + x_18)) : ((8.0 + x_21) > ((1.0 + x_22) > (8.0 + x_23)? (1.0 + x_22) : (8.0 + x_23))? (8.0 + x_21) : ((1.0 + x_22) > (8.0 + x_23)? (1.0 + x_22) : (8.0 + x_23)))) : (((1.0 + x_25) > (5.0 + x_30)? (1.0 + x_25) : (5.0 + x_30)) > ((18.0 + x_34) > ((9.0 + x_38) > (3.0 + x_39)? (9.0 + x_38) : (3.0 + x_39))? (18.0 + x_34) : ((9.0 + x_38) > (3.0 + x_39)? (9.0 + x_38) : (3.0 + x_39)))? ((1.0 + x_25) > (5.0 + x_30)? (1.0 + x_25) : (5.0 + x_30)) : ((18.0 + x_34) > ((9.0 + x_38) > (3.0 + x_39)? (9.0 + x_38) : (3.0 + x_39))? (18.0 + x_34) : ((9.0 + x_38) > (3.0 + x_39)? (9.0 + x_38) : (3.0 + x_39))))));
x_12_ = (((((13.0 + x_0) > (11.0 + x_1)? (13.0 + x_0) : (11.0 + x_1)) > ((15.0 + x_2) > ((14.0 + x_6) > (18.0 + x_8)? (14.0 + x_6) : (18.0 + x_8))? (15.0 + x_2) : ((14.0 + x_6) > (18.0 + x_8)? (14.0 + x_6) : (18.0 + x_8)))? ((13.0 + x_0) > (11.0 + x_1)? (13.0 + x_0) : (11.0 + x_1)) : ((15.0 + x_2) > ((14.0 + x_6) > (18.0 + x_8)? (14.0 + x_6) : (18.0 + x_8))? (15.0 + x_2) : ((14.0 + x_6) > (18.0 + x_8)? (14.0 + x_6) : (18.0 + x_8)))) > (((15.0 + x_11) > (2.0 + x_12)? (15.0 + x_11) : (2.0 + x_12)) > ((17.0 + x_16) > ((20.0 + x_19) > (1.0 + x_20)? (20.0 + x_19) : (1.0 + x_20))? (17.0 + x_16) : ((20.0 + x_19) > (1.0 + x_20)? (20.0 + x_19) : (1.0 + x_20)))? ((15.0 + x_11) > (2.0 + x_12)? (15.0 + x_11) : (2.0 + x_12)) : ((17.0 + x_16) > ((20.0 + x_19) > (1.0 + x_20)? (20.0 + x_19) : (1.0 + x_20))? (17.0 + x_16) : ((20.0 + x_19) > (1.0 + x_20)? (20.0 + x_19) : (1.0 + x_20))))? (((13.0 + x_0) > (11.0 + x_1)? (13.0 + x_0) : (11.0 + x_1)) > ((15.0 + x_2) > ((14.0 + x_6) > (18.0 + x_8)? (14.0 + x_6) : (18.0 + x_8))? (15.0 + x_2) : ((14.0 + x_6) > (18.0 + x_8)? (14.0 + x_6) : (18.0 + x_8)))? ((13.0 + x_0) > (11.0 + x_1)? (13.0 + x_0) : (11.0 + x_1)) : ((15.0 + x_2) > ((14.0 + x_6) > (18.0 + x_8)? (14.0 + x_6) : (18.0 + x_8))? (15.0 + x_2) : ((14.0 + x_6) > (18.0 + x_8)? (14.0 + x_6) : (18.0 + x_8)))) : (((15.0 + x_11) > (2.0 + x_12)? (15.0 + x_11) : (2.0 + x_12)) > ((17.0 + x_16) > ((20.0 + x_19) > (1.0 + x_20)? (20.0 + x_19) : (1.0 + x_20))? (17.0 + x_16) : ((20.0 + x_19) > (1.0 + x_20)? (20.0 + x_19) : (1.0 + x_20)))? ((15.0 + x_11) > (2.0 + x_12)? (15.0 + x_11) : (2.0 + x_12)) : ((17.0 + x_16) > ((20.0 + x_19) > (1.0 + x_20)? (20.0 + x_19) : (1.0 + x_20))? (17.0 + x_16) : ((20.0 + x_19) > (1.0 + x_20)? (20.0 + x_19) : (1.0 + x_20))))) > ((((14.0 + x_21) > (13.0 + x_24)? (14.0 + x_21) : (13.0 + x_24)) > ((9.0 + x_26) > ((7.0 + x_29) > (9.0 + x_32)? (7.0 + x_29) : (9.0 + x_32))? (9.0 + x_26) : ((7.0 + x_29) > (9.0 + x_32)? (7.0 + x_29) : (9.0 + x_32)))? ((14.0 + x_21) > (13.0 + x_24)? (14.0 + x_21) : (13.0 + x_24)) : ((9.0 + x_26) > ((7.0 + x_29) > (9.0 + x_32)? (7.0 + x_29) : (9.0 + x_32))? (9.0 + x_26) : ((7.0 + x_29) > (9.0 + x_32)? (7.0 + x_29) : (9.0 + x_32)))) > (((9.0 + x_34) > (7.0 + x_35)? (9.0 + x_34) : (7.0 + x_35)) > ((17.0 + x_36) > ((5.0 + x_37) > (14.0 + x_39)? (5.0 + x_37) : (14.0 + x_39))? (17.0 + x_36) : ((5.0 + x_37) > (14.0 + x_39)? (5.0 + x_37) : (14.0 + x_39)))? ((9.0 + x_34) > (7.0 + x_35)? (9.0 + x_34) : (7.0 + x_35)) : ((17.0 + x_36) > ((5.0 + x_37) > (14.0 + x_39)? (5.0 + x_37) : (14.0 + x_39))? (17.0 + x_36) : ((5.0 + x_37) > (14.0 + x_39)? (5.0 + x_37) : (14.0 + x_39))))? (((14.0 + x_21) > (13.0 + x_24)? (14.0 + x_21) : (13.0 + x_24)) > ((9.0 + x_26) > ((7.0 + x_29) > (9.0 + x_32)? (7.0 + x_29) : (9.0 + x_32))? (9.0 + x_26) : ((7.0 + x_29) > (9.0 + x_32)? (7.0 + x_29) : (9.0 + x_32)))? ((14.0 + x_21) > (13.0 + x_24)? (14.0 + x_21) : (13.0 + x_24)) : ((9.0 + x_26) > ((7.0 + x_29) > (9.0 + x_32)? (7.0 + x_29) : (9.0 + x_32))? (9.0 + x_26) : ((7.0 + x_29) > (9.0 + x_32)? (7.0 + x_29) : (9.0 + x_32)))) : (((9.0 + x_34) > (7.0 + x_35)? (9.0 + x_34) : (7.0 + x_35)) > ((17.0 + x_36) > ((5.0 + x_37) > (14.0 + x_39)? (5.0 + x_37) : (14.0 + x_39))? (17.0 + x_36) : ((5.0 + x_37) > (14.0 + x_39)? (5.0 + x_37) : (14.0 + x_39)))? ((9.0 + x_34) > (7.0 + x_35)? (9.0 + x_34) : (7.0 + x_35)) : ((17.0 + x_36) > ((5.0 + x_37) > (14.0 + x_39)? (5.0 + x_37) : (14.0 + x_39))? (17.0 + x_36) : ((5.0 + x_37) > (14.0 + x_39)? (5.0 + x_37) : (14.0 + x_39)))))? ((((13.0 + x_0) > (11.0 + x_1)? (13.0 + x_0) : (11.0 + x_1)) > ((15.0 + x_2) > ((14.0 + x_6) > (18.0 + x_8)? (14.0 + x_6) : (18.0 + x_8))? (15.0 + x_2) : ((14.0 + x_6) > (18.0 + x_8)? (14.0 + x_6) : (18.0 + x_8)))? ((13.0 + x_0) > (11.0 + x_1)? (13.0 + x_0) : (11.0 + x_1)) : ((15.0 + x_2) > ((14.0 + x_6) > (18.0 + x_8)? (14.0 + x_6) : (18.0 + x_8))? (15.0 + x_2) : ((14.0 + x_6) > (18.0 + x_8)? (14.0 + x_6) : (18.0 + x_8)))) > (((15.0 + x_11) > (2.0 + x_12)? (15.0 + x_11) : (2.0 + x_12)) > ((17.0 + x_16) > ((20.0 + x_19) > (1.0 + x_20)? (20.0 + x_19) : (1.0 + x_20))? (17.0 + x_16) : ((20.0 + x_19) > (1.0 + x_20)? (20.0 + x_19) : (1.0 + x_20)))? ((15.0 + x_11) > (2.0 + x_12)? (15.0 + x_11) : (2.0 + x_12)) : ((17.0 + x_16) > ((20.0 + x_19) > (1.0 + x_20)? (20.0 + x_19) : (1.0 + x_20))? (17.0 + x_16) : ((20.0 + x_19) > (1.0 + x_20)? (20.0 + x_19) : (1.0 + x_20))))? (((13.0 + x_0) > (11.0 + x_1)? (13.0 + x_0) : (11.0 + x_1)) > ((15.0 + x_2) > ((14.0 + x_6) > (18.0 + x_8)? (14.0 + x_6) : (18.0 + x_8))? (15.0 + x_2) : ((14.0 + x_6) > (18.0 + x_8)? (14.0 + x_6) : (18.0 + x_8)))? ((13.0 + x_0) > (11.0 + x_1)? (13.0 + x_0) : (11.0 + x_1)) : ((15.0 + x_2) > ((14.0 + x_6) > (18.0 + x_8)? (14.0 + x_6) : (18.0 + x_8))? (15.0 + x_2) : ((14.0 + x_6) > (18.0 + x_8)? (14.0 + x_6) : (18.0 + x_8)))) : (((15.0 + x_11) > (2.0 + x_12)? (15.0 + x_11) : (2.0 + x_12)) > ((17.0 + x_16) > ((20.0 + x_19) > (1.0 + x_20)? (20.0 + x_19) : (1.0 + x_20))? (17.0 + x_16) : ((20.0 + x_19) > (1.0 + x_20)? (20.0 + x_19) : (1.0 + x_20)))? ((15.0 + x_11) > (2.0 + x_12)? (15.0 + x_11) : (2.0 + x_12)) : ((17.0 + x_16) > ((20.0 + x_19) > (1.0 + x_20)? (20.0 + x_19) : (1.0 + x_20))? (17.0 + x_16) : ((20.0 + x_19) > (1.0 + x_20)? (20.0 + x_19) : (1.0 + x_20))))) : ((((14.0 + x_21) > (13.0 + x_24)? (14.0 + x_21) : (13.0 + x_24)) > ((9.0 + x_26) > ((7.0 + x_29) > (9.0 + x_32)? (7.0 + x_29) : (9.0 + x_32))? (9.0 + x_26) : ((7.0 + x_29) > (9.0 + x_32)? (7.0 + x_29) : (9.0 + x_32)))? ((14.0 + x_21) > (13.0 + x_24)? (14.0 + x_21) : (13.0 + x_24)) : ((9.0 + x_26) > ((7.0 + x_29) > (9.0 + x_32)? (7.0 + x_29) : (9.0 + x_32))? (9.0 + x_26) : ((7.0 + x_29) > (9.0 + x_32)? (7.0 + x_29) : (9.0 + x_32)))) > (((9.0 + x_34) > (7.0 + x_35)? (9.0 + x_34) : (7.0 + x_35)) > ((17.0 + x_36) > ((5.0 + x_37) > (14.0 + x_39)? (5.0 + x_37) : (14.0 + x_39))? (17.0 + x_36) : ((5.0 + x_37) > (14.0 + x_39)? (5.0 + x_37) : (14.0 + x_39)))? ((9.0 + x_34) > (7.0 + x_35)? (9.0 + x_34) : (7.0 + x_35)) : ((17.0 + x_36) > ((5.0 + x_37) > (14.0 + x_39)? (5.0 + x_37) : (14.0 + x_39))? (17.0 + x_36) : ((5.0 + x_37) > (14.0 + x_39)? (5.0 + x_37) : (14.0 + x_39))))? (((14.0 + x_21) > (13.0 + x_24)? (14.0 + x_21) : (13.0 + x_24)) > ((9.0 + x_26) > ((7.0 + x_29) > (9.0 + x_32)? (7.0 + x_29) : (9.0 + x_32))? (9.0 + x_26) : ((7.0 + x_29) > (9.0 + x_32)? (7.0 + x_29) : (9.0 + x_32)))? ((14.0 + x_21) > (13.0 + x_24)? (14.0 + x_21) : (13.0 + x_24)) : ((9.0 + x_26) > ((7.0 + x_29) > (9.0 + x_32)? (7.0 + x_29) : (9.0 + x_32))? (9.0 + x_26) : ((7.0 + x_29) > (9.0 + x_32)? (7.0 + x_29) : (9.0 + x_32)))) : (((9.0 + x_34) > (7.0 + x_35)? (9.0 + x_34) : (7.0 + x_35)) > ((17.0 + x_36) > ((5.0 + x_37) > (14.0 + x_39)? (5.0 + x_37) : (14.0 + x_39))? (17.0 + x_36) : ((5.0 + x_37) > (14.0 + x_39)? (5.0 + x_37) : (14.0 + x_39)))? ((9.0 + x_34) > (7.0 + x_35)? (9.0 + x_34) : (7.0 + x_35)) : ((17.0 + x_36) > ((5.0 + x_37) > (14.0 + x_39)? (5.0 + x_37) : (14.0 + x_39))? (17.0 + x_36) : ((5.0 + x_37) > (14.0 + x_39)? (5.0 + x_37) : (14.0 + x_39))))));
x_13_ = (((((6.0 + x_1) > (8.0 + x_3)? (6.0 + x_1) : (8.0 + x_3)) > ((13.0 + x_4) > ((12.0 + x_7) > (14.0 + x_8)? (12.0 + x_7) : (14.0 + x_8))? (13.0 + x_4) : ((12.0 + x_7) > (14.0 + x_8)? (12.0 + x_7) : (14.0 + x_8)))? ((6.0 + x_1) > (8.0 + x_3)? (6.0 + x_1) : (8.0 + x_3)) : ((13.0 + x_4) > ((12.0 + x_7) > (14.0 + x_8)? (12.0 + x_7) : (14.0 + x_8))? (13.0 + x_4) : ((12.0 + x_7) > (14.0 + x_8)? (12.0 + x_7) : (14.0 + x_8)))) > (((17.0 + x_9) > (13.0 + x_14)? (17.0 + x_9) : (13.0 + x_14)) > ((2.0 + x_17) > ((3.0 + x_18) > (6.0 + x_19)? (3.0 + x_18) : (6.0 + x_19))? (2.0 + x_17) : ((3.0 + x_18) > (6.0 + x_19)? (3.0 + x_18) : (6.0 + x_19)))? ((17.0 + x_9) > (13.0 + x_14)? (17.0 + x_9) : (13.0 + x_14)) : ((2.0 + x_17) > ((3.0 + x_18) > (6.0 + x_19)? (3.0 + x_18) : (6.0 + x_19))? (2.0 + x_17) : ((3.0 + x_18) > (6.0 + x_19)? (3.0 + x_18) : (6.0 + x_19))))? (((6.0 + x_1) > (8.0 + x_3)? (6.0 + x_1) : (8.0 + x_3)) > ((13.0 + x_4) > ((12.0 + x_7) > (14.0 + x_8)? (12.0 + x_7) : (14.0 + x_8))? (13.0 + x_4) : ((12.0 + x_7) > (14.0 + x_8)? (12.0 + x_7) : (14.0 + x_8)))? ((6.0 + x_1) > (8.0 + x_3)? (6.0 + x_1) : (8.0 + x_3)) : ((13.0 + x_4) > ((12.0 + x_7) > (14.0 + x_8)? (12.0 + x_7) : (14.0 + x_8))? (13.0 + x_4) : ((12.0 + x_7) > (14.0 + x_8)? (12.0 + x_7) : (14.0 + x_8)))) : (((17.0 + x_9) > (13.0 + x_14)? (17.0 + x_9) : (13.0 + x_14)) > ((2.0 + x_17) > ((3.0 + x_18) > (6.0 + x_19)? (3.0 + x_18) : (6.0 + x_19))? (2.0 + x_17) : ((3.0 + x_18) > (6.0 + x_19)? (3.0 + x_18) : (6.0 + x_19)))? ((17.0 + x_9) > (13.0 + x_14)? (17.0 + x_9) : (13.0 + x_14)) : ((2.0 + x_17) > ((3.0 + x_18) > (6.0 + x_19)? (3.0 + x_18) : (6.0 + x_19))? (2.0 + x_17) : ((3.0 + x_18) > (6.0 + x_19)? (3.0 + x_18) : (6.0 + x_19))))) > ((((13.0 + x_20) > (12.0 + x_22)? (13.0 + x_20) : (12.0 + x_22)) > ((10.0 + x_24) > ((17.0 + x_25) > (19.0 + x_26)? (17.0 + x_25) : (19.0 + x_26))? (10.0 + x_24) : ((17.0 + x_25) > (19.0 + x_26)? (17.0 + x_25) : (19.0 + x_26)))? ((13.0 + x_20) > (12.0 + x_22)? (13.0 + x_20) : (12.0 + x_22)) : ((10.0 + x_24) > ((17.0 + x_25) > (19.0 + x_26)? (17.0 + x_25) : (19.0 + x_26))? (10.0 + x_24) : ((17.0 + x_25) > (19.0 + x_26)? (17.0 + x_25) : (19.0 + x_26)))) > (((20.0 + x_29) > (17.0 + x_31)? (20.0 + x_29) : (17.0 + x_31)) > ((11.0 + x_33) > ((1.0 + x_35) > (5.0 + x_39)? (1.0 + x_35) : (5.0 + x_39))? (11.0 + x_33) : ((1.0 + x_35) > (5.0 + x_39)? (1.0 + x_35) : (5.0 + x_39)))? ((20.0 + x_29) > (17.0 + x_31)? (20.0 + x_29) : (17.0 + x_31)) : ((11.0 + x_33) > ((1.0 + x_35) > (5.0 + x_39)? (1.0 + x_35) : (5.0 + x_39))? (11.0 + x_33) : ((1.0 + x_35) > (5.0 + x_39)? (1.0 + x_35) : (5.0 + x_39))))? (((13.0 + x_20) > (12.0 + x_22)? (13.0 + x_20) : (12.0 + x_22)) > ((10.0 + x_24) > ((17.0 + x_25) > (19.0 + x_26)? (17.0 + x_25) : (19.0 + x_26))? (10.0 + x_24) : ((17.0 + x_25) > (19.0 + x_26)? (17.0 + x_25) : (19.0 + x_26)))? ((13.0 + x_20) > (12.0 + x_22)? (13.0 + x_20) : (12.0 + x_22)) : ((10.0 + x_24) > ((17.0 + x_25) > (19.0 + x_26)? (17.0 + x_25) : (19.0 + x_26))? (10.0 + x_24) : ((17.0 + x_25) > (19.0 + x_26)? (17.0 + x_25) : (19.0 + x_26)))) : (((20.0 + x_29) > (17.0 + x_31)? (20.0 + x_29) : (17.0 + x_31)) > ((11.0 + x_33) > ((1.0 + x_35) > (5.0 + x_39)? (1.0 + x_35) : (5.0 + x_39))? (11.0 + x_33) : ((1.0 + x_35) > (5.0 + x_39)? (1.0 + x_35) : (5.0 + x_39)))? ((20.0 + x_29) > (17.0 + x_31)? (20.0 + x_29) : (17.0 + x_31)) : ((11.0 + x_33) > ((1.0 + x_35) > (5.0 + x_39)? (1.0 + x_35) : (5.0 + x_39))? (11.0 + x_33) : ((1.0 + x_35) > (5.0 + x_39)? (1.0 + x_35) : (5.0 + x_39)))))? ((((6.0 + x_1) > (8.0 + x_3)? (6.0 + x_1) : (8.0 + x_3)) > ((13.0 + x_4) > ((12.0 + x_7) > (14.0 + x_8)? (12.0 + x_7) : (14.0 + x_8))? (13.0 + x_4) : ((12.0 + x_7) > (14.0 + x_8)? (12.0 + x_7) : (14.0 + x_8)))? ((6.0 + x_1) > (8.0 + x_3)? (6.0 + x_1) : (8.0 + x_3)) : ((13.0 + x_4) > ((12.0 + x_7) > (14.0 + x_8)? (12.0 + x_7) : (14.0 + x_8))? (13.0 + x_4) : ((12.0 + x_7) > (14.0 + x_8)? (12.0 + x_7) : (14.0 + x_8)))) > (((17.0 + x_9) > (13.0 + x_14)? (17.0 + x_9) : (13.0 + x_14)) > ((2.0 + x_17) > ((3.0 + x_18) > (6.0 + x_19)? (3.0 + x_18) : (6.0 + x_19))? (2.0 + x_17) : ((3.0 + x_18) > (6.0 + x_19)? (3.0 + x_18) : (6.0 + x_19)))? ((17.0 + x_9) > (13.0 + x_14)? (17.0 + x_9) : (13.0 + x_14)) : ((2.0 + x_17) > ((3.0 + x_18) > (6.0 + x_19)? (3.0 + x_18) : (6.0 + x_19))? (2.0 + x_17) : ((3.0 + x_18) > (6.0 + x_19)? (3.0 + x_18) : (6.0 + x_19))))? (((6.0 + x_1) > (8.0 + x_3)? (6.0 + x_1) : (8.0 + x_3)) > ((13.0 + x_4) > ((12.0 + x_7) > (14.0 + x_8)? (12.0 + x_7) : (14.0 + x_8))? (13.0 + x_4) : ((12.0 + x_7) > (14.0 + x_8)? (12.0 + x_7) : (14.0 + x_8)))? ((6.0 + x_1) > (8.0 + x_3)? (6.0 + x_1) : (8.0 + x_3)) : ((13.0 + x_4) > ((12.0 + x_7) > (14.0 + x_8)? (12.0 + x_7) : (14.0 + x_8))? (13.0 + x_4) : ((12.0 + x_7) > (14.0 + x_8)? (12.0 + x_7) : (14.0 + x_8)))) : (((17.0 + x_9) > (13.0 + x_14)? (17.0 + x_9) : (13.0 + x_14)) > ((2.0 + x_17) > ((3.0 + x_18) > (6.0 + x_19)? (3.0 + x_18) : (6.0 + x_19))? (2.0 + x_17) : ((3.0 + x_18) > (6.0 + x_19)? (3.0 + x_18) : (6.0 + x_19)))? ((17.0 + x_9) > (13.0 + x_14)? (17.0 + x_9) : (13.0 + x_14)) : ((2.0 + x_17) > ((3.0 + x_18) > (6.0 + x_19)? (3.0 + x_18) : (6.0 + x_19))? (2.0 + x_17) : ((3.0 + x_18) > (6.0 + x_19)? (3.0 + x_18) : (6.0 + x_19))))) : ((((13.0 + x_20) > (12.0 + x_22)? (13.0 + x_20) : (12.0 + x_22)) > ((10.0 + x_24) > ((17.0 + x_25) > (19.0 + x_26)? (17.0 + x_25) : (19.0 + x_26))? (10.0 + x_24) : ((17.0 + x_25) > (19.0 + x_26)? (17.0 + x_25) : (19.0 + x_26)))? ((13.0 + x_20) > (12.0 + x_22)? (13.0 + x_20) : (12.0 + x_22)) : ((10.0 + x_24) > ((17.0 + x_25) > (19.0 + x_26)? (17.0 + x_25) : (19.0 + x_26))? (10.0 + x_24) : ((17.0 + x_25) > (19.0 + x_26)? (17.0 + x_25) : (19.0 + x_26)))) > (((20.0 + x_29) > (17.0 + x_31)? (20.0 + x_29) : (17.0 + x_31)) > ((11.0 + x_33) > ((1.0 + x_35) > (5.0 + x_39)? (1.0 + x_35) : (5.0 + x_39))? (11.0 + x_33) : ((1.0 + x_35) > (5.0 + x_39)? (1.0 + x_35) : (5.0 + x_39)))? ((20.0 + x_29) > (17.0 + x_31)? (20.0 + x_29) : (17.0 + x_31)) : ((11.0 + x_33) > ((1.0 + x_35) > (5.0 + x_39)? (1.0 + x_35) : (5.0 + x_39))? (11.0 + x_33) : ((1.0 + x_35) > (5.0 + x_39)? (1.0 + x_35) : (5.0 + x_39))))? (((13.0 + x_20) > (12.0 + x_22)? (13.0 + x_20) : (12.0 + x_22)) > ((10.0 + x_24) > ((17.0 + x_25) > (19.0 + x_26)? (17.0 + x_25) : (19.0 + x_26))? (10.0 + x_24) : ((17.0 + x_25) > (19.0 + x_26)? (17.0 + x_25) : (19.0 + x_26)))? ((13.0 + x_20) > (12.0 + x_22)? (13.0 + x_20) : (12.0 + x_22)) : ((10.0 + x_24) > ((17.0 + x_25) > (19.0 + x_26)? (17.0 + x_25) : (19.0 + x_26))? (10.0 + x_24) : ((17.0 + x_25) > (19.0 + x_26)? (17.0 + x_25) : (19.0 + x_26)))) : (((20.0 + x_29) > (17.0 + x_31)? (20.0 + x_29) : (17.0 + x_31)) > ((11.0 + x_33) > ((1.0 + x_35) > (5.0 + x_39)? (1.0 + x_35) : (5.0 + x_39))? (11.0 + x_33) : ((1.0 + x_35) > (5.0 + x_39)? (1.0 + x_35) : (5.0 + x_39)))? ((20.0 + x_29) > (17.0 + x_31)? (20.0 + x_29) : (17.0 + x_31)) : ((11.0 + x_33) > ((1.0 + x_35) > (5.0 + x_39)? (1.0 + x_35) : (5.0 + x_39))? (11.0 + x_33) : ((1.0 + x_35) > (5.0 + x_39)? (1.0 + x_35) : (5.0 + x_39))))));
x_14_ = (((((8.0 + x_2) > (11.0 + x_4)? (8.0 + x_2) : (11.0 + x_4)) > ((4.0 + x_5) > ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8))? (4.0 + x_5) : ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8)))? ((8.0 + x_2) > (11.0 + x_4)? (8.0 + x_2) : (11.0 + x_4)) : ((4.0 + x_5) > ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8))? (4.0 + x_5) : ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8)))) > (((5.0 + x_9) > (1.0 + x_10)? (5.0 + x_9) : (1.0 + x_10)) > ((11.0 + x_11) > ((15.0 + x_13) > (2.0 + x_14)? (15.0 + x_13) : (2.0 + x_14))? (11.0 + x_11) : ((15.0 + x_13) > (2.0 + x_14)? (15.0 + x_13) : (2.0 + x_14)))? ((5.0 + x_9) > (1.0 + x_10)? (5.0 + x_9) : (1.0 + x_10)) : ((11.0 + x_11) > ((15.0 + x_13) > (2.0 + x_14)? (15.0 + x_13) : (2.0 + x_14))? (11.0 + x_11) : ((15.0 + x_13) > (2.0 + x_14)? (15.0 + x_13) : (2.0 + x_14))))? (((8.0 + x_2) > (11.0 + x_4)? (8.0 + x_2) : (11.0 + x_4)) > ((4.0 + x_5) > ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8))? (4.0 + x_5) : ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8)))? ((8.0 + x_2) > (11.0 + x_4)? (8.0 + x_2) : (11.0 + x_4)) : ((4.0 + x_5) > ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8))? (4.0 + x_5) : ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8)))) : (((5.0 + x_9) > (1.0 + x_10)? (5.0 + x_9) : (1.0 + x_10)) > ((11.0 + x_11) > ((15.0 + x_13) > (2.0 + x_14)? (15.0 + x_13) : (2.0 + x_14))? (11.0 + x_11) : ((15.0 + x_13) > (2.0 + x_14)? (15.0 + x_13) : (2.0 + x_14)))? ((5.0 + x_9) > (1.0 + x_10)? (5.0 + x_9) : (1.0 + x_10)) : ((11.0 + x_11) > ((15.0 + x_13) > (2.0 + x_14)? (15.0 + x_13) : (2.0 + x_14))? (11.0 + x_11) : ((15.0 + x_13) > (2.0 + x_14)? (15.0 + x_13) : (2.0 + x_14))))) > ((((17.0 + x_17) > (1.0 + x_20)? (17.0 + x_17) : (1.0 + x_20)) > ((14.0 + x_22) > ((8.0 + x_23) > (10.0 + x_24)? (8.0 + x_23) : (10.0 + x_24))? (14.0 + x_22) : ((8.0 + x_23) > (10.0 + x_24)? (8.0 + x_23) : (10.0 + x_24)))? ((17.0 + x_17) > (1.0 + x_20)? (17.0 + x_17) : (1.0 + x_20)) : ((14.0 + x_22) > ((8.0 + x_23) > (10.0 + x_24)? (8.0 + x_23) : (10.0 + x_24))? (14.0 + x_22) : ((8.0 + x_23) > (10.0 + x_24)? (8.0 + x_23) : (10.0 + x_24)))) > (((17.0 + x_27) > (10.0 + x_28)? (17.0 + x_27) : (10.0 + x_28)) > ((10.0 + x_31) > ((13.0 + x_32) > (13.0 + x_39)? (13.0 + x_32) : (13.0 + x_39))? (10.0 + x_31) : ((13.0 + x_32) > (13.0 + x_39)? (13.0 + x_32) : (13.0 + x_39)))? ((17.0 + x_27) > (10.0 + x_28)? (17.0 + x_27) : (10.0 + x_28)) : ((10.0 + x_31) > ((13.0 + x_32) > (13.0 + x_39)? (13.0 + x_32) : (13.0 + x_39))? (10.0 + x_31) : ((13.0 + x_32) > (13.0 + x_39)? (13.0 + x_32) : (13.0 + x_39))))? (((17.0 + x_17) > (1.0 + x_20)? (17.0 + x_17) : (1.0 + x_20)) > ((14.0 + x_22) > ((8.0 + x_23) > (10.0 + x_24)? (8.0 + x_23) : (10.0 + x_24))? (14.0 + x_22) : ((8.0 + x_23) > (10.0 + x_24)? (8.0 + x_23) : (10.0 + x_24)))? ((17.0 + x_17) > (1.0 + x_20)? (17.0 + x_17) : (1.0 + x_20)) : ((14.0 + x_22) > ((8.0 + x_23) > (10.0 + x_24)? (8.0 + x_23) : (10.0 + x_24))? (14.0 + x_22) : ((8.0 + x_23) > (10.0 + x_24)? (8.0 + x_23) : (10.0 + x_24)))) : (((17.0 + x_27) > (10.0 + x_28)? (17.0 + x_27) : (10.0 + x_28)) > ((10.0 + x_31) > ((13.0 + x_32) > (13.0 + x_39)? (13.0 + x_32) : (13.0 + x_39))? (10.0 + x_31) : ((13.0 + x_32) > (13.0 + x_39)? (13.0 + x_32) : (13.0 + x_39)))? ((17.0 + x_27) > (10.0 + x_28)? (17.0 + x_27) : (10.0 + x_28)) : ((10.0 + x_31) > ((13.0 + x_32) > (13.0 + x_39)? (13.0 + x_32) : (13.0 + x_39))? (10.0 + x_31) : ((13.0 + x_32) > (13.0 + x_39)? (13.0 + x_32) : (13.0 + x_39)))))? ((((8.0 + x_2) > (11.0 + x_4)? (8.0 + x_2) : (11.0 + x_4)) > ((4.0 + x_5) > ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8))? (4.0 + x_5) : ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8)))? ((8.0 + x_2) > (11.0 + x_4)? (8.0 + x_2) : (11.0 + x_4)) : ((4.0 + x_5) > ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8))? (4.0 + x_5) : ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8)))) > (((5.0 + x_9) > (1.0 + x_10)? (5.0 + x_9) : (1.0 + x_10)) > ((11.0 + x_11) > ((15.0 + x_13) > (2.0 + x_14)? (15.0 + x_13) : (2.0 + x_14))? (11.0 + x_11) : ((15.0 + x_13) > (2.0 + x_14)? (15.0 + x_13) : (2.0 + x_14)))? ((5.0 + x_9) > (1.0 + x_10)? (5.0 + x_9) : (1.0 + x_10)) : ((11.0 + x_11) > ((15.0 + x_13) > (2.0 + x_14)? (15.0 + x_13) : (2.0 + x_14))? (11.0 + x_11) : ((15.0 + x_13) > (2.0 + x_14)? (15.0 + x_13) : (2.0 + x_14))))? (((8.0 + x_2) > (11.0 + x_4)? (8.0 + x_2) : (11.0 + x_4)) > ((4.0 + x_5) > ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8))? (4.0 + x_5) : ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8)))? ((8.0 + x_2) > (11.0 + x_4)? (8.0 + x_2) : (11.0 + x_4)) : ((4.0 + x_5) > ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8))? (4.0 + x_5) : ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8)))) : (((5.0 + x_9) > (1.0 + x_10)? (5.0 + x_9) : (1.0 + x_10)) > ((11.0 + x_11) > ((15.0 + x_13) > (2.0 + x_14)? (15.0 + x_13) : (2.0 + x_14))? (11.0 + x_11) : ((15.0 + x_13) > (2.0 + x_14)? (15.0 + x_13) : (2.0 + x_14)))? ((5.0 + x_9) > (1.0 + x_10)? (5.0 + x_9) : (1.0 + x_10)) : ((11.0 + x_11) > ((15.0 + x_13) > (2.0 + x_14)? (15.0 + x_13) : (2.0 + x_14))? (11.0 + x_11) : ((15.0 + x_13) > (2.0 + x_14)? (15.0 + x_13) : (2.0 + x_14))))) : ((((17.0 + x_17) > (1.0 + x_20)? (17.0 + x_17) : (1.0 + x_20)) > ((14.0 + x_22) > ((8.0 + x_23) > (10.0 + x_24)? (8.0 + x_23) : (10.0 + x_24))? (14.0 + x_22) : ((8.0 + x_23) > (10.0 + x_24)? (8.0 + x_23) : (10.0 + x_24)))? ((17.0 + x_17) > (1.0 + x_20)? (17.0 + x_17) : (1.0 + x_20)) : ((14.0 + x_22) > ((8.0 + x_23) > (10.0 + x_24)? (8.0 + x_23) : (10.0 + x_24))? (14.0 + x_22) : ((8.0 + x_23) > (10.0 + x_24)? (8.0 + x_23) : (10.0 + x_24)))) > (((17.0 + x_27) > (10.0 + x_28)? (17.0 + x_27) : (10.0 + x_28)) > ((10.0 + x_31) > ((13.0 + x_32) > (13.0 + x_39)? (13.0 + x_32) : (13.0 + x_39))? (10.0 + x_31) : ((13.0 + x_32) > (13.0 + x_39)? (13.0 + x_32) : (13.0 + x_39)))? ((17.0 + x_27) > (10.0 + x_28)? (17.0 + x_27) : (10.0 + x_28)) : ((10.0 + x_31) > ((13.0 + x_32) > (13.0 + x_39)? (13.0 + x_32) : (13.0 + x_39))? (10.0 + x_31) : ((13.0 + x_32) > (13.0 + x_39)? (13.0 + x_32) : (13.0 + x_39))))? (((17.0 + x_17) > (1.0 + x_20)? (17.0 + x_17) : (1.0 + x_20)) > ((14.0 + x_22) > ((8.0 + x_23) > (10.0 + x_24)? (8.0 + x_23) : (10.0 + x_24))? (14.0 + x_22) : ((8.0 + x_23) > (10.0 + x_24)? (8.0 + x_23) : (10.0 + x_24)))? ((17.0 + x_17) > (1.0 + x_20)? (17.0 + x_17) : (1.0 + x_20)) : ((14.0 + x_22) > ((8.0 + x_23) > (10.0 + x_24)? (8.0 + x_23) : (10.0 + x_24))? (14.0 + x_22) : ((8.0 + x_23) > (10.0 + x_24)? (8.0 + x_23) : (10.0 + x_24)))) : (((17.0 + x_27) > (10.0 + x_28)? (17.0 + x_27) : (10.0 + x_28)) > ((10.0 + x_31) > ((13.0 + x_32) > (13.0 + x_39)? (13.0 + x_32) : (13.0 + x_39))? (10.0 + x_31) : ((13.0 + x_32) > (13.0 + x_39)? (13.0 + x_32) : (13.0 + x_39)))? ((17.0 + x_27) > (10.0 + x_28)? (17.0 + x_27) : (10.0 + x_28)) : ((10.0 + x_31) > ((13.0 + x_32) > (13.0 + x_39)? (13.0 + x_32) : (13.0 + x_39))? (10.0 + x_31) : ((13.0 + x_32) > (13.0 + x_39)? (13.0 + x_32) : (13.0 + x_39))))));
x_15_ = (((((2.0 + x_2) > (5.0 + x_3)? (2.0 + x_2) : (5.0 + x_3)) > ((4.0 + x_5) > ((4.0 + x_6) > (10.0 + x_7)? (4.0 + x_6) : (10.0 + x_7))? (4.0 + x_5) : ((4.0 + x_6) > (10.0 + x_7)? (4.0 + x_6) : (10.0 + x_7)))? ((2.0 + x_2) > (5.0 + x_3)? (2.0 + x_2) : (5.0 + x_3)) : ((4.0 + x_5) > ((4.0 + x_6) > (10.0 + x_7)? (4.0 + x_6) : (10.0 + x_7))? (4.0 + x_5) : ((4.0 + x_6) > (10.0 + x_7)? (4.0 + x_6) : (10.0 + x_7)))) > (((2.0 + x_9) > (11.0 + x_10)? (2.0 + x_9) : (11.0 + x_10)) > ((4.0 + x_11) > ((16.0 + x_12) > (18.0 + x_15)? (16.0 + x_12) : (18.0 + x_15))? (4.0 + x_11) : ((16.0 + x_12) > (18.0 + x_15)? (16.0 + x_12) : (18.0 + x_15)))? ((2.0 + x_9) > (11.0 + x_10)? (2.0 + x_9) : (11.0 + x_10)) : ((4.0 + x_11) > ((16.0 + x_12) > (18.0 + x_15)? (16.0 + x_12) : (18.0 + x_15))? (4.0 + x_11) : ((16.0 + x_12) > (18.0 + x_15)? (16.0 + x_12) : (18.0 + x_15))))? (((2.0 + x_2) > (5.0 + x_3)? (2.0 + x_2) : (5.0 + x_3)) > ((4.0 + x_5) > ((4.0 + x_6) > (10.0 + x_7)? (4.0 + x_6) : (10.0 + x_7))? (4.0 + x_5) : ((4.0 + x_6) > (10.0 + x_7)? (4.0 + x_6) : (10.0 + x_7)))? ((2.0 + x_2) > (5.0 + x_3)? (2.0 + x_2) : (5.0 + x_3)) : ((4.0 + x_5) > ((4.0 + x_6) > (10.0 + x_7)? (4.0 + x_6) : (10.0 + x_7))? (4.0 + x_5) : ((4.0 + x_6) > (10.0 + x_7)? (4.0 + x_6) : (10.0 + x_7)))) : (((2.0 + x_9) > (11.0 + x_10)? (2.0 + x_9) : (11.0 + x_10)) > ((4.0 + x_11) > ((16.0 + x_12) > (18.0 + x_15)? (16.0 + x_12) : (18.0 + x_15))? (4.0 + x_11) : ((16.0 + x_12) > (18.0 + x_15)? (16.0 + x_12) : (18.0 + x_15)))? ((2.0 + x_9) > (11.0 + x_10)? (2.0 + x_9) : (11.0 + x_10)) : ((4.0 + x_11) > ((16.0 + x_12) > (18.0 + x_15)? (16.0 + x_12) : (18.0 + x_15))? (4.0 + x_11) : ((16.0 + x_12) > (18.0 + x_15)? (16.0 + x_12) : (18.0 + x_15))))) > ((((3.0 + x_16) > (5.0 + x_20)? (3.0 + x_16) : (5.0 + x_20)) > ((12.0 + x_22) > ((1.0 + x_23) > (1.0 + x_26)? (1.0 + x_23) : (1.0 + x_26))? (12.0 + x_22) : ((1.0 + x_23) > (1.0 + x_26)? (1.0 + x_23) : (1.0 + x_26)))? ((3.0 + x_16) > (5.0 + x_20)? (3.0 + x_16) : (5.0 + x_20)) : ((12.0 + x_22) > ((1.0 + x_23) > (1.0 + x_26)? (1.0 + x_23) : (1.0 + x_26))? (12.0 + x_22) : ((1.0 + x_23) > (1.0 + x_26)? (1.0 + x_23) : (1.0 + x_26)))) > (((14.0 + x_31) > (7.0 + x_32)? (14.0 + x_31) : (7.0 + x_32)) > ((6.0 + x_34) > ((15.0 + x_36) > (10.0 + x_39)? (15.0 + x_36) : (10.0 + x_39))? (6.0 + x_34) : ((15.0 + x_36) > (10.0 + x_39)? (15.0 + x_36) : (10.0 + x_39)))? ((14.0 + x_31) > (7.0 + x_32)? (14.0 + x_31) : (7.0 + x_32)) : ((6.0 + x_34) > ((15.0 + x_36) > (10.0 + x_39)? (15.0 + x_36) : (10.0 + x_39))? (6.0 + x_34) : ((15.0 + x_36) > (10.0 + x_39)? (15.0 + x_36) : (10.0 + x_39))))? (((3.0 + x_16) > (5.0 + x_20)? (3.0 + x_16) : (5.0 + x_20)) > ((12.0 + x_22) > ((1.0 + x_23) > (1.0 + x_26)? (1.0 + x_23) : (1.0 + x_26))? (12.0 + x_22) : ((1.0 + x_23) > (1.0 + x_26)? (1.0 + x_23) : (1.0 + x_26)))? ((3.0 + x_16) > (5.0 + x_20)? (3.0 + x_16) : (5.0 + x_20)) : ((12.0 + x_22) > ((1.0 + x_23) > (1.0 + x_26)? (1.0 + x_23) : (1.0 + x_26))? (12.0 + x_22) : ((1.0 + x_23) > (1.0 + x_26)? (1.0 + x_23) : (1.0 + x_26)))) : (((14.0 + x_31) > (7.0 + x_32)? (14.0 + x_31) : (7.0 + x_32)) > ((6.0 + x_34) > ((15.0 + x_36) > (10.0 + x_39)? (15.0 + x_36) : (10.0 + x_39))? (6.0 + x_34) : ((15.0 + x_36) > (10.0 + x_39)? (15.0 + x_36) : (10.0 + x_39)))? ((14.0 + x_31) > (7.0 + x_32)? (14.0 + x_31) : (7.0 + x_32)) : ((6.0 + x_34) > ((15.0 + x_36) > (10.0 + x_39)? (15.0 + x_36) : (10.0 + x_39))? (6.0 + x_34) : ((15.0 + x_36) > (10.0 + x_39)? (15.0 + x_36) : (10.0 + x_39)))))? ((((2.0 + x_2) > (5.0 + x_3)? (2.0 + x_2) : (5.0 + x_3)) > ((4.0 + x_5) > ((4.0 + x_6) > (10.0 + x_7)? (4.0 + x_6) : (10.0 + x_7))? (4.0 + x_5) : ((4.0 + x_6) > (10.0 + x_7)? (4.0 + x_6) : (10.0 + x_7)))? ((2.0 + x_2) > (5.0 + x_3)? (2.0 + x_2) : (5.0 + x_3)) : ((4.0 + x_5) > ((4.0 + x_6) > (10.0 + x_7)? (4.0 + x_6) : (10.0 + x_7))? (4.0 + x_5) : ((4.0 + x_6) > (10.0 + x_7)? (4.0 + x_6) : (10.0 + x_7)))) > (((2.0 + x_9) > (11.0 + x_10)? (2.0 + x_9) : (11.0 + x_10)) > ((4.0 + x_11) > ((16.0 + x_12) > (18.0 + x_15)? (16.0 + x_12) : (18.0 + x_15))? (4.0 + x_11) : ((16.0 + x_12) > (18.0 + x_15)? (16.0 + x_12) : (18.0 + x_15)))? ((2.0 + x_9) > (11.0 + x_10)? (2.0 + x_9) : (11.0 + x_10)) : ((4.0 + x_11) > ((16.0 + x_12) > (18.0 + x_15)? (16.0 + x_12) : (18.0 + x_15))? (4.0 + x_11) : ((16.0 + x_12) > (18.0 + x_15)? (16.0 + x_12) : (18.0 + x_15))))? (((2.0 + x_2) > (5.0 + x_3)? (2.0 + x_2) : (5.0 + x_3)) > ((4.0 + x_5) > ((4.0 + x_6) > (10.0 + x_7)? (4.0 + x_6) : (10.0 + x_7))? (4.0 + x_5) : ((4.0 + x_6) > (10.0 + x_7)? (4.0 + x_6) : (10.0 + x_7)))? ((2.0 + x_2) > (5.0 + x_3)? (2.0 + x_2) : (5.0 + x_3)) : ((4.0 + x_5) > ((4.0 + x_6) > (10.0 + x_7)? (4.0 + x_6) : (10.0 + x_7))? (4.0 + x_5) : ((4.0 + x_6) > (10.0 + x_7)? (4.0 + x_6) : (10.0 + x_7)))) : (((2.0 + x_9) > (11.0 + x_10)? (2.0 + x_9) : (11.0 + x_10)) > ((4.0 + x_11) > ((16.0 + x_12) > (18.0 + x_15)? (16.0 + x_12) : (18.0 + x_15))? (4.0 + x_11) : ((16.0 + x_12) > (18.0 + x_15)? (16.0 + x_12) : (18.0 + x_15)))? ((2.0 + x_9) > (11.0 + x_10)? (2.0 + x_9) : (11.0 + x_10)) : ((4.0 + x_11) > ((16.0 + x_12) > (18.0 + x_15)? (16.0 + x_12) : (18.0 + x_15))? (4.0 + x_11) : ((16.0 + x_12) > (18.0 + x_15)? (16.0 + x_12) : (18.0 + x_15))))) : ((((3.0 + x_16) > (5.0 + x_20)? (3.0 + x_16) : (5.0 + x_20)) > ((12.0 + x_22) > ((1.0 + x_23) > (1.0 + x_26)? (1.0 + x_23) : (1.0 + x_26))? (12.0 + x_22) : ((1.0 + x_23) > (1.0 + x_26)? (1.0 + x_23) : (1.0 + x_26)))? ((3.0 + x_16) > (5.0 + x_20)? (3.0 + x_16) : (5.0 + x_20)) : ((12.0 + x_22) > ((1.0 + x_23) > (1.0 + x_26)? (1.0 + x_23) : (1.0 + x_26))? (12.0 + x_22) : ((1.0 + x_23) > (1.0 + x_26)? (1.0 + x_23) : (1.0 + x_26)))) > (((14.0 + x_31) > (7.0 + x_32)? (14.0 + x_31) : (7.0 + x_32)) > ((6.0 + x_34) > ((15.0 + x_36) > (10.0 + x_39)? (15.0 + x_36) : (10.0 + x_39))? (6.0 + x_34) : ((15.0 + x_36) > (10.0 + x_39)? (15.0 + x_36) : (10.0 + x_39)))? ((14.0 + x_31) > (7.0 + x_32)? (14.0 + x_31) : (7.0 + x_32)) : ((6.0 + x_34) > ((15.0 + x_36) > (10.0 + x_39)? (15.0 + x_36) : (10.0 + x_39))? (6.0 + x_34) : ((15.0 + x_36) > (10.0 + x_39)? (15.0 + x_36) : (10.0 + x_39))))? (((3.0 + x_16) > (5.0 + x_20)? (3.0 + x_16) : (5.0 + x_20)) > ((12.0 + x_22) > ((1.0 + x_23) > (1.0 + x_26)? (1.0 + x_23) : (1.0 + x_26))? (12.0 + x_22) : ((1.0 + x_23) > (1.0 + x_26)? (1.0 + x_23) : (1.0 + x_26)))? ((3.0 + x_16) > (5.0 + x_20)? (3.0 + x_16) : (5.0 + x_20)) : ((12.0 + x_22) > ((1.0 + x_23) > (1.0 + x_26)? (1.0 + x_23) : (1.0 + x_26))? (12.0 + x_22) : ((1.0 + x_23) > (1.0 + x_26)? (1.0 + x_23) : (1.0 + x_26)))) : (((14.0 + x_31) > (7.0 + x_32)? (14.0 + x_31) : (7.0 + x_32)) > ((6.0 + x_34) > ((15.0 + x_36) > (10.0 + x_39)? (15.0 + x_36) : (10.0 + x_39))? (6.0 + x_34) : ((15.0 + x_36) > (10.0 + x_39)? (15.0 + x_36) : (10.0 + x_39)))? ((14.0 + x_31) > (7.0 + x_32)? (14.0 + x_31) : (7.0 + x_32)) : ((6.0 + x_34) > ((15.0 + x_36) > (10.0 + x_39)? (15.0 + x_36) : (10.0 + x_39))? (6.0 + x_34) : ((15.0 + x_36) > (10.0 + x_39)? (15.0 + x_36) : (10.0 + x_39))))));
x_16_ = (((((4.0 + x_3) > (2.0 + x_4)? (4.0 + x_3) : (2.0 + x_4)) > ((8.0 + x_6) > ((17.0 + x_9) > (9.0 + x_10)? (17.0 + x_9) : (9.0 + x_10))? (8.0 + x_6) : ((17.0 + x_9) > (9.0 + x_10)? (17.0 + x_9) : (9.0 + x_10)))? ((4.0 + x_3) > (2.0 + x_4)? (4.0 + x_3) : (2.0 + x_4)) : ((8.0 + x_6) > ((17.0 + x_9) > (9.0 + x_10)? (17.0 + x_9) : (9.0 + x_10))? (8.0 + x_6) : ((17.0 + x_9) > (9.0 + x_10)? (17.0 + x_9) : (9.0 + x_10)))) > (((3.0 + x_12) > (5.0 + x_14)? (3.0 + x_12) : (5.0 + x_14)) > ((5.0 + x_16) > ((10.0 + x_19) > (2.0 + x_22)? (10.0 + x_19) : (2.0 + x_22))? (5.0 + x_16) : ((10.0 + x_19) > (2.0 + x_22)? (10.0 + x_19) : (2.0 + x_22)))? ((3.0 + x_12) > (5.0 + x_14)? (3.0 + x_12) : (5.0 + x_14)) : ((5.0 + x_16) > ((10.0 + x_19) > (2.0 + x_22)? (10.0 + x_19) : (2.0 + x_22))? (5.0 + x_16) : ((10.0 + x_19) > (2.0 + x_22)? (10.0 + x_19) : (2.0 + x_22))))? (((4.0 + x_3) > (2.0 + x_4)? (4.0 + x_3) : (2.0 + x_4)) > ((8.0 + x_6) > ((17.0 + x_9) > (9.0 + x_10)? (17.0 + x_9) : (9.0 + x_10))? (8.0 + x_6) : ((17.0 + x_9) > (9.0 + x_10)? (17.0 + x_9) : (9.0 + x_10)))? ((4.0 + x_3) > (2.0 + x_4)? (4.0 + x_3) : (2.0 + x_4)) : ((8.0 + x_6) > ((17.0 + x_9) > (9.0 + x_10)? (17.0 + x_9) : (9.0 + x_10))? (8.0 + x_6) : ((17.0 + x_9) > (9.0 + x_10)? (17.0 + x_9) : (9.0 + x_10)))) : (((3.0 + x_12) > (5.0 + x_14)? (3.0 + x_12) : (5.0 + x_14)) > ((5.0 + x_16) > ((10.0 + x_19) > (2.0 + x_22)? (10.0 + x_19) : (2.0 + x_22))? (5.0 + x_16) : ((10.0 + x_19) > (2.0 + x_22)? (10.0 + x_19) : (2.0 + x_22)))? ((3.0 + x_12) > (5.0 + x_14)? (3.0 + x_12) : (5.0 + x_14)) : ((5.0 + x_16) > ((10.0 + x_19) > (2.0 + x_22)? (10.0 + x_19) : (2.0 + x_22))? (5.0 + x_16) : ((10.0 + x_19) > (2.0 + x_22)? (10.0 + x_19) : (2.0 + x_22))))) > ((((5.0 + x_23) > (18.0 + x_26)? (5.0 + x_23) : (18.0 + x_26)) > ((13.0 + x_29) > ((8.0 + x_30) > (1.0 + x_31)? (8.0 + x_30) : (1.0 + x_31))? (13.0 + x_29) : ((8.0 + x_30) > (1.0 + x_31)? (8.0 + x_30) : (1.0 + x_31)))? ((5.0 + x_23) > (18.0 + x_26)? (5.0 + x_23) : (18.0 + x_26)) : ((13.0 + x_29) > ((8.0 + x_30) > (1.0 + x_31)? (8.0 + x_30) : (1.0 + x_31))? (13.0 + x_29) : ((8.0 + x_30) > (1.0 + x_31)? (8.0 + x_30) : (1.0 + x_31)))) > (((7.0 + x_33) > (19.0 + x_34)? (7.0 + x_33) : (19.0 + x_34)) > ((18.0 + x_36) > ((3.0 + x_37) > (6.0 + x_39)? (3.0 + x_37) : (6.0 + x_39))? (18.0 + x_36) : ((3.0 + x_37) > (6.0 + x_39)? (3.0 + x_37) : (6.0 + x_39)))? ((7.0 + x_33) > (19.0 + x_34)? (7.0 + x_33) : (19.0 + x_34)) : ((18.0 + x_36) > ((3.0 + x_37) > (6.0 + x_39)? (3.0 + x_37) : (6.0 + x_39))? (18.0 + x_36) : ((3.0 + x_37) > (6.0 + x_39)? (3.0 + x_37) : (6.0 + x_39))))? (((5.0 + x_23) > (18.0 + x_26)? (5.0 + x_23) : (18.0 + x_26)) > ((13.0 + x_29) > ((8.0 + x_30) > (1.0 + x_31)? (8.0 + x_30) : (1.0 + x_31))? (13.0 + x_29) : ((8.0 + x_30) > (1.0 + x_31)? (8.0 + x_30) : (1.0 + x_31)))? ((5.0 + x_23) > (18.0 + x_26)? (5.0 + x_23) : (18.0 + x_26)) : ((13.0 + x_29) > ((8.0 + x_30) > (1.0 + x_31)? (8.0 + x_30) : (1.0 + x_31))? (13.0 + x_29) : ((8.0 + x_30) > (1.0 + x_31)? (8.0 + x_30) : (1.0 + x_31)))) : (((7.0 + x_33) > (19.0 + x_34)? (7.0 + x_33) : (19.0 + x_34)) > ((18.0 + x_36) > ((3.0 + x_37) > (6.0 + x_39)? (3.0 + x_37) : (6.0 + x_39))? (18.0 + x_36) : ((3.0 + x_37) > (6.0 + x_39)? (3.0 + x_37) : (6.0 + x_39)))? ((7.0 + x_33) > (19.0 + x_34)? (7.0 + x_33) : (19.0 + x_34)) : ((18.0 + x_36) > ((3.0 + x_37) > (6.0 + x_39)? (3.0 + x_37) : (6.0 + x_39))? (18.0 + x_36) : ((3.0 + x_37) > (6.0 + x_39)? (3.0 + x_37) : (6.0 + x_39)))))? ((((4.0 + x_3) > (2.0 + x_4)? (4.0 + x_3) : (2.0 + x_4)) > ((8.0 + x_6) > ((17.0 + x_9) > (9.0 + x_10)? (17.0 + x_9) : (9.0 + x_10))? (8.0 + x_6) : ((17.0 + x_9) > (9.0 + x_10)? (17.0 + x_9) : (9.0 + x_10)))? ((4.0 + x_3) > (2.0 + x_4)? (4.0 + x_3) : (2.0 + x_4)) : ((8.0 + x_6) > ((17.0 + x_9) > (9.0 + x_10)? (17.0 + x_9) : (9.0 + x_10))? (8.0 + x_6) : ((17.0 + x_9) > (9.0 + x_10)? (17.0 + x_9) : (9.0 + x_10)))) > (((3.0 + x_12) > (5.0 + x_14)? (3.0 + x_12) : (5.0 + x_14)) > ((5.0 + x_16) > ((10.0 + x_19) > (2.0 + x_22)? (10.0 + x_19) : (2.0 + x_22))? (5.0 + x_16) : ((10.0 + x_19) > (2.0 + x_22)? (10.0 + x_19) : (2.0 + x_22)))? ((3.0 + x_12) > (5.0 + x_14)? (3.0 + x_12) : (5.0 + x_14)) : ((5.0 + x_16) > ((10.0 + x_19) > (2.0 + x_22)? (10.0 + x_19) : (2.0 + x_22))? (5.0 + x_16) : ((10.0 + x_19) > (2.0 + x_22)? (10.0 + x_19) : (2.0 + x_22))))? (((4.0 + x_3) > (2.0 + x_4)? (4.0 + x_3) : (2.0 + x_4)) > ((8.0 + x_6) > ((17.0 + x_9) > (9.0 + x_10)? (17.0 + x_9) : (9.0 + x_10))? (8.0 + x_6) : ((17.0 + x_9) > (9.0 + x_10)? (17.0 + x_9) : (9.0 + x_10)))? ((4.0 + x_3) > (2.0 + x_4)? (4.0 + x_3) : (2.0 + x_4)) : ((8.0 + x_6) > ((17.0 + x_9) > (9.0 + x_10)? (17.0 + x_9) : (9.0 + x_10))? (8.0 + x_6) : ((17.0 + x_9) > (9.0 + x_10)? (17.0 + x_9) : (9.0 + x_10)))) : (((3.0 + x_12) > (5.0 + x_14)? (3.0 + x_12) : (5.0 + x_14)) > ((5.0 + x_16) > ((10.0 + x_19) > (2.0 + x_22)? (10.0 + x_19) : (2.0 + x_22))? (5.0 + x_16) : ((10.0 + x_19) > (2.0 + x_22)? (10.0 + x_19) : (2.0 + x_22)))? ((3.0 + x_12) > (5.0 + x_14)? (3.0 + x_12) : (5.0 + x_14)) : ((5.0 + x_16) > ((10.0 + x_19) > (2.0 + x_22)? (10.0 + x_19) : (2.0 + x_22))? (5.0 + x_16) : ((10.0 + x_19) > (2.0 + x_22)? (10.0 + x_19) : (2.0 + x_22))))) : ((((5.0 + x_23) > (18.0 + x_26)? (5.0 + x_23) : (18.0 + x_26)) > ((13.0 + x_29) > ((8.0 + x_30) > (1.0 + x_31)? (8.0 + x_30) : (1.0 + x_31))? (13.0 + x_29) : ((8.0 + x_30) > (1.0 + x_31)? (8.0 + x_30) : (1.0 + x_31)))? ((5.0 + x_23) > (18.0 + x_26)? (5.0 + x_23) : (18.0 + x_26)) : ((13.0 + x_29) > ((8.0 + x_30) > (1.0 + x_31)? (8.0 + x_30) : (1.0 + x_31))? (13.0 + x_29) : ((8.0 + x_30) > (1.0 + x_31)? (8.0 + x_30) : (1.0 + x_31)))) > (((7.0 + x_33) > (19.0 + x_34)? (7.0 + x_33) : (19.0 + x_34)) > ((18.0 + x_36) > ((3.0 + x_37) > (6.0 + x_39)? (3.0 + x_37) : (6.0 + x_39))? (18.0 + x_36) : ((3.0 + x_37) > (6.0 + x_39)? (3.0 + x_37) : (6.0 + x_39)))? ((7.0 + x_33) > (19.0 + x_34)? (7.0 + x_33) : (19.0 + x_34)) : ((18.0 + x_36) > ((3.0 + x_37) > (6.0 + x_39)? (3.0 + x_37) : (6.0 + x_39))? (18.0 + x_36) : ((3.0 + x_37) > (6.0 + x_39)? (3.0 + x_37) : (6.0 + x_39))))? (((5.0 + x_23) > (18.0 + x_26)? (5.0 + x_23) : (18.0 + x_26)) > ((13.0 + x_29) > ((8.0 + x_30) > (1.0 + x_31)? (8.0 + x_30) : (1.0 + x_31))? (13.0 + x_29) : ((8.0 + x_30) > (1.0 + x_31)? (8.0 + x_30) : (1.0 + x_31)))? ((5.0 + x_23) > (18.0 + x_26)? (5.0 + x_23) : (18.0 + x_26)) : ((13.0 + x_29) > ((8.0 + x_30) > (1.0 + x_31)? (8.0 + x_30) : (1.0 + x_31))? (13.0 + x_29) : ((8.0 + x_30) > (1.0 + x_31)? (8.0 + x_30) : (1.0 + x_31)))) : (((7.0 + x_33) > (19.0 + x_34)? (7.0 + x_33) : (19.0 + x_34)) > ((18.0 + x_36) > ((3.0 + x_37) > (6.0 + x_39)? (3.0 + x_37) : (6.0 + x_39))? (18.0 + x_36) : ((3.0 + x_37) > (6.0 + x_39)? (3.0 + x_37) : (6.0 + x_39)))? ((7.0 + x_33) > (19.0 + x_34)? (7.0 + x_33) : (19.0 + x_34)) : ((18.0 + x_36) > ((3.0 + x_37) > (6.0 + x_39)? (3.0 + x_37) : (6.0 + x_39))? (18.0 + x_36) : ((3.0 + x_37) > (6.0 + x_39)? (3.0 + x_37) : (6.0 + x_39))))));
x_17_ = (((((6.0 + x_3) > (4.0 + x_7)? (6.0 + x_3) : (4.0 + x_7)) > ((16.0 + x_10) > ((5.0 + x_11) > (3.0 + x_13)? (5.0 + x_11) : (3.0 + x_13))? (16.0 + x_10) : ((5.0 + x_11) > (3.0 + x_13)? (5.0 + x_11) : (3.0 + x_13)))? ((6.0 + x_3) > (4.0 + x_7)? (6.0 + x_3) : (4.0 + x_7)) : ((16.0 + x_10) > ((5.0 + x_11) > (3.0 + x_13)? (5.0 + x_11) : (3.0 + x_13))? (16.0 + x_10) : ((5.0 + x_11) > (3.0 + x_13)? (5.0 + x_11) : (3.0 + x_13)))) > (((2.0 + x_16) > (9.0 + x_19)? (2.0 + x_16) : (9.0 + x_19)) > ((13.0 + x_20) > ((7.0 + x_21) > (12.0 + x_23)? (7.0 + x_21) : (12.0 + x_23))? (13.0 + x_20) : ((7.0 + x_21) > (12.0 + x_23)? (7.0 + x_21) : (12.0 + x_23)))? ((2.0 + x_16) > (9.0 + x_19)? (2.0 + x_16) : (9.0 + x_19)) : ((13.0 + x_20) > ((7.0 + x_21) > (12.0 + x_23)? (7.0 + x_21) : (12.0 + x_23))? (13.0 + x_20) : ((7.0 + x_21) > (12.0 + x_23)? (7.0 + x_21) : (12.0 + x_23))))? (((6.0 + x_3) > (4.0 + x_7)? (6.0 + x_3) : (4.0 + x_7)) > ((16.0 + x_10) > ((5.0 + x_11) > (3.0 + x_13)? (5.0 + x_11) : (3.0 + x_13))? (16.0 + x_10) : ((5.0 + x_11) > (3.0 + x_13)? (5.0 + x_11) : (3.0 + x_13)))? ((6.0 + x_3) > (4.0 + x_7)? (6.0 + x_3) : (4.0 + x_7)) : ((16.0 + x_10) > ((5.0 + x_11) > (3.0 + x_13)? (5.0 + x_11) : (3.0 + x_13))? (16.0 + x_10) : ((5.0 + x_11) > (3.0 + x_13)? (5.0 + x_11) : (3.0 + x_13)))) : (((2.0 + x_16) > (9.0 + x_19)? (2.0 + x_16) : (9.0 + x_19)) > ((13.0 + x_20) > ((7.0 + x_21) > (12.0 + x_23)? (7.0 + x_21) : (12.0 + x_23))? (13.0 + x_20) : ((7.0 + x_21) > (12.0 + x_23)? (7.0 + x_21) : (12.0 + x_23)))? ((2.0 + x_16) > (9.0 + x_19)? (2.0 + x_16) : (9.0 + x_19)) : ((13.0 + x_20) > ((7.0 + x_21) > (12.0 + x_23)? (7.0 + x_21) : (12.0 + x_23))? (13.0 + x_20) : ((7.0 + x_21) > (12.0 + x_23)? (7.0 + x_21) : (12.0 + x_23))))) > ((((13.0 + x_24) > (15.0 + x_27)? (13.0 + x_24) : (15.0 + x_27)) > ((16.0 + x_28) > ((3.0 + x_29) > (6.0 + x_30)? (3.0 + x_29) : (6.0 + x_30))? (16.0 + x_28) : ((3.0 + x_29) > (6.0 + x_30)? (3.0 + x_29) : (6.0 + x_30)))? ((13.0 + x_24) > (15.0 + x_27)? (13.0 + x_24) : (15.0 + x_27)) : ((16.0 + x_28) > ((3.0 + x_29) > (6.0 + x_30)? (3.0 + x_29) : (6.0 + x_30))? (16.0 + x_28) : ((3.0 + x_29) > (6.0 + x_30)? (3.0 + x_29) : (6.0 + x_30)))) > (((14.0 + x_33) > (11.0 + x_35)? (14.0 + x_33) : (11.0 + x_35)) > ((12.0 + x_36) > ((17.0 + x_37) > (11.0 + x_38)? (17.0 + x_37) : (11.0 + x_38))? (12.0 + x_36) : ((17.0 + x_37) > (11.0 + x_38)? (17.0 + x_37) : (11.0 + x_38)))? ((14.0 + x_33) > (11.0 + x_35)? (14.0 + x_33) : (11.0 + x_35)) : ((12.0 + x_36) > ((17.0 + x_37) > (11.0 + x_38)? (17.0 + x_37) : (11.0 + x_38))? (12.0 + x_36) : ((17.0 + x_37) > (11.0 + x_38)? (17.0 + x_37) : (11.0 + x_38))))? (((13.0 + x_24) > (15.0 + x_27)? (13.0 + x_24) : (15.0 + x_27)) > ((16.0 + x_28) > ((3.0 + x_29) > (6.0 + x_30)? (3.0 + x_29) : (6.0 + x_30))? (16.0 + x_28) : ((3.0 + x_29) > (6.0 + x_30)? (3.0 + x_29) : (6.0 + x_30)))? ((13.0 + x_24) > (15.0 + x_27)? (13.0 + x_24) : (15.0 + x_27)) : ((16.0 + x_28) > ((3.0 + x_29) > (6.0 + x_30)? (3.0 + x_29) : (6.0 + x_30))? (16.0 + x_28) : ((3.0 + x_29) > (6.0 + x_30)? (3.0 + x_29) : (6.0 + x_30)))) : (((14.0 + x_33) > (11.0 + x_35)? (14.0 + x_33) : (11.0 + x_35)) > ((12.0 + x_36) > ((17.0 + x_37) > (11.0 + x_38)? (17.0 + x_37) : (11.0 + x_38))? (12.0 + x_36) : ((17.0 + x_37) > (11.0 + x_38)? (17.0 + x_37) : (11.0 + x_38)))? ((14.0 + x_33) > (11.0 + x_35)? (14.0 + x_33) : (11.0 + x_35)) : ((12.0 + x_36) > ((17.0 + x_37) > (11.0 + x_38)? (17.0 + x_37) : (11.0 + x_38))? (12.0 + x_36) : ((17.0 + x_37) > (11.0 + x_38)? (17.0 + x_37) : (11.0 + x_38)))))? ((((6.0 + x_3) > (4.0 + x_7)? (6.0 + x_3) : (4.0 + x_7)) > ((16.0 + x_10) > ((5.0 + x_11) > (3.0 + x_13)? (5.0 + x_11) : (3.0 + x_13))? (16.0 + x_10) : ((5.0 + x_11) > (3.0 + x_13)? (5.0 + x_11) : (3.0 + x_13)))? ((6.0 + x_3) > (4.0 + x_7)? (6.0 + x_3) : (4.0 + x_7)) : ((16.0 + x_10) > ((5.0 + x_11) > (3.0 + x_13)? (5.0 + x_11) : (3.0 + x_13))? (16.0 + x_10) : ((5.0 + x_11) > (3.0 + x_13)? (5.0 + x_11) : (3.0 + x_13)))) > (((2.0 + x_16) > (9.0 + x_19)? (2.0 + x_16) : (9.0 + x_19)) > ((13.0 + x_20) > ((7.0 + x_21) > (12.0 + x_23)? (7.0 + x_21) : (12.0 + x_23))? (13.0 + x_20) : ((7.0 + x_21) > (12.0 + x_23)? (7.0 + x_21) : (12.0 + x_23)))? ((2.0 + x_16) > (9.0 + x_19)? (2.0 + x_16) : (9.0 + x_19)) : ((13.0 + x_20) > ((7.0 + x_21) > (12.0 + x_23)? (7.0 + x_21) : (12.0 + x_23))? (13.0 + x_20) : ((7.0 + x_21) > (12.0 + x_23)? (7.0 + x_21) : (12.0 + x_23))))? (((6.0 + x_3) > (4.0 + x_7)? (6.0 + x_3) : (4.0 + x_7)) > ((16.0 + x_10) > ((5.0 + x_11) > (3.0 + x_13)? (5.0 + x_11) : (3.0 + x_13))? (16.0 + x_10) : ((5.0 + x_11) > (3.0 + x_13)? (5.0 + x_11) : (3.0 + x_13)))? ((6.0 + x_3) > (4.0 + x_7)? (6.0 + x_3) : (4.0 + x_7)) : ((16.0 + x_10) > ((5.0 + x_11) > (3.0 + x_13)? (5.0 + x_11) : (3.0 + x_13))? (16.0 + x_10) : ((5.0 + x_11) > (3.0 + x_13)? (5.0 + x_11) : (3.0 + x_13)))) : (((2.0 + x_16) > (9.0 + x_19)? (2.0 + x_16) : (9.0 + x_19)) > ((13.0 + x_20) > ((7.0 + x_21) > (12.0 + x_23)? (7.0 + x_21) : (12.0 + x_23))? (13.0 + x_20) : ((7.0 + x_21) > (12.0 + x_23)? (7.0 + x_21) : (12.0 + x_23)))? ((2.0 + x_16) > (9.0 + x_19)? (2.0 + x_16) : (9.0 + x_19)) : ((13.0 + x_20) > ((7.0 + x_21) > (12.0 + x_23)? (7.0 + x_21) : (12.0 + x_23))? (13.0 + x_20) : ((7.0 + x_21) > (12.0 + x_23)? (7.0 + x_21) : (12.0 + x_23))))) : ((((13.0 + x_24) > (15.0 + x_27)? (13.0 + x_24) : (15.0 + x_27)) > ((16.0 + x_28) > ((3.0 + x_29) > (6.0 + x_30)? (3.0 + x_29) : (6.0 + x_30))? (16.0 + x_28) : ((3.0 + x_29) > (6.0 + x_30)? (3.0 + x_29) : (6.0 + x_30)))? ((13.0 + x_24) > (15.0 + x_27)? (13.0 + x_24) : (15.0 + x_27)) : ((16.0 + x_28) > ((3.0 + x_29) > (6.0 + x_30)? (3.0 + x_29) : (6.0 + x_30))? (16.0 + x_28) : ((3.0 + x_29) > (6.0 + x_30)? (3.0 + x_29) : (6.0 + x_30)))) > (((14.0 + x_33) > (11.0 + x_35)? (14.0 + x_33) : (11.0 + x_35)) > ((12.0 + x_36) > ((17.0 + x_37) > (11.0 + x_38)? (17.0 + x_37) : (11.0 + x_38))? (12.0 + x_36) : ((17.0 + x_37) > (11.0 + x_38)? (17.0 + x_37) : (11.0 + x_38)))? ((14.0 + x_33) > (11.0 + x_35)? (14.0 + x_33) : (11.0 + x_35)) : ((12.0 + x_36) > ((17.0 + x_37) > (11.0 + x_38)? (17.0 + x_37) : (11.0 + x_38))? (12.0 + x_36) : ((17.0 + x_37) > (11.0 + x_38)? (17.0 + x_37) : (11.0 + x_38))))? (((13.0 + x_24) > (15.0 + x_27)? (13.0 + x_24) : (15.0 + x_27)) > ((16.0 + x_28) > ((3.0 + x_29) > (6.0 + x_30)? (3.0 + x_29) : (6.0 + x_30))? (16.0 + x_28) : ((3.0 + x_29) > (6.0 + x_30)? (3.0 + x_29) : (6.0 + x_30)))? ((13.0 + x_24) > (15.0 + x_27)? (13.0 + x_24) : (15.0 + x_27)) : ((16.0 + x_28) > ((3.0 + x_29) > (6.0 + x_30)? (3.0 + x_29) : (6.0 + x_30))? (16.0 + x_28) : ((3.0 + x_29) > (6.0 + x_30)? (3.0 + x_29) : (6.0 + x_30)))) : (((14.0 + x_33) > (11.0 + x_35)? (14.0 + x_33) : (11.0 + x_35)) > ((12.0 + x_36) > ((17.0 + x_37) > (11.0 + x_38)? (17.0 + x_37) : (11.0 + x_38))? (12.0 + x_36) : ((17.0 + x_37) > (11.0 + x_38)? (17.0 + x_37) : (11.0 + x_38)))? ((14.0 + x_33) > (11.0 + x_35)? (14.0 + x_33) : (11.0 + x_35)) : ((12.0 + x_36) > ((17.0 + x_37) > (11.0 + x_38)? (17.0 + x_37) : (11.0 + x_38))? (12.0 + x_36) : ((17.0 + x_37) > (11.0 + x_38)? (17.0 + x_37) : (11.0 + x_38))))));
x_18_ = (((((18.0 + x_1) > (16.0 + x_4)? (18.0 + x_1) : (16.0 + x_4)) > ((18.0 + x_7) > ((10.0 + x_11) > (2.0 + x_12)? (10.0 + x_11) : (2.0 + x_12))? (18.0 + x_7) : ((10.0 + x_11) > (2.0 + x_12)? (10.0 + x_11) : (2.0 + x_12)))? ((18.0 + x_1) > (16.0 + x_4)? (18.0 + x_1) : (16.0 + x_4)) : ((18.0 + x_7) > ((10.0 + x_11) > (2.0 + x_12)? (10.0 + x_11) : (2.0 + x_12))? (18.0 + x_7) : ((10.0 + x_11) > (2.0 + x_12)? (10.0 + x_11) : (2.0 + x_12)))) > (((13.0 + x_13) > (7.0 + x_14)? (13.0 + x_13) : (7.0 + x_14)) > ((15.0 + x_18) > ((3.0 + x_19) > (8.0 + x_20)? (3.0 + x_19) : (8.0 + x_20))? (15.0 + x_18) : ((3.0 + x_19) > (8.0 + x_20)? (3.0 + x_19) : (8.0 + x_20)))? ((13.0 + x_13) > (7.0 + x_14)? (13.0 + x_13) : (7.0 + x_14)) : ((15.0 + x_18) > ((3.0 + x_19) > (8.0 + x_20)? (3.0 + x_19) : (8.0 + x_20))? (15.0 + x_18) : ((3.0 + x_19) > (8.0 + x_20)? (3.0 + x_19) : (8.0 + x_20))))? (((18.0 + x_1) > (16.0 + x_4)? (18.0 + x_1) : (16.0 + x_4)) > ((18.0 + x_7) > ((10.0 + x_11) > (2.0 + x_12)? (10.0 + x_11) : (2.0 + x_12))? (18.0 + x_7) : ((10.0 + x_11) > (2.0 + x_12)? (10.0 + x_11) : (2.0 + x_12)))? ((18.0 + x_1) > (16.0 + x_4)? (18.0 + x_1) : (16.0 + x_4)) : ((18.0 + x_7) > ((10.0 + x_11) > (2.0 + x_12)? (10.0 + x_11) : (2.0 + x_12))? (18.0 + x_7) : ((10.0 + x_11) > (2.0 + x_12)? (10.0 + x_11) : (2.0 + x_12)))) : (((13.0 + x_13) > (7.0 + x_14)? (13.0 + x_13) : (7.0 + x_14)) > ((15.0 + x_18) > ((3.0 + x_19) > (8.0 + x_20)? (3.0 + x_19) : (8.0 + x_20))? (15.0 + x_18) : ((3.0 + x_19) > (8.0 + x_20)? (3.0 + x_19) : (8.0 + x_20)))? ((13.0 + x_13) > (7.0 + x_14)? (13.0 + x_13) : (7.0 + x_14)) : ((15.0 + x_18) > ((3.0 + x_19) > (8.0 + x_20)? (3.0 + x_19) : (8.0 + x_20))? (15.0 + x_18) : ((3.0 + x_19) > (8.0 + x_20)? (3.0 + x_19) : (8.0 + x_20))))) > ((((3.0 + x_22) > (17.0 + x_23)? (3.0 + x_22) : (17.0 + x_23)) > ((15.0 + x_25) > ((10.0 + x_28) > (18.0 + x_31)? (10.0 + x_28) : (18.0 + x_31))? (15.0 + x_25) : ((10.0 + x_28) > (18.0 + x_31)? (10.0 + x_28) : (18.0 + x_31)))? ((3.0 + x_22) > (17.0 + x_23)? (3.0 + x_22) : (17.0 + x_23)) : ((15.0 + x_25) > ((10.0 + x_28) > (18.0 + x_31)? (10.0 + x_28) : (18.0 + x_31))? (15.0 + x_25) : ((10.0 + x_28) > (18.0 + x_31)? (10.0 + x_28) : (18.0 + x_31)))) > (((10.0 + x_32) > (8.0 + x_36)? (10.0 + x_32) : (8.0 + x_36)) > ((9.0 + x_37) > ((2.0 + x_38) > (10.0 + x_39)? (2.0 + x_38) : (10.0 + x_39))? (9.0 + x_37) : ((2.0 + x_38) > (10.0 + x_39)? (2.0 + x_38) : (10.0 + x_39)))? ((10.0 + x_32) > (8.0 + x_36)? (10.0 + x_32) : (8.0 + x_36)) : ((9.0 + x_37) > ((2.0 + x_38) > (10.0 + x_39)? (2.0 + x_38) : (10.0 + x_39))? (9.0 + x_37) : ((2.0 + x_38) > (10.0 + x_39)? (2.0 + x_38) : (10.0 + x_39))))? (((3.0 + x_22) > (17.0 + x_23)? (3.0 + x_22) : (17.0 + x_23)) > ((15.0 + x_25) > ((10.0 + x_28) > (18.0 + x_31)? (10.0 + x_28) : (18.0 + x_31))? (15.0 + x_25) : ((10.0 + x_28) > (18.0 + x_31)? (10.0 + x_28) : (18.0 + x_31)))? ((3.0 + x_22) > (17.0 + x_23)? (3.0 + x_22) : (17.0 + x_23)) : ((15.0 + x_25) > ((10.0 + x_28) > (18.0 + x_31)? (10.0 + x_28) : (18.0 + x_31))? (15.0 + x_25) : ((10.0 + x_28) > (18.0 + x_31)? (10.0 + x_28) : (18.0 + x_31)))) : (((10.0 + x_32) > (8.0 + x_36)? (10.0 + x_32) : (8.0 + x_36)) > ((9.0 + x_37) > ((2.0 + x_38) > (10.0 + x_39)? (2.0 + x_38) : (10.0 + x_39))? (9.0 + x_37) : ((2.0 + x_38) > (10.0 + x_39)? (2.0 + x_38) : (10.0 + x_39)))? ((10.0 + x_32) > (8.0 + x_36)? (10.0 + x_32) : (8.0 + x_36)) : ((9.0 + x_37) > ((2.0 + x_38) > (10.0 + x_39)? (2.0 + x_38) : (10.0 + x_39))? (9.0 + x_37) : ((2.0 + x_38) > (10.0 + x_39)? (2.0 + x_38) : (10.0 + x_39)))))? ((((18.0 + x_1) > (16.0 + x_4)? (18.0 + x_1) : (16.0 + x_4)) > ((18.0 + x_7) > ((10.0 + x_11) > (2.0 + x_12)? (10.0 + x_11) : (2.0 + x_12))? (18.0 + x_7) : ((10.0 + x_11) > (2.0 + x_12)? (10.0 + x_11) : (2.0 + x_12)))? ((18.0 + x_1) > (16.0 + x_4)? (18.0 + x_1) : (16.0 + x_4)) : ((18.0 + x_7) > ((10.0 + x_11) > (2.0 + x_12)? (10.0 + x_11) : (2.0 + x_12))? (18.0 + x_7) : ((10.0 + x_11) > (2.0 + x_12)? (10.0 + x_11) : (2.0 + x_12)))) > (((13.0 + x_13) > (7.0 + x_14)? (13.0 + x_13) : (7.0 + x_14)) > ((15.0 + x_18) > ((3.0 + x_19) > (8.0 + x_20)? (3.0 + x_19) : (8.0 + x_20))? (15.0 + x_18) : ((3.0 + x_19) > (8.0 + x_20)? (3.0 + x_19) : (8.0 + x_20)))? ((13.0 + x_13) > (7.0 + x_14)? (13.0 + x_13) : (7.0 + x_14)) : ((15.0 + x_18) > ((3.0 + x_19) > (8.0 + x_20)? (3.0 + x_19) : (8.0 + x_20))? (15.0 + x_18) : ((3.0 + x_19) > (8.0 + x_20)? (3.0 + x_19) : (8.0 + x_20))))? (((18.0 + x_1) > (16.0 + x_4)? (18.0 + x_1) : (16.0 + x_4)) > ((18.0 + x_7) > ((10.0 + x_11) > (2.0 + x_12)? (10.0 + x_11) : (2.0 + x_12))? (18.0 + x_7) : ((10.0 + x_11) > (2.0 + x_12)? (10.0 + x_11) : (2.0 + x_12)))? ((18.0 + x_1) > (16.0 + x_4)? (18.0 + x_1) : (16.0 + x_4)) : ((18.0 + x_7) > ((10.0 + x_11) > (2.0 + x_12)? (10.0 + x_11) : (2.0 + x_12))? (18.0 + x_7) : ((10.0 + x_11) > (2.0 + x_12)? (10.0 + x_11) : (2.0 + x_12)))) : (((13.0 + x_13) > (7.0 + x_14)? (13.0 + x_13) : (7.0 + x_14)) > ((15.0 + x_18) > ((3.0 + x_19) > (8.0 + x_20)? (3.0 + x_19) : (8.0 + x_20))? (15.0 + x_18) : ((3.0 + x_19) > (8.0 + x_20)? (3.0 + x_19) : (8.0 + x_20)))? ((13.0 + x_13) > (7.0 + x_14)? (13.0 + x_13) : (7.0 + x_14)) : ((15.0 + x_18) > ((3.0 + x_19) > (8.0 + x_20)? (3.0 + x_19) : (8.0 + x_20))? (15.0 + x_18) : ((3.0 + x_19) > (8.0 + x_20)? (3.0 + x_19) : (8.0 + x_20))))) : ((((3.0 + x_22) > (17.0 + x_23)? (3.0 + x_22) : (17.0 + x_23)) > ((15.0 + x_25) > ((10.0 + x_28) > (18.0 + x_31)? (10.0 + x_28) : (18.0 + x_31))? (15.0 + x_25) : ((10.0 + x_28) > (18.0 + x_31)? (10.0 + x_28) : (18.0 + x_31)))? ((3.0 + x_22) > (17.0 + x_23)? (3.0 + x_22) : (17.0 + x_23)) : ((15.0 + x_25) > ((10.0 + x_28) > (18.0 + x_31)? (10.0 + x_28) : (18.0 + x_31))? (15.0 + x_25) : ((10.0 + x_28) > (18.0 + x_31)? (10.0 + x_28) : (18.0 + x_31)))) > (((10.0 + x_32) > (8.0 + x_36)? (10.0 + x_32) : (8.0 + x_36)) > ((9.0 + x_37) > ((2.0 + x_38) > (10.0 + x_39)? (2.0 + x_38) : (10.0 + x_39))? (9.0 + x_37) : ((2.0 + x_38) > (10.0 + x_39)? (2.0 + x_38) : (10.0 + x_39)))? ((10.0 + x_32) > (8.0 + x_36)? (10.0 + x_32) : (8.0 + x_36)) : ((9.0 + x_37) > ((2.0 + x_38) > (10.0 + x_39)? (2.0 + x_38) : (10.0 + x_39))? (9.0 + x_37) : ((2.0 + x_38) > (10.0 + x_39)? (2.0 + x_38) : (10.0 + x_39))))? (((3.0 + x_22) > (17.0 + x_23)? (3.0 + x_22) : (17.0 + x_23)) > ((15.0 + x_25) > ((10.0 + x_28) > (18.0 + x_31)? (10.0 + x_28) : (18.0 + x_31))? (15.0 + x_25) : ((10.0 + x_28) > (18.0 + x_31)? (10.0 + x_28) : (18.0 + x_31)))? ((3.0 + x_22) > (17.0 + x_23)? (3.0 + x_22) : (17.0 + x_23)) : ((15.0 + x_25) > ((10.0 + x_28) > (18.0 + x_31)? (10.0 + x_28) : (18.0 + x_31))? (15.0 + x_25) : ((10.0 + x_28) > (18.0 + x_31)? (10.0 + x_28) : (18.0 + x_31)))) : (((10.0 + x_32) > (8.0 + x_36)? (10.0 + x_32) : (8.0 + x_36)) > ((9.0 + x_37) > ((2.0 + x_38) > (10.0 + x_39)? (2.0 + x_38) : (10.0 + x_39))? (9.0 + x_37) : ((2.0 + x_38) > (10.0 + x_39)? (2.0 + x_38) : (10.0 + x_39)))? ((10.0 + x_32) > (8.0 + x_36)? (10.0 + x_32) : (8.0 + x_36)) : ((9.0 + x_37) > ((2.0 + x_38) > (10.0 + x_39)? (2.0 + x_38) : (10.0 + x_39))? (9.0 + x_37) : ((2.0 + x_38) > (10.0 + x_39)? (2.0 + x_38) : (10.0 + x_39))))));
x_19_ = (((((8.0 + x_1) > (15.0 + x_2)? (8.0 + x_1) : (15.0 + x_2)) > ((19.0 + x_4) > ((12.0 + x_6) > (6.0 + x_10)? (12.0 + x_6) : (6.0 + x_10))? (19.0 + x_4) : ((12.0 + x_6) > (6.0 + x_10)? (12.0 + x_6) : (6.0 + x_10)))? ((8.0 + x_1) > (15.0 + x_2)? (8.0 + x_1) : (15.0 + x_2)) : ((19.0 + x_4) > ((12.0 + x_6) > (6.0 + x_10)? (12.0 + x_6) : (6.0 + x_10))? (19.0 + x_4) : ((12.0 + x_6) > (6.0 + x_10)? (12.0 + x_6) : (6.0 + x_10)))) > (((18.0 + x_12) > (10.0 + x_13)? (18.0 + x_12) : (10.0 + x_13)) > ((3.0 + x_16) > ((6.0 + x_18) > (11.0 + x_19)? (6.0 + x_18) : (11.0 + x_19))? (3.0 + x_16) : ((6.0 + x_18) > (11.0 + x_19)? (6.0 + x_18) : (11.0 + x_19)))? ((18.0 + x_12) > (10.0 + x_13)? (18.0 + x_12) : (10.0 + x_13)) : ((3.0 + x_16) > ((6.0 + x_18) > (11.0 + x_19)? (6.0 + x_18) : (11.0 + x_19))? (3.0 + x_16) : ((6.0 + x_18) > (11.0 + x_19)? (6.0 + x_18) : (11.0 + x_19))))? (((8.0 + x_1) > (15.0 + x_2)? (8.0 + x_1) : (15.0 + x_2)) > ((19.0 + x_4) > ((12.0 + x_6) > (6.0 + x_10)? (12.0 + x_6) : (6.0 + x_10))? (19.0 + x_4) : ((12.0 + x_6) > (6.0 + x_10)? (12.0 + x_6) : (6.0 + x_10)))? ((8.0 + x_1) > (15.0 + x_2)? (8.0 + x_1) : (15.0 + x_2)) : ((19.0 + x_4) > ((12.0 + x_6) > (6.0 + x_10)? (12.0 + x_6) : (6.0 + x_10))? (19.0 + x_4) : ((12.0 + x_6) > (6.0 + x_10)? (12.0 + x_6) : (6.0 + x_10)))) : (((18.0 + x_12) > (10.0 + x_13)? (18.0 + x_12) : (10.0 + x_13)) > ((3.0 + x_16) > ((6.0 + x_18) > (11.0 + x_19)? (6.0 + x_18) : (11.0 + x_19))? (3.0 + x_16) : ((6.0 + x_18) > (11.0 + x_19)? (6.0 + x_18) : (11.0 + x_19)))? ((18.0 + x_12) > (10.0 + x_13)? (18.0 + x_12) : (10.0 + x_13)) : ((3.0 + x_16) > ((6.0 + x_18) > (11.0 + x_19)? (6.0 + x_18) : (11.0 + x_19))? (3.0 + x_16) : ((6.0 + x_18) > (11.0 + x_19)? (6.0 + x_18) : (11.0 + x_19))))) > ((((11.0 + x_21) > (6.0 + x_22)? (11.0 + x_21) : (6.0 + x_22)) > ((12.0 + x_26) > ((15.0 + x_28) > (7.0 + x_29)? (15.0 + x_28) : (7.0 + x_29))? (12.0 + x_26) : ((15.0 + x_28) > (7.0 + x_29)? (15.0 + x_28) : (7.0 + x_29)))? ((11.0 + x_21) > (6.0 + x_22)? (11.0 + x_21) : (6.0 + x_22)) : ((12.0 + x_26) > ((15.0 + x_28) > (7.0 + x_29)? (15.0 + x_28) : (7.0 + x_29))? (12.0 + x_26) : ((15.0 + x_28) > (7.0 + x_29)? (15.0 + x_28) : (7.0 + x_29)))) > (((11.0 + x_30) > (16.0 + x_32)? (11.0 + x_30) : (16.0 + x_32)) > ((5.0 + x_34) > ((8.0 + x_35) > (5.0 + x_37)? (8.0 + x_35) : (5.0 + x_37))? (5.0 + x_34) : ((8.0 + x_35) > (5.0 + x_37)? (8.0 + x_35) : (5.0 + x_37)))? ((11.0 + x_30) > (16.0 + x_32)? (11.0 + x_30) : (16.0 + x_32)) : ((5.0 + x_34) > ((8.0 + x_35) > (5.0 + x_37)? (8.0 + x_35) : (5.0 + x_37))? (5.0 + x_34) : ((8.0 + x_35) > (5.0 + x_37)? (8.0 + x_35) : (5.0 + x_37))))? (((11.0 + x_21) > (6.0 + x_22)? (11.0 + x_21) : (6.0 + x_22)) > ((12.0 + x_26) > ((15.0 + x_28) > (7.0 + x_29)? (15.0 + x_28) : (7.0 + x_29))? (12.0 + x_26) : ((15.0 + x_28) > (7.0 + x_29)? (15.0 + x_28) : (7.0 + x_29)))? ((11.0 + x_21) > (6.0 + x_22)? (11.0 + x_21) : (6.0 + x_22)) : ((12.0 + x_26) > ((15.0 + x_28) > (7.0 + x_29)? (15.0 + x_28) : (7.0 + x_29))? (12.0 + x_26) : ((15.0 + x_28) > (7.0 + x_29)? (15.0 + x_28) : (7.0 + x_29)))) : (((11.0 + x_30) > (16.0 + x_32)? (11.0 + x_30) : (16.0 + x_32)) > ((5.0 + x_34) > ((8.0 + x_35) > (5.0 + x_37)? (8.0 + x_35) : (5.0 + x_37))? (5.0 + x_34) : ((8.0 + x_35) > (5.0 + x_37)? (8.0 + x_35) : (5.0 + x_37)))? ((11.0 + x_30) > (16.0 + x_32)? (11.0 + x_30) : (16.0 + x_32)) : ((5.0 + x_34) > ((8.0 + x_35) > (5.0 + x_37)? (8.0 + x_35) : (5.0 + x_37))? (5.0 + x_34) : ((8.0 + x_35) > (5.0 + x_37)? (8.0 + x_35) : (5.0 + x_37)))))? ((((8.0 + x_1) > (15.0 + x_2)? (8.0 + x_1) : (15.0 + x_2)) > ((19.0 + x_4) > ((12.0 + x_6) > (6.0 + x_10)? (12.0 + x_6) : (6.0 + x_10))? (19.0 + x_4) : ((12.0 + x_6) > (6.0 + x_10)? (12.0 + x_6) : (6.0 + x_10)))? ((8.0 + x_1) > (15.0 + x_2)? (8.0 + x_1) : (15.0 + x_2)) : ((19.0 + x_4) > ((12.0 + x_6) > (6.0 + x_10)? (12.0 + x_6) : (6.0 + x_10))? (19.0 + x_4) : ((12.0 + x_6) > (6.0 + x_10)? (12.0 + x_6) : (6.0 + x_10)))) > (((18.0 + x_12) > (10.0 + x_13)? (18.0 + x_12) : (10.0 + x_13)) > ((3.0 + x_16) > ((6.0 + x_18) > (11.0 + x_19)? (6.0 + x_18) : (11.0 + x_19))? (3.0 + x_16) : ((6.0 + x_18) > (11.0 + x_19)? (6.0 + x_18) : (11.0 + x_19)))? ((18.0 + x_12) > (10.0 + x_13)? (18.0 + x_12) : (10.0 + x_13)) : ((3.0 + x_16) > ((6.0 + x_18) > (11.0 + x_19)? (6.0 + x_18) : (11.0 + x_19))? (3.0 + x_16) : ((6.0 + x_18) > (11.0 + x_19)? (6.0 + x_18) : (11.0 + x_19))))? (((8.0 + x_1) > (15.0 + x_2)? (8.0 + x_1) : (15.0 + x_2)) > ((19.0 + x_4) > ((12.0 + x_6) > (6.0 + x_10)? (12.0 + x_6) : (6.0 + x_10))? (19.0 + x_4) : ((12.0 + x_6) > (6.0 + x_10)? (12.0 + x_6) : (6.0 + x_10)))? ((8.0 + x_1) > (15.0 + x_2)? (8.0 + x_1) : (15.0 + x_2)) : ((19.0 + x_4) > ((12.0 + x_6) > (6.0 + x_10)? (12.0 + x_6) : (6.0 + x_10))? (19.0 + x_4) : ((12.0 + x_6) > (6.0 + x_10)? (12.0 + x_6) : (6.0 + x_10)))) : (((18.0 + x_12) > (10.0 + x_13)? (18.0 + x_12) : (10.0 + x_13)) > ((3.0 + x_16) > ((6.0 + x_18) > (11.0 + x_19)? (6.0 + x_18) : (11.0 + x_19))? (3.0 + x_16) : ((6.0 + x_18) > (11.0 + x_19)? (6.0 + x_18) : (11.0 + x_19)))? ((18.0 + x_12) > (10.0 + x_13)? (18.0 + x_12) : (10.0 + x_13)) : ((3.0 + x_16) > ((6.0 + x_18) > (11.0 + x_19)? (6.0 + x_18) : (11.0 + x_19))? (3.0 + x_16) : ((6.0 + x_18) > (11.0 + x_19)? (6.0 + x_18) : (11.0 + x_19))))) : ((((11.0 + x_21) > (6.0 + x_22)? (11.0 + x_21) : (6.0 + x_22)) > ((12.0 + x_26) > ((15.0 + x_28) > (7.0 + x_29)? (15.0 + x_28) : (7.0 + x_29))? (12.0 + x_26) : ((15.0 + x_28) > (7.0 + x_29)? (15.0 + x_28) : (7.0 + x_29)))? ((11.0 + x_21) > (6.0 + x_22)? (11.0 + x_21) : (6.0 + x_22)) : ((12.0 + x_26) > ((15.0 + x_28) > (7.0 + x_29)? (15.0 + x_28) : (7.0 + x_29))? (12.0 + x_26) : ((15.0 + x_28) > (7.0 + x_29)? (15.0 + x_28) : (7.0 + x_29)))) > (((11.0 + x_30) > (16.0 + x_32)? (11.0 + x_30) : (16.0 + x_32)) > ((5.0 + x_34) > ((8.0 + x_35) > (5.0 + x_37)? (8.0 + x_35) : (5.0 + x_37))? (5.0 + x_34) : ((8.0 + x_35) > (5.0 + x_37)? (8.0 + x_35) : (5.0 + x_37)))? ((11.0 + x_30) > (16.0 + x_32)? (11.0 + x_30) : (16.0 + x_32)) : ((5.0 + x_34) > ((8.0 + x_35) > (5.0 + x_37)? (8.0 + x_35) : (5.0 + x_37))? (5.0 + x_34) : ((8.0 + x_35) > (5.0 + x_37)? (8.0 + x_35) : (5.0 + x_37))))? (((11.0 + x_21) > (6.0 + x_22)? (11.0 + x_21) : (6.0 + x_22)) > ((12.0 + x_26) > ((15.0 + x_28) > (7.0 + x_29)? (15.0 + x_28) : (7.0 + x_29))? (12.0 + x_26) : ((15.0 + x_28) > (7.0 + x_29)? (15.0 + x_28) : (7.0 + x_29)))? ((11.0 + x_21) > (6.0 + x_22)? (11.0 + x_21) : (6.0 + x_22)) : ((12.0 + x_26) > ((15.0 + x_28) > (7.0 + x_29)? (15.0 + x_28) : (7.0 + x_29))? (12.0 + x_26) : ((15.0 + x_28) > (7.0 + x_29)? (15.0 + x_28) : (7.0 + x_29)))) : (((11.0 + x_30) > (16.0 + x_32)? (11.0 + x_30) : (16.0 + x_32)) > ((5.0 + x_34) > ((8.0 + x_35) > (5.0 + x_37)? (8.0 + x_35) : (5.0 + x_37))? (5.0 + x_34) : ((8.0 + x_35) > (5.0 + x_37)? (8.0 + x_35) : (5.0 + x_37)))? ((11.0 + x_30) > (16.0 + x_32)? (11.0 + x_30) : (16.0 + x_32)) : ((5.0 + x_34) > ((8.0 + x_35) > (5.0 + x_37)? (8.0 + x_35) : (5.0 + x_37))? (5.0 + x_34) : ((8.0 + x_35) > (5.0 + x_37)? (8.0 + x_35) : (5.0 + x_37))))));
x_20_ = (((((13.0 + x_0) > (9.0 + x_1)? (13.0 + x_0) : (9.0 + x_1)) > ((3.0 + x_3) > ((11.0 + x_4) > (11.0 + x_5)? (11.0 + x_4) : (11.0 + x_5))? (3.0 + x_3) : ((11.0 + x_4) > (11.0 + x_5)? (11.0 + x_4) : (11.0 + x_5)))? ((13.0 + x_0) > (9.0 + x_1)? (13.0 + x_0) : (9.0 + x_1)) : ((3.0 + x_3) > ((11.0 + x_4) > (11.0 + x_5)? (11.0 + x_4) : (11.0 + x_5))? (3.0 + x_3) : ((11.0 + x_4) > (11.0 + x_5)? (11.0 + x_4) : (11.0 + x_5)))) > (((3.0 + x_9) > (7.0 + x_10)? (3.0 + x_9) : (7.0 + x_10)) > ((20.0 + x_11) > ((6.0 + x_14) > (3.0 + x_16)? (6.0 + x_14) : (3.0 + x_16))? (20.0 + x_11) : ((6.0 + x_14) > (3.0 + x_16)? (6.0 + x_14) : (3.0 + x_16)))? ((3.0 + x_9) > (7.0 + x_10)? (3.0 + x_9) : (7.0 + x_10)) : ((20.0 + x_11) > ((6.0 + x_14) > (3.0 + x_16)? (6.0 + x_14) : (3.0 + x_16))? (20.0 + x_11) : ((6.0 + x_14) > (3.0 + x_16)? (6.0 + x_14) : (3.0 + x_16))))? (((13.0 + x_0) > (9.0 + x_1)? (13.0 + x_0) : (9.0 + x_1)) > ((3.0 + x_3) > ((11.0 + x_4) > (11.0 + x_5)? (11.0 + x_4) : (11.0 + x_5))? (3.0 + x_3) : ((11.0 + x_4) > (11.0 + x_5)? (11.0 + x_4) : (11.0 + x_5)))? ((13.0 + x_0) > (9.0 + x_1)? (13.0 + x_0) : (9.0 + x_1)) : ((3.0 + x_3) > ((11.0 + x_4) > (11.0 + x_5)? (11.0 + x_4) : (11.0 + x_5))? (3.0 + x_3) : ((11.0 + x_4) > (11.0 + x_5)? (11.0 + x_4) : (11.0 + x_5)))) : (((3.0 + x_9) > (7.0 + x_10)? (3.0 + x_9) : (7.0 + x_10)) > ((20.0 + x_11) > ((6.0 + x_14) > (3.0 + x_16)? (6.0 + x_14) : (3.0 + x_16))? (20.0 + x_11) : ((6.0 + x_14) > (3.0 + x_16)? (6.0 + x_14) : (3.0 + x_16)))? ((3.0 + x_9) > (7.0 + x_10)? (3.0 + x_9) : (7.0 + x_10)) : ((20.0 + x_11) > ((6.0 + x_14) > (3.0 + x_16)? (6.0 + x_14) : (3.0 + x_16))? (20.0 + x_11) : ((6.0 + x_14) > (3.0 + x_16)? (6.0 + x_14) : (3.0 + x_16))))) > ((((10.0 + x_19) > (12.0 + x_20)? (10.0 + x_19) : (12.0 + x_20)) > ((2.0 + x_21) > ((14.0 + x_22) > (8.0 + x_26)? (14.0 + x_22) : (8.0 + x_26))? (2.0 + x_21) : ((14.0 + x_22) > (8.0 + x_26)? (14.0 + x_22) : (8.0 + x_26)))? ((10.0 + x_19) > (12.0 + x_20)? (10.0 + x_19) : (12.0 + x_20)) : ((2.0 + x_21) > ((14.0 + x_22) > (8.0 + x_26)? (14.0 + x_22) : (8.0 + x_26))? (2.0 + x_21) : ((14.0 + x_22) > (8.0 + x_26)? (14.0 + x_22) : (8.0 + x_26)))) > (((12.0 + x_27) > (10.0 + x_29)? (12.0 + x_27) : (10.0 + x_29)) > ((13.0 + x_32) > ((8.0 + x_33) > (2.0 + x_37)? (8.0 + x_33) : (2.0 + x_37))? (13.0 + x_32) : ((8.0 + x_33) > (2.0 + x_37)? (8.0 + x_33) : (2.0 + x_37)))? ((12.0 + x_27) > (10.0 + x_29)? (12.0 + x_27) : (10.0 + x_29)) : ((13.0 + x_32) > ((8.0 + x_33) > (2.0 + x_37)? (8.0 + x_33) : (2.0 + x_37))? (13.0 + x_32) : ((8.0 + x_33) > (2.0 + x_37)? (8.0 + x_33) : (2.0 + x_37))))? (((10.0 + x_19) > (12.0 + x_20)? (10.0 + x_19) : (12.0 + x_20)) > ((2.0 + x_21) > ((14.0 + x_22) > (8.0 + x_26)? (14.0 + x_22) : (8.0 + x_26))? (2.0 + x_21) : ((14.0 + x_22) > (8.0 + x_26)? (14.0 + x_22) : (8.0 + x_26)))? ((10.0 + x_19) > (12.0 + x_20)? (10.0 + x_19) : (12.0 + x_20)) : ((2.0 + x_21) > ((14.0 + x_22) > (8.0 + x_26)? (14.0 + x_22) : (8.0 + x_26))? (2.0 + x_21) : ((14.0 + x_22) > (8.0 + x_26)? (14.0 + x_22) : (8.0 + x_26)))) : (((12.0 + x_27) > (10.0 + x_29)? (12.0 + x_27) : (10.0 + x_29)) > ((13.0 + x_32) > ((8.0 + x_33) > (2.0 + x_37)? (8.0 + x_33) : (2.0 + x_37))? (13.0 + x_32) : ((8.0 + x_33) > (2.0 + x_37)? (8.0 + x_33) : (2.0 + x_37)))? ((12.0 + x_27) > (10.0 + x_29)? (12.0 + x_27) : (10.0 + x_29)) : ((13.0 + x_32) > ((8.0 + x_33) > (2.0 + x_37)? (8.0 + x_33) : (2.0 + x_37))? (13.0 + x_32) : ((8.0 + x_33) > (2.0 + x_37)? (8.0 + x_33) : (2.0 + x_37)))))? ((((13.0 + x_0) > (9.0 + x_1)? (13.0 + x_0) : (9.0 + x_1)) > ((3.0 + x_3) > ((11.0 + x_4) > (11.0 + x_5)? (11.0 + x_4) : (11.0 + x_5))? (3.0 + x_3) : ((11.0 + x_4) > (11.0 + x_5)? (11.0 + x_4) : (11.0 + x_5)))? ((13.0 + x_0) > (9.0 + x_1)? (13.0 + x_0) : (9.0 + x_1)) : ((3.0 + x_3) > ((11.0 + x_4) > (11.0 + x_5)? (11.0 + x_4) : (11.0 + x_5))? (3.0 + x_3) : ((11.0 + x_4) > (11.0 + x_5)? (11.0 + x_4) : (11.0 + x_5)))) > (((3.0 + x_9) > (7.0 + x_10)? (3.0 + x_9) : (7.0 + x_10)) > ((20.0 + x_11) > ((6.0 + x_14) > (3.0 + x_16)? (6.0 + x_14) : (3.0 + x_16))? (20.0 + x_11) : ((6.0 + x_14) > (3.0 + x_16)? (6.0 + x_14) : (3.0 + x_16)))? ((3.0 + x_9) > (7.0 + x_10)? (3.0 + x_9) : (7.0 + x_10)) : ((20.0 + x_11) > ((6.0 + x_14) > (3.0 + x_16)? (6.0 + x_14) : (3.0 + x_16))? (20.0 + x_11) : ((6.0 + x_14) > (3.0 + x_16)? (6.0 + x_14) : (3.0 + x_16))))? (((13.0 + x_0) > (9.0 + x_1)? (13.0 + x_0) : (9.0 + x_1)) > ((3.0 + x_3) > ((11.0 + x_4) > (11.0 + x_5)? (11.0 + x_4) : (11.0 + x_5))? (3.0 + x_3) : ((11.0 + x_4) > (11.0 + x_5)? (11.0 + x_4) : (11.0 + x_5)))? ((13.0 + x_0) > (9.0 + x_1)? (13.0 + x_0) : (9.0 + x_1)) : ((3.0 + x_3) > ((11.0 + x_4) > (11.0 + x_5)? (11.0 + x_4) : (11.0 + x_5))? (3.0 + x_3) : ((11.0 + x_4) > (11.0 + x_5)? (11.0 + x_4) : (11.0 + x_5)))) : (((3.0 + x_9) > (7.0 + x_10)? (3.0 + x_9) : (7.0 + x_10)) > ((20.0 + x_11) > ((6.0 + x_14) > (3.0 + x_16)? (6.0 + x_14) : (3.0 + x_16))? (20.0 + x_11) : ((6.0 + x_14) > (3.0 + x_16)? (6.0 + x_14) : (3.0 + x_16)))? ((3.0 + x_9) > (7.0 + x_10)? (3.0 + x_9) : (7.0 + x_10)) : ((20.0 + x_11) > ((6.0 + x_14) > (3.0 + x_16)? (6.0 + x_14) : (3.0 + x_16))? (20.0 + x_11) : ((6.0 + x_14) > (3.0 + x_16)? (6.0 + x_14) : (3.0 + x_16))))) : ((((10.0 + x_19) > (12.0 + x_20)? (10.0 + x_19) : (12.0 + x_20)) > ((2.0 + x_21) > ((14.0 + x_22) > (8.0 + x_26)? (14.0 + x_22) : (8.0 + x_26))? (2.0 + x_21) : ((14.0 + x_22) > (8.0 + x_26)? (14.0 + x_22) : (8.0 + x_26)))? ((10.0 + x_19) > (12.0 + x_20)? (10.0 + x_19) : (12.0 + x_20)) : ((2.0 + x_21) > ((14.0 + x_22) > (8.0 + x_26)? (14.0 + x_22) : (8.0 + x_26))? (2.0 + x_21) : ((14.0 + x_22) > (8.0 + x_26)? (14.0 + x_22) : (8.0 + x_26)))) > (((12.0 + x_27) > (10.0 + x_29)? (12.0 + x_27) : (10.0 + x_29)) > ((13.0 + x_32) > ((8.0 + x_33) > (2.0 + x_37)? (8.0 + x_33) : (2.0 + x_37))? (13.0 + x_32) : ((8.0 + x_33) > (2.0 + x_37)? (8.0 + x_33) : (2.0 + x_37)))? ((12.0 + x_27) > (10.0 + x_29)? (12.0 + x_27) : (10.0 + x_29)) : ((13.0 + x_32) > ((8.0 + x_33) > (2.0 + x_37)? (8.0 + x_33) : (2.0 + x_37))? (13.0 + x_32) : ((8.0 + x_33) > (2.0 + x_37)? (8.0 + x_33) : (2.0 + x_37))))? (((10.0 + x_19) > (12.0 + x_20)? (10.0 + x_19) : (12.0 + x_20)) > ((2.0 + x_21) > ((14.0 + x_22) > (8.0 + x_26)? (14.0 + x_22) : (8.0 + x_26))? (2.0 + x_21) : ((14.0 + x_22) > (8.0 + x_26)? (14.0 + x_22) : (8.0 + x_26)))? ((10.0 + x_19) > (12.0 + x_20)? (10.0 + x_19) : (12.0 + x_20)) : ((2.0 + x_21) > ((14.0 + x_22) > (8.0 + x_26)? (14.0 + x_22) : (8.0 + x_26))? (2.0 + x_21) : ((14.0 + x_22) > (8.0 + x_26)? (14.0 + x_22) : (8.0 + x_26)))) : (((12.0 + x_27) > (10.0 + x_29)? (12.0 + x_27) : (10.0 + x_29)) > ((13.0 + x_32) > ((8.0 + x_33) > (2.0 + x_37)? (8.0 + x_33) : (2.0 + x_37))? (13.0 + x_32) : ((8.0 + x_33) > (2.0 + x_37)? (8.0 + x_33) : (2.0 + x_37)))? ((12.0 + x_27) > (10.0 + x_29)? (12.0 + x_27) : (10.0 + x_29)) : ((13.0 + x_32) > ((8.0 + x_33) > (2.0 + x_37)? (8.0 + x_33) : (2.0 + x_37))? (13.0 + x_32) : ((8.0 + x_33) > (2.0 + x_37)? (8.0 + x_33) : (2.0 + x_37))))));
x_21_ = (((((17.0 + x_0) > (19.0 + x_1)? (17.0 + x_0) : (19.0 + x_1)) > ((8.0 + x_4) > ((9.0 + x_5) > (7.0 + x_6)? (9.0 + x_5) : (7.0 + x_6))? (8.0 + x_4) : ((9.0 + x_5) > (7.0 + x_6)? (9.0 + x_5) : (7.0 + x_6)))? ((17.0 + x_0) > (19.0 + x_1)? (17.0 + x_0) : (19.0 + x_1)) : ((8.0 + x_4) > ((9.0 + x_5) > (7.0 + x_6)? (9.0 + x_5) : (7.0 + x_6))? (8.0 + x_4) : ((9.0 + x_5) > (7.0 + x_6)? (9.0 + x_5) : (7.0 + x_6)))) > (((18.0 + x_7) > (12.0 + x_8)? (18.0 + x_7) : (12.0 + x_8)) > ((3.0 + x_9) > ((3.0 + x_10) > (1.0 + x_11)? (3.0 + x_10) : (1.0 + x_11))? (3.0 + x_9) : ((3.0 + x_10) > (1.0 + x_11)? (3.0 + x_10) : (1.0 + x_11)))? ((18.0 + x_7) > (12.0 + x_8)? (18.0 + x_7) : (12.0 + x_8)) : ((3.0 + x_9) > ((3.0 + x_10) > (1.0 + x_11)? (3.0 + x_10) : (1.0 + x_11))? (3.0 + x_9) : ((3.0 + x_10) > (1.0 + x_11)? (3.0 + x_10) : (1.0 + x_11))))? (((17.0 + x_0) > (19.0 + x_1)? (17.0 + x_0) : (19.0 + x_1)) > ((8.0 + x_4) > ((9.0 + x_5) > (7.0 + x_6)? (9.0 + x_5) : (7.0 + x_6))? (8.0 + x_4) : ((9.0 + x_5) > (7.0 + x_6)? (9.0 + x_5) : (7.0 + x_6)))? ((17.0 + x_0) > (19.0 + x_1)? (17.0 + x_0) : (19.0 + x_1)) : ((8.0 + x_4) > ((9.0 + x_5) > (7.0 + x_6)? (9.0 + x_5) : (7.0 + x_6))? (8.0 + x_4) : ((9.0 + x_5) > (7.0 + x_6)? (9.0 + x_5) : (7.0 + x_6)))) : (((18.0 + x_7) > (12.0 + x_8)? (18.0 + x_7) : (12.0 + x_8)) > ((3.0 + x_9) > ((3.0 + x_10) > (1.0 + x_11)? (3.0 + x_10) : (1.0 + x_11))? (3.0 + x_9) : ((3.0 + x_10) > (1.0 + x_11)? (3.0 + x_10) : (1.0 + x_11)))? ((18.0 + x_7) > (12.0 + x_8)? (18.0 + x_7) : (12.0 + x_8)) : ((3.0 + x_9) > ((3.0 + x_10) > (1.0 + x_11)? (3.0 + x_10) : (1.0 + x_11))? (3.0 + x_9) : ((3.0 + x_10) > (1.0 + x_11)? (3.0 + x_10) : (1.0 + x_11))))) > ((((11.0 + x_12) > (5.0 + x_13)? (11.0 + x_12) : (5.0 + x_13)) > ((11.0 + x_15) > ((13.0 + x_25) > (1.0 + x_29)? (13.0 + x_25) : (1.0 + x_29))? (11.0 + x_15) : ((13.0 + x_25) > (1.0 + x_29)? (13.0 + x_25) : (1.0 + x_29)))? ((11.0 + x_12) > (5.0 + x_13)? (11.0 + x_12) : (5.0 + x_13)) : ((11.0 + x_15) > ((13.0 + x_25) > (1.0 + x_29)? (13.0 + x_25) : (1.0 + x_29))? (11.0 + x_15) : ((13.0 + x_25) > (1.0 + x_29)? (13.0 + x_25) : (1.0 + x_29)))) > (((4.0 + x_31) > (9.0 + x_33)? (4.0 + x_31) : (9.0 + x_33)) > ((5.0 + x_34) > ((18.0 + x_35) > (8.0 + x_38)? (18.0 + x_35) : (8.0 + x_38))? (5.0 + x_34) : ((18.0 + x_35) > (8.0 + x_38)? (18.0 + x_35) : (8.0 + x_38)))? ((4.0 + x_31) > (9.0 + x_33)? (4.0 + x_31) : (9.0 + x_33)) : ((5.0 + x_34) > ((18.0 + x_35) > (8.0 + x_38)? (18.0 + x_35) : (8.0 + x_38))? (5.0 + x_34) : ((18.0 + x_35) > (8.0 + x_38)? (18.0 + x_35) : (8.0 + x_38))))? (((11.0 + x_12) > (5.0 + x_13)? (11.0 + x_12) : (5.0 + x_13)) > ((11.0 + x_15) > ((13.0 + x_25) > (1.0 + x_29)? (13.0 + x_25) : (1.0 + x_29))? (11.0 + x_15) : ((13.0 + x_25) > (1.0 + x_29)? (13.0 + x_25) : (1.0 + x_29)))? ((11.0 + x_12) > (5.0 + x_13)? (11.0 + x_12) : (5.0 + x_13)) : ((11.0 + x_15) > ((13.0 + x_25) > (1.0 + x_29)? (13.0 + x_25) : (1.0 + x_29))? (11.0 + x_15) : ((13.0 + x_25) > (1.0 + x_29)? (13.0 + x_25) : (1.0 + x_29)))) : (((4.0 + x_31) > (9.0 + x_33)? (4.0 + x_31) : (9.0 + x_33)) > ((5.0 + x_34) > ((18.0 + x_35) > (8.0 + x_38)? (18.0 + x_35) : (8.0 + x_38))? (5.0 + x_34) : ((18.0 + x_35) > (8.0 + x_38)? (18.0 + x_35) : (8.0 + x_38)))? ((4.0 + x_31) > (9.0 + x_33)? (4.0 + x_31) : (9.0 + x_33)) : ((5.0 + x_34) > ((18.0 + x_35) > (8.0 + x_38)? (18.0 + x_35) : (8.0 + x_38))? (5.0 + x_34) : ((18.0 + x_35) > (8.0 + x_38)? (18.0 + x_35) : (8.0 + x_38)))))? ((((17.0 + x_0) > (19.0 + x_1)? (17.0 + x_0) : (19.0 + x_1)) > ((8.0 + x_4) > ((9.0 + x_5) > (7.0 + x_6)? (9.0 + x_5) : (7.0 + x_6))? (8.0 + x_4) : ((9.0 + x_5) > (7.0 + x_6)? (9.0 + x_5) : (7.0 + x_6)))? ((17.0 + x_0) > (19.0 + x_1)? (17.0 + x_0) : (19.0 + x_1)) : ((8.0 + x_4) > ((9.0 + x_5) > (7.0 + x_6)? (9.0 + x_5) : (7.0 + x_6))? (8.0 + x_4) : ((9.0 + x_5) > (7.0 + x_6)? (9.0 + x_5) : (7.0 + x_6)))) > (((18.0 + x_7) > (12.0 + x_8)? (18.0 + x_7) : (12.0 + x_8)) > ((3.0 + x_9) > ((3.0 + x_10) > (1.0 + x_11)? (3.0 + x_10) : (1.0 + x_11))? (3.0 + x_9) : ((3.0 + x_10) > (1.0 + x_11)? (3.0 + x_10) : (1.0 + x_11)))? ((18.0 + x_7) > (12.0 + x_8)? (18.0 + x_7) : (12.0 + x_8)) : ((3.0 + x_9) > ((3.0 + x_10) > (1.0 + x_11)? (3.0 + x_10) : (1.0 + x_11))? (3.0 + x_9) : ((3.0 + x_10) > (1.0 + x_11)? (3.0 + x_10) : (1.0 + x_11))))? (((17.0 + x_0) > (19.0 + x_1)? (17.0 + x_0) : (19.0 + x_1)) > ((8.0 + x_4) > ((9.0 + x_5) > (7.0 + x_6)? (9.0 + x_5) : (7.0 + x_6))? (8.0 + x_4) : ((9.0 + x_5) > (7.0 + x_6)? (9.0 + x_5) : (7.0 + x_6)))? ((17.0 + x_0) > (19.0 + x_1)? (17.0 + x_0) : (19.0 + x_1)) : ((8.0 + x_4) > ((9.0 + x_5) > (7.0 + x_6)? (9.0 + x_5) : (7.0 + x_6))? (8.0 + x_4) : ((9.0 + x_5) > (7.0 + x_6)? (9.0 + x_5) : (7.0 + x_6)))) : (((18.0 + x_7) > (12.0 + x_8)? (18.0 + x_7) : (12.0 + x_8)) > ((3.0 + x_9) > ((3.0 + x_10) > (1.0 + x_11)? (3.0 + x_10) : (1.0 + x_11))? (3.0 + x_9) : ((3.0 + x_10) > (1.0 + x_11)? (3.0 + x_10) : (1.0 + x_11)))? ((18.0 + x_7) > (12.0 + x_8)? (18.0 + x_7) : (12.0 + x_8)) : ((3.0 + x_9) > ((3.0 + x_10) > (1.0 + x_11)? (3.0 + x_10) : (1.0 + x_11))? (3.0 + x_9) : ((3.0 + x_10) > (1.0 + x_11)? (3.0 + x_10) : (1.0 + x_11))))) : ((((11.0 + x_12) > (5.0 + x_13)? (11.0 + x_12) : (5.0 + x_13)) > ((11.0 + x_15) > ((13.0 + x_25) > (1.0 + x_29)? (13.0 + x_25) : (1.0 + x_29))? (11.0 + x_15) : ((13.0 + x_25) > (1.0 + x_29)? (13.0 + x_25) : (1.0 + x_29)))? ((11.0 + x_12) > (5.0 + x_13)? (11.0 + x_12) : (5.0 + x_13)) : ((11.0 + x_15) > ((13.0 + x_25) > (1.0 + x_29)? (13.0 + x_25) : (1.0 + x_29))? (11.0 + x_15) : ((13.0 + x_25) > (1.0 + x_29)? (13.0 + x_25) : (1.0 + x_29)))) > (((4.0 + x_31) > (9.0 + x_33)? (4.0 + x_31) : (9.0 + x_33)) > ((5.0 + x_34) > ((18.0 + x_35) > (8.0 + x_38)? (18.0 + x_35) : (8.0 + x_38))? (5.0 + x_34) : ((18.0 + x_35) > (8.0 + x_38)? (18.0 + x_35) : (8.0 + x_38)))? ((4.0 + x_31) > (9.0 + x_33)? (4.0 + x_31) : (9.0 + x_33)) : ((5.0 + x_34) > ((18.0 + x_35) > (8.0 + x_38)? (18.0 + x_35) : (8.0 + x_38))? (5.0 + x_34) : ((18.0 + x_35) > (8.0 + x_38)? (18.0 + x_35) : (8.0 + x_38))))? (((11.0 + x_12) > (5.0 + x_13)? (11.0 + x_12) : (5.0 + x_13)) > ((11.0 + x_15) > ((13.0 + x_25) > (1.0 + x_29)? (13.0 + x_25) : (1.0 + x_29))? (11.0 + x_15) : ((13.0 + x_25) > (1.0 + x_29)? (13.0 + x_25) : (1.0 + x_29)))? ((11.0 + x_12) > (5.0 + x_13)? (11.0 + x_12) : (5.0 + x_13)) : ((11.0 + x_15) > ((13.0 + x_25) > (1.0 + x_29)? (13.0 + x_25) : (1.0 + x_29))? (11.0 + x_15) : ((13.0 + x_25) > (1.0 + x_29)? (13.0 + x_25) : (1.0 + x_29)))) : (((4.0 + x_31) > (9.0 + x_33)? (4.0 + x_31) : (9.0 + x_33)) > ((5.0 + x_34) > ((18.0 + x_35) > (8.0 + x_38)? (18.0 + x_35) : (8.0 + x_38))? (5.0 + x_34) : ((18.0 + x_35) > (8.0 + x_38)? (18.0 + x_35) : (8.0 + x_38)))? ((4.0 + x_31) > (9.0 + x_33)? (4.0 + x_31) : (9.0 + x_33)) : ((5.0 + x_34) > ((18.0 + x_35) > (8.0 + x_38)? (18.0 + x_35) : (8.0 + x_38))? (5.0 + x_34) : ((18.0 + x_35) > (8.0 + x_38)? (18.0 + x_35) : (8.0 + x_38))))));
x_22_ = (((((16.0 + x_0) > (18.0 + x_2)? (16.0 + x_0) : (18.0 + x_2)) > ((7.0 + x_8) > ((18.0 + x_9) > (13.0 + x_11)? (18.0 + x_9) : (13.0 + x_11))? (7.0 + x_8) : ((18.0 + x_9) > (13.0 + x_11)? (18.0 + x_9) : (13.0 + x_11)))? ((16.0 + x_0) > (18.0 + x_2)? (16.0 + x_0) : (18.0 + x_2)) : ((7.0 + x_8) > ((18.0 + x_9) > (13.0 + x_11)? (18.0 + x_9) : (13.0 + x_11))? (7.0 + x_8) : ((18.0 + x_9) > (13.0 + x_11)? (18.0 + x_9) : (13.0 + x_11)))) > (((7.0 + x_12) > (18.0 + x_14)? (7.0 + x_12) : (18.0 + x_14)) > ((16.0 + x_17) > ((14.0 + x_19) > (12.0 + x_20)? (14.0 + x_19) : (12.0 + x_20))? (16.0 + x_17) : ((14.0 + x_19) > (12.0 + x_20)? (14.0 + x_19) : (12.0 + x_20)))? ((7.0 + x_12) > (18.0 + x_14)? (7.0 + x_12) : (18.0 + x_14)) : ((16.0 + x_17) > ((14.0 + x_19) > (12.0 + x_20)? (14.0 + x_19) : (12.0 + x_20))? (16.0 + x_17) : ((14.0 + x_19) > (12.0 + x_20)? (14.0 + x_19) : (12.0 + x_20))))? (((16.0 + x_0) > (18.0 + x_2)? (16.0 + x_0) : (18.0 + x_2)) > ((7.0 + x_8) > ((18.0 + x_9) > (13.0 + x_11)? (18.0 + x_9) : (13.0 + x_11))? (7.0 + x_8) : ((18.0 + x_9) > (13.0 + x_11)? (18.0 + x_9) : (13.0 + x_11)))? ((16.0 + x_0) > (18.0 + x_2)? (16.0 + x_0) : (18.0 + x_2)) : ((7.0 + x_8) > ((18.0 + x_9) > (13.0 + x_11)? (18.0 + x_9) : (13.0 + x_11))? (7.0 + x_8) : ((18.0 + x_9) > (13.0 + x_11)? (18.0 + x_9) : (13.0 + x_11)))) : (((7.0 + x_12) > (18.0 + x_14)? (7.0 + x_12) : (18.0 + x_14)) > ((16.0 + x_17) > ((14.0 + x_19) > (12.0 + x_20)? (14.0 + x_19) : (12.0 + x_20))? (16.0 + x_17) : ((14.0 + x_19) > (12.0 + x_20)? (14.0 + x_19) : (12.0 + x_20)))? ((7.0 + x_12) > (18.0 + x_14)? (7.0 + x_12) : (18.0 + x_14)) : ((16.0 + x_17) > ((14.0 + x_19) > (12.0 + x_20)? (14.0 + x_19) : (12.0 + x_20))? (16.0 + x_17) : ((14.0 + x_19) > (12.0 + x_20)? (14.0 + x_19) : (12.0 + x_20))))) > ((((18.0 + x_22) > (5.0 + x_24)? (18.0 + x_22) : (5.0 + x_24)) > ((1.0 + x_28) > ((6.0 + x_29) > (5.0 + x_30)? (6.0 + x_29) : (5.0 + x_30))? (1.0 + x_28) : ((6.0 + x_29) > (5.0 + x_30)? (6.0 + x_29) : (5.0 + x_30)))? ((18.0 + x_22) > (5.0 + x_24)? (18.0 + x_22) : (5.0 + x_24)) : ((1.0 + x_28) > ((6.0 + x_29) > (5.0 + x_30)? (6.0 + x_29) : (5.0 + x_30))? (1.0 + x_28) : ((6.0 + x_29) > (5.0 + x_30)? (6.0 + x_29) : (5.0 + x_30)))) > (((18.0 + x_31) > (14.0 + x_33)? (18.0 + x_31) : (14.0 + x_33)) > ((10.0 + x_34) > ((6.0 + x_35) > (7.0 + x_37)? (6.0 + x_35) : (7.0 + x_37))? (10.0 + x_34) : ((6.0 + x_35) > (7.0 + x_37)? (6.0 + x_35) : (7.0 + x_37)))? ((18.0 + x_31) > (14.0 + x_33)? (18.0 + x_31) : (14.0 + x_33)) : ((10.0 + x_34) > ((6.0 + x_35) > (7.0 + x_37)? (6.0 + x_35) : (7.0 + x_37))? (10.0 + x_34) : ((6.0 + x_35) > (7.0 + x_37)? (6.0 + x_35) : (7.0 + x_37))))? (((18.0 + x_22) > (5.0 + x_24)? (18.0 + x_22) : (5.0 + x_24)) > ((1.0 + x_28) > ((6.0 + x_29) > (5.0 + x_30)? (6.0 + x_29) : (5.0 + x_30))? (1.0 + x_28) : ((6.0 + x_29) > (5.0 + x_30)? (6.0 + x_29) : (5.0 + x_30)))? ((18.0 + x_22) > (5.0 + x_24)? (18.0 + x_22) : (5.0 + x_24)) : ((1.0 + x_28) > ((6.0 + x_29) > (5.0 + x_30)? (6.0 + x_29) : (5.0 + x_30))? (1.0 + x_28) : ((6.0 + x_29) > (5.0 + x_30)? (6.0 + x_29) : (5.0 + x_30)))) : (((18.0 + x_31) > (14.0 + x_33)? (18.0 + x_31) : (14.0 + x_33)) > ((10.0 + x_34) > ((6.0 + x_35) > (7.0 + x_37)? (6.0 + x_35) : (7.0 + x_37))? (10.0 + x_34) : ((6.0 + x_35) > (7.0 + x_37)? (6.0 + x_35) : (7.0 + x_37)))? ((18.0 + x_31) > (14.0 + x_33)? (18.0 + x_31) : (14.0 + x_33)) : ((10.0 + x_34) > ((6.0 + x_35) > (7.0 + x_37)? (6.0 + x_35) : (7.0 + x_37))? (10.0 + x_34) : ((6.0 + x_35) > (7.0 + x_37)? (6.0 + x_35) : (7.0 + x_37)))))? ((((16.0 + x_0) > (18.0 + x_2)? (16.0 + x_0) : (18.0 + x_2)) > ((7.0 + x_8) > ((18.0 + x_9) > (13.0 + x_11)? (18.0 + x_9) : (13.0 + x_11))? (7.0 + x_8) : ((18.0 + x_9) > (13.0 + x_11)? (18.0 + x_9) : (13.0 + x_11)))? ((16.0 + x_0) > (18.0 + x_2)? (16.0 + x_0) : (18.0 + x_2)) : ((7.0 + x_8) > ((18.0 + x_9) > (13.0 + x_11)? (18.0 + x_9) : (13.0 + x_11))? (7.0 + x_8) : ((18.0 + x_9) > (13.0 + x_11)? (18.0 + x_9) : (13.0 + x_11)))) > (((7.0 + x_12) > (18.0 + x_14)? (7.0 + x_12) : (18.0 + x_14)) > ((16.0 + x_17) > ((14.0 + x_19) > (12.0 + x_20)? (14.0 + x_19) : (12.0 + x_20))? (16.0 + x_17) : ((14.0 + x_19) > (12.0 + x_20)? (14.0 + x_19) : (12.0 + x_20)))? ((7.0 + x_12) > (18.0 + x_14)? (7.0 + x_12) : (18.0 + x_14)) : ((16.0 + x_17) > ((14.0 + x_19) > (12.0 + x_20)? (14.0 + x_19) : (12.0 + x_20))? (16.0 + x_17) : ((14.0 + x_19) > (12.0 + x_20)? (14.0 + x_19) : (12.0 + x_20))))? (((16.0 + x_0) > (18.0 + x_2)? (16.0 + x_0) : (18.0 + x_2)) > ((7.0 + x_8) > ((18.0 + x_9) > (13.0 + x_11)? (18.0 + x_9) : (13.0 + x_11))? (7.0 + x_8) : ((18.0 + x_9) > (13.0 + x_11)? (18.0 + x_9) : (13.0 + x_11)))? ((16.0 + x_0) > (18.0 + x_2)? (16.0 + x_0) : (18.0 + x_2)) : ((7.0 + x_8) > ((18.0 + x_9) > (13.0 + x_11)? (18.0 + x_9) : (13.0 + x_11))? (7.0 + x_8) : ((18.0 + x_9) > (13.0 + x_11)? (18.0 + x_9) : (13.0 + x_11)))) : (((7.0 + x_12) > (18.0 + x_14)? (7.0 + x_12) : (18.0 + x_14)) > ((16.0 + x_17) > ((14.0 + x_19) > (12.0 + x_20)? (14.0 + x_19) : (12.0 + x_20))? (16.0 + x_17) : ((14.0 + x_19) > (12.0 + x_20)? (14.0 + x_19) : (12.0 + x_20)))? ((7.0 + x_12) > (18.0 + x_14)? (7.0 + x_12) : (18.0 + x_14)) : ((16.0 + x_17) > ((14.0 + x_19) > (12.0 + x_20)? (14.0 + x_19) : (12.0 + x_20))? (16.0 + x_17) : ((14.0 + x_19) > (12.0 + x_20)? (14.0 + x_19) : (12.0 + x_20))))) : ((((18.0 + x_22) > (5.0 + x_24)? (18.0 + x_22) : (5.0 + x_24)) > ((1.0 + x_28) > ((6.0 + x_29) > (5.0 + x_30)? (6.0 + x_29) : (5.0 + x_30))? (1.0 + x_28) : ((6.0 + x_29) > (5.0 + x_30)? (6.0 + x_29) : (5.0 + x_30)))? ((18.0 + x_22) > (5.0 + x_24)? (18.0 + x_22) : (5.0 + x_24)) : ((1.0 + x_28) > ((6.0 + x_29) > (5.0 + x_30)? (6.0 + x_29) : (5.0 + x_30))? (1.0 + x_28) : ((6.0 + x_29) > (5.0 + x_30)? (6.0 + x_29) : (5.0 + x_30)))) > (((18.0 + x_31) > (14.0 + x_33)? (18.0 + x_31) : (14.0 + x_33)) > ((10.0 + x_34) > ((6.0 + x_35) > (7.0 + x_37)? (6.0 + x_35) : (7.0 + x_37))? (10.0 + x_34) : ((6.0 + x_35) > (7.0 + x_37)? (6.0 + x_35) : (7.0 + x_37)))? ((18.0 + x_31) > (14.0 + x_33)? (18.0 + x_31) : (14.0 + x_33)) : ((10.0 + x_34) > ((6.0 + x_35) > (7.0 + x_37)? (6.0 + x_35) : (7.0 + x_37))? (10.0 + x_34) : ((6.0 + x_35) > (7.0 + x_37)? (6.0 + x_35) : (7.0 + x_37))))? (((18.0 + x_22) > (5.0 + x_24)? (18.0 + x_22) : (5.0 + x_24)) > ((1.0 + x_28) > ((6.0 + x_29) > (5.0 + x_30)? (6.0 + x_29) : (5.0 + x_30))? (1.0 + x_28) : ((6.0 + x_29) > (5.0 + x_30)? (6.0 + x_29) : (5.0 + x_30)))? ((18.0 + x_22) > (5.0 + x_24)? (18.0 + x_22) : (5.0 + x_24)) : ((1.0 + x_28) > ((6.0 + x_29) > (5.0 + x_30)? (6.0 + x_29) : (5.0 + x_30))? (1.0 + x_28) : ((6.0 + x_29) > (5.0 + x_30)? (6.0 + x_29) : (5.0 + x_30)))) : (((18.0 + x_31) > (14.0 + x_33)? (18.0 + x_31) : (14.0 + x_33)) > ((10.0 + x_34) > ((6.0 + x_35) > (7.0 + x_37)? (6.0 + x_35) : (7.0 + x_37))? (10.0 + x_34) : ((6.0 + x_35) > (7.0 + x_37)? (6.0 + x_35) : (7.0 + x_37)))? ((18.0 + x_31) > (14.0 + x_33)? (18.0 + x_31) : (14.0 + x_33)) : ((10.0 + x_34) > ((6.0 + x_35) > (7.0 + x_37)? (6.0 + x_35) : (7.0 + x_37))? (10.0 + x_34) : ((6.0 + x_35) > (7.0 + x_37)? (6.0 + x_35) : (7.0 + x_37))))));
x_23_ = (((((7.0 + x_5) > (16.0 + x_6)? (7.0 + x_5) : (16.0 + x_6)) > ((9.0 + x_7) > ((4.0 + x_8) > (19.0 + x_9)? (4.0 + x_8) : (19.0 + x_9))? (9.0 + x_7) : ((4.0 + x_8) > (19.0 + x_9)? (4.0 + x_8) : (19.0 + x_9)))? ((7.0 + x_5) > (16.0 + x_6)? (7.0 + x_5) : (16.0 + x_6)) : ((9.0 + x_7) > ((4.0 + x_8) > (19.0 + x_9)? (4.0 + x_8) : (19.0 + x_9))? (9.0 + x_7) : ((4.0 + x_8) > (19.0 + x_9)? (4.0 + x_8) : (19.0 + x_9)))) > (((15.0 + x_10) > (4.0 + x_11)? (15.0 + x_10) : (4.0 + x_11)) > ((11.0 + x_14) > ((18.0 + x_15) > (7.0 + x_18)? (18.0 + x_15) : (7.0 + x_18))? (11.0 + x_14) : ((18.0 + x_15) > (7.0 + x_18)? (18.0 + x_15) : (7.0 + x_18)))? ((15.0 + x_10) > (4.0 + x_11)? (15.0 + x_10) : (4.0 + x_11)) : ((11.0 + x_14) > ((18.0 + x_15) > (7.0 + x_18)? (18.0 + x_15) : (7.0 + x_18))? (11.0 + x_14) : ((18.0 + x_15) > (7.0 + x_18)? (18.0 + x_15) : (7.0 + x_18))))? (((7.0 + x_5) > (16.0 + x_6)? (7.0 + x_5) : (16.0 + x_6)) > ((9.0 + x_7) > ((4.0 + x_8) > (19.0 + x_9)? (4.0 + x_8) : (19.0 + x_9))? (9.0 + x_7) : ((4.0 + x_8) > (19.0 + x_9)? (4.0 + x_8) : (19.0 + x_9)))? ((7.0 + x_5) > (16.0 + x_6)? (7.0 + x_5) : (16.0 + x_6)) : ((9.0 + x_7) > ((4.0 + x_8) > (19.0 + x_9)? (4.0 + x_8) : (19.0 + x_9))? (9.0 + x_7) : ((4.0 + x_8) > (19.0 + x_9)? (4.0 + x_8) : (19.0 + x_9)))) : (((15.0 + x_10) > (4.0 + x_11)? (15.0 + x_10) : (4.0 + x_11)) > ((11.0 + x_14) > ((18.0 + x_15) > (7.0 + x_18)? (18.0 + x_15) : (7.0 + x_18))? (11.0 + x_14) : ((18.0 + x_15) > (7.0 + x_18)? (18.0 + x_15) : (7.0 + x_18)))? ((15.0 + x_10) > (4.0 + x_11)? (15.0 + x_10) : (4.0 + x_11)) : ((11.0 + x_14) > ((18.0 + x_15) > (7.0 + x_18)? (18.0 + x_15) : (7.0 + x_18))? (11.0 + x_14) : ((18.0 + x_15) > (7.0 + x_18)? (18.0 + x_15) : (7.0 + x_18))))) > ((((17.0 + x_19) > (12.0 + x_20)? (17.0 + x_19) : (12.0 + x_20)) > ((11.0 + x_24) > ((17.0 + x_27) > (12.0 + x_29)? (17.0 + x_27) : (12.0 + x_29))? (11.0 + x_24) : ((17.0 + x_27) > (12.0 + x_29)? (17.0 + x_27) : (12.0 + x_29)))? ((17.0 + x_19) > (12.0 + x_20)? (17.0 + x_19) : (12.0 + x_20)) : ((11.0 + x_24) > ((17.0 + x_27) > (12.0 + x_29)? (17.0 + x_27) : (12.0 + x_29))? (11.0 + x_24) : ((17.0 + x_27) > (12.0 + x_29)? (17.0 + x_27) : (12.0 + x_29)))) > (((11.0 + x_32) > (5.0 + x_33)? (11.0 + x_32) : (5.0 + x_33)) > ((3.0 + x_37) > ((11.0 + x_38) > (15.0 + x_39)? (11.0 + x_38) : (15.0 + x_39))? (3.0 + x_37) : ((11.0 + x_38) > (15.0 + x_39)? (11.0 + x_38) : (15.0 + x_39)))? ((11.0 + x_32) > (5.0 + x_33)? (11.0 + x_32) : (5.0 + x_33)) : ((3.0 + x_37) > ((11.0 + x_38) > (15.0 + x_39)? (11.0 + x_38) : (15.0 + x_39))? (3.0 + x_37) : ((11.0 + x_38) > (15.0 + x_39)? (11.0 + x_38) : (15.0 + x_39))))? (((17.0 + x_19) > (12.0 + x_20)? (17.0 + x_19) : (12.0 + x_20)) > ((11.0 + x_24) > ((17.0 + x_27) > (12.0 + x_29)? (17.0 + x_27) : (12.0 + x_29))? (11.0 + x_24) : ((17.0 + x_27) > (12.0 + x_29)? (17.0 + x_27) : (12.0 + x_29)))? ((17.0 + x_19) > (12.0 + x_20)? (17.0 + x_19) : (12.0 + x_20)) : ((11.0 + x_24) > ((17.0 + x_27) > (12.0 + x_29)? (17.0 + x_27) : (12.0 + x_29))? (11.0 + x_24) : ((17.0 + x_27) > (12.0 + x_29)? (17.0 + x_27) : (12.0 + x_29)))) : (((11.0 + x_32) > (5.0 + x_33)? (11.0 + x_32) : (5.0 + x_33)) > ((3.0 + x_37) > ((11.0 + x_38) > (15.0 + x_39)? (11.0 + x_38) : (15.0 + x_39))? (3.0 + x_37) : ((11.0 + x_38) > (15.0 + x_39)? (11.0 + x_38) : (15.0 + x_39)))? ((11.0 + x_32) > (5.0 + x_33)? (11.0 + x_32) : (5.0 + x_33)) : ((3.0 + x_37) > ((11.0 + x_38) > (15.0 + x_39)? (11.0 + x_38) : (15.0 + x_39))? (3.0 + x_37) : ((11.0 + x_38) > (15.0 + x_39)? (11.0 + x_38) : (15.0 + x_39)))))? ((((7.0 + x_5) > (16.0 + x_6)? (7.0 + x_5) : (16.0 + x_6)) > ((9.0 + x_7) > ((4.0 + x_8) > (19.0 + x_9)? (4.0 + x_8) : (19.0 + x_9))? (9.0 + x_7) : ((4.0 + x_8) > (19.0 + x_9)? (4.0 + x_8) : (19.0 + x_9)))? ((7.0 + x_5) > (16.0 + x_6)? (7.0 + x_5) : (16.0 + x_6)) : ((9.0 + x_7) > ((4.0 + x_8) > (19.0 + x_9)? (4.0 + x_8) : (19.0 + x_9))? (9.0 + x_7) : ((4.0 + x_8) > (19.0 + x_9)? (4.0 + x_8) : (19.0 + x_9)))) > (((15.0 + x_10) > (4.0 + x_11)? (15.0 + x_10) : (4.0 + x_11)) > ((11.0 + x_14) > ((18.0 + x_15) > (7.0 + x_18)? (18.0 + x_15) : (7.0 + x_18))? (11.0 + x_14) : ((18.0 + x_15) > (7.0 + x_18)? (18.0 + x_15) : (7.0 + x_18)))? ((15.0 + x_10) > (4.0 + x_11)? (15.0 + x_10) : (4.0 + x_11)) : ((11.0 + x_14) > ((18.0 + x_15) > (7.0 + x_18)? (18.0 + x_15) : (7.0 + x_18))? (11.0 + x_14) : ((18.0 + x_15) > (7.0 + x_18)? (18.0 + x_15) : (7.0 + x_18))))? (((7.0 + x_5) > (16.0 + x_6)? (7.0 + x_5) : (16.0 + x_6)) > ((9.0 + x_7) > ((4.0 + x_8) > (19.0 + x_9)? (4.0 + x_8) : (19.0 + x_9))? (9.0 + x_7) : ((4.0 + x_8) > (19.0 + x_9)? (4.0 + x_8) : (19.0 + x_9)))? ((7.0 + x_5) > (16.0 + x_6)? (7.0 + x_5) : (16.0 + x_6)) : ((9.0 + x_7) > ((4.0 + x_8) > (19.0 + x_9)? (4.0 + x_8) : (19.0 + x_9))? (9.0 + x_7) : ((4.0 + x_8) > (19.0 + x_9)? (4.0 + x_8) : (19.0 + x_9)))) : (((15.0 + x_10) > (4.0 + x_11)? (15.0 + x_10) : (4.0 + x_11)) > ((11.0 + x_14) > ((18.0 + x_15) > (7.0 + x_18)? (18.0 + x_15) : (7.0 + x_18))? (11.0 + x_14) : ((18.0 + x_15) > (7.0 + x_18)? (18.0 + x_15) : (7.0 + x_18)))? ((15.0 + x_10) > (4.0 + x_11)? (15.0 + x_10) : (4.0 + x_11)) : ((11.0 + x_14) > ((18.0 + x_15) > (7.0 + x_18)? (18.0 + x_15) : (7.0 + x_18))? (11.0 + x_14) : ((18.0 + x_15) > (7.0 + x_18)? (18.0 + x_15) : (7.0 + x_18))))) : ((((17.0 + x_19) > (12.0 + x_20)? (17.0 + x_19) : (12.0 + x_20)) > ((11.0 + x_24) > ((17.0 + x_27) > (12.0 + x_29)? (17.0 + x_27) : (12.0 + x_29))? (11.0 + x_24) : ((17.0 + x_27) > (12.0 + x_29)? (17.0 + x_27) : (12.0 + x_29)))? ((17.0 + x_19) > (12.0 + x_20)? (17.0 + x_19) : (12.0 + x_20)) : ((11.0 + x_24) > ((17.0 + x_27) > (12.0 + x_29)? (17.0 + x_27) : (12.0 + x_29))? (11.0 + x_24) : ((17.0 + x_27) > (12.0 + x_29)? (17.0 + x_27) : (12.0 + x_29)))) > (((11.0 + x_32) > (5.0 + x_33)? (11.0 + x_32) : (5.0 + x_33)) > ((3.0 + x_37) > ((11.0 + x_38) > (15.0 + x_39)? (11.0 + x_38) : (15.0 + x_39))? (3.0 + x_37) : ((11.0 + x_38) > (15.0 + x_39)? (11.0 + x_38) : (15.0 + x_39)))? ((11.0 + x_32) > (5.0 + x_33)? (11.0 + x_32) : (5.0 + x_33)) : ((3.0 + x_37) > ((11.0 + x_38) > (15.0 + x_39)? (11.0 + x_38) : (15.0 + x_39))? (3.0 + x_37) : ((11.0 + x_38) > (15.0 + x_39)? (11.0 + x_38) : (15.0 + x_39))))? (((17.0 + x_19) > (12.0 + x_20)? (17.0 + x_19) : (12.0 + x_20)) > ((11.0 + x_24) > ((17.0 + x_27) > (12.0 + x_29)? (17.0 + x_27) : (12.0 + x_29))? (11.0 + x_24) : ((17.0 + x_27) > (12.0 + x_29)? (17.0 + x_27) : (12.0 + x_29)))? ((17.0 + x_19) > (12.0 + x_20)? (17.0 + x_19) : (12.0 + x_20)) : ((11.0 + x_24) > ((17.0 + x_27) > (12.0 + x_29)? (17.0 + x_27) : (12.0 + x_29))? (11.0 + x_24) : ((17.0 + x_27) > (12.0 + x_29)? (17.0 + x_27) : (12.0 + x_29)))) : (((11.0 + x_32) > (5.0 + x_33)? (11.0 + x_32) : (5.0 + x_33)) > ((3.0 + x_37) > ((11.0 + x_38) > (15.0 + x_39)? (11.0 + x_38) : (15.0 + x_39))? (3.0 + x_37) : ((11.0 + x_38) > (15.0 + x_39)? (11.0 + x_38) : (15.0 + x_39)))? ((11.0 + x_32) > (5.0 + x_33)? (11.0 + x_32) : (5.0 + x_33)) : ((3.0 + x_37) > ((11.0 + x_38) > (15.0 + x_39)? (11.0 + x_38) : (15.0 + x_39))? (3.0 + x_37) : ((11.0 + x_38) > (15.0 + x_39)? (11.0 + x_38) : (15.0 + x_39))))));
x_24_ = (((((20.0 + x_0) > (14.0 + x_2)? (20.0 + x_0) : (14.0 + x_2)) > ((12.0 + x_5) > ((10.0 + x_7) > (7.0 + x_8)? (10.0 + x_7) : (7.0 + x_8))? (12.0 + x_5) : ((10.0 + x_7) > (7.0 + x_8)? (10.0 + x_7) : (7.0 + x_8)))? ((20.0 + x_0) > (14.0 + x_2)? (20.0 + x_0) : (14.0 + x_2)) : ((12.0 + x_5) > ((10.0 + x_7) > (7.0 + x_8)? (10.0 + x_7) : (7.0 + x_8))? (12.0 + x_5) : ((10.0 + x_7) > (7.0 + x_8)? (10.0 + x_7) : (7.0 + x_8)))) > (((5.0 + x_12) > (7.0 + x_13)? (5.0 + x_12) : (7.0 + x_13)) > ((13.0 + x_15) > ((5.0 + x_16) > (6.0 + x_17)? (5.0 + x_16) : (6.0 + x_17))? (13.0 + x_15) : ((5.0 + x_16) > (6.0 + x_17)? (5.0 + x_16) : (6.0 + x_17)))? ((5.0 + x_12) > (7.0 + x_13)? (5.0 + x_12) : (7.0 + x_13)) : ((13.0 + x_15) > ((5.0 + x_16) > (6.0 + x_17)? (5.0 + x_16) : (6.0 + x_17))? (13.0 + x_15) : ((5.0 + x_16) > (6.0 + x_17)? (5.0 + x_16) : (6.0 + x_17))))? (((20.0 + x_0) > (14.0 + x_2)? (20.0 + x_0) : (14.0 + x_2)) > ((12.0 + x_5) > ((10.0 + x_7) > (7.0 + x_8)? (10.0 + x_7) : (7.0 + x_8))? (12.0 + x_5) : ((10.0 + x_7) > (7.0 + x_8)? (10.0 + x_7) : (7.0 + x_8)))? ((20.0 + x_0) > (14.0 + x_2)? (20.0 + x_0) : (14.0 + x_2)) : ((12.0 + x_5) > ((10.0 + x_7) > (7.0 + x_8)? (10.0 + x_7) : (7.0 + x_8))? (12.0 + x_5) : ((10.0 + x_7) > (7.0 + x_8)? (10.0 + x_7) : (7.0 + x_8)))) : (((5.0 + x_12) > (7.0 + x_13)? (5.0 + x_12) : (7.0 + x_13)) > ((13.0 + x_15) > ((5.0 + x_16) > (6.0 + x_17)? (5.0 + x_16) : (6.0 + x_17))? (13.0 + x_15) : ((5.0 + x_16) > (6.0 + x_17)? (5.0 + x_16) : (6.0 + x_17)))? ((5.0 + x_12) > (7.0 + x_13)? (5.0 + x_12) : (7.0 + x_13)) : ((13.0 + x_15) > ((5.0 + x_16) > (6.0 + x_17)? (5.0 + x_16) : (6.0 + x_17))? (13.0 + x_15) : ((5.0 + x_16) > (6.0 + x_17)? (5.0 + x_16) : (6.0 + x_17))))) > ((((2.0 + x_18) > (19.0 + x_21)? (2.0 + x_18) : (19.0 + x_21)) > ((13.0 + x_22) > ((8.0 + x_23) > (6.0 + x_24)? (8.0 + x_23) : (6.0 + x_24))? (13.0 + x_22) : ((8.0 + x_23) > (6.0 + x_24)? (8.0 + x_23) : (6.0 + x_24)))? ((2.0 + x_18) > (19.0 + x_21)? (2.0 + x_18) : (19.0 + x_21)) : ((13.0 + x_22) > ((8.0 + x_23) > (6.0 + x_24)? (8.0 + x_23) : (6.0 + x_24))? (13.0 + x_22) : ((8.0 + x_23) > (6.0 + x_24)? (8.0 + x_23) : (6.0 + x_24)))) > (((17.0 + x_25) > (6.0 + x_33)? (17.0 + x_25) : (6.0 + x_33)) > ((16.0 + x_34) > ((2.0 + x_37) > (17.0 + x_38)? (2.0 + x_37) : (17.0 + x_38))? (16.0 + x_34) : ((2.0 + x_37) > (17.0 + x_38)? (2.0 + x_37) : (17.0 + x_38)))? ((17.0 + x_25) > (6.0 + x_33)? (17.0 + x_25) : (6.0 + x_33)) : ((16.0 + x_34) > ((2.0 + x_37) > (17.0 + x_38)? (2.0 + x_37) : (17.0 + x_38))? (16.0 + x_34) : ((2.0 + x_37) > (17.0 + x_38)? (2.0 + x_37) : (17.0 + x_38))))? (((2.0 + x_18) > (19.0 + x_21)? (2.0 + x_18) : (19.0 + x_21)) > ((13.0 + x_22) > ((8.0 + x_23) > (6.0 + x_24)? (8.0 + x_23) : (6.0 + x_24))? (13.0 + x_22) : ((8.0 + x_23) > (6.0 + x_24)? (8.0 + x_23) : (6.0 + x_24)))? ((2.0 + x_18) > (19.0 + x_21)? (2.0 + x_18) : (19.0 + x_21)) : ((13.0 + x_22) > ((8.0 + x_23) > (6.0 + x_24)? (8.0 + x_23) : (6.0 + x_24))? (13.0 + x_22) : ((8.0 + x_23) > (6.0 + x_24)? (8.0 + x_23) : (6.0 + x_24)))) : (((17.0 + x_25) > (6.0 + x_33)? (17.0 + x_25) : (6.0 + x_33)) > ((16.0 + x_34) > ((2.0 + x_37) > (17.0 + x_38)? (2.0 + x_37) : (17.0 + x_38))? (16.0 + x_34) : ((2.0 + x_37) > (17.0 + x_38)? (2.0 + x_37) : (17.0 + x_38)))? ((17.0 + x_25) > (6.0 + x_33)? (17.0 + x_25) : (6.0 + x_33)) : ((16.0 + x_34) > ((2.0 + x_37) > (17.0 + x_38)? (2.0 + x_37) : (17.0 + x_38))? (16.0 + x_34) : ((2.0 + x_37) > (17.0 + x_38)? (2.0 + x_37) : (17.0 + x_38)))))? ((((20.0 + x_0) > (14.0 + x_2)? (20.0 + x_0) : (14.0 + x_2)) > ((12.0 + x_5) > ((10.0 + x_7) > (7.0 + x_8)? (10.0 + x_7) : (7.0 + x_8))? (12.0 + x_5) : ((10.0 + x_7) > (7.0 + x_8)? (10.0 + x_7) : (7.0 + x_8)))? ((20.0 + x_0) > (14.0 + x_2)? (20.0 + x_0) : (14.0 + x_2)) : ((12.0 + x_5) > ((10.0 + x_7) > (7.0 + x_8)? (10.0 + x_7) : (7.0 + x_8))? (12.0 + x_5) : ((10.0 + x_7) > (7.0 + x_8)? (10.0 + x_7) : (7.0 + x_8)))) > (((5.0 + x_12) > (7.0 + x_13)? (5.0 + x_12) : (7.0 + x_13)) > ((13.0 + x_15) > ((5.0 + x_16) > (6.0 + x_17)? (5.0 + x_16) : (6.0 + x_17))? (13.0 + x_15) : ((5.0 + x_16) > (6.0 + x_17)? (5.0 + x_16) : (6.0 + x_17)))? ((5.0 + x_12) > (7.0 + x_13)? (5.0 + x_12) : (7.0 + x_13)) : ((13.0 + x_15) > ((5.0 + x_16) > (6.0 + x_17)? (5.0 + x_16) : (6.0 + x_17))? (13.0 + x_15) : ((5.0 + x_16) > (6.0 + x_17)? (5.0 + x_16) : (6.0 + x_17))))? (((20.0 + x_0) > (14.0 + x_2)? (20.0 + x_0) : (14.0 + x_2)) > ((12.0 + x_5) > ((10.0 + x_7) > (7.0 + x_8)? (10.0 + x_7) : (7.0 + x_8))? (12.0 + x_5) : ((10.0 + x_7) > (7.0 + x_8)? (10.0 + x_7) : (7.0 + x_8)))? ((20.0 + x_0) > (14.0 + x_2)? (20.0 + x_0) : (14.0 + x_2)) : ((12.0 + x_5) > ((10.0 + x_7) > (7.0 + x_8)? (10.0 + x_7) : (7.0 + x_8))? (12.0 + x_5) : ((10.0 + x_7) > (7.0 + x_8)? (10.0 + x_7) : (7.0 + x_8)))) : (((5.0 + x_12) > (7.0 + x_13)? (5.0 + x_12) : (7.0 + x_13)) > ((13.0 + x_15) > ((5.0 + x_16) > (6.0 + x_17)? (5.0 + x_16) : (6.0 + x_17))? (13.0 + x_15) : ((5.0 + x_16) > (6.0 + x_17)? (5.0 + x_16) : (6.0 + x_17)))? ((5.0 + x_12) > (7.0 + x_13)? (5.0 + x_12) : (7.0 + x_13)) : ((13.0 + x_15) > ((5.0 + x_16) > (6.0 + x_17)? (5.0 + x_16) : (6.0 + x_17))? (13.0 + x_15) : ((5.0 + x_16) > (6.0 + x_17)? (5.0 + x_16) : (6.0 + x_17))))) : ((((2.0 + x_18) > (19.0 + x_21)? (2.0 + x_18) : (19.0 + x_21)) > ((13.0 + x_22) > ((8.0 + x_23) > (6.0 + x_24)? (8.0 + x_23) : (6.0 + x_24))? (13.0 + x_22) : ((8.0 + x_23) > (6.0 + x_24)? (8.0 + x_23) : (6.0 + x_24)))? ((2.0 + x_18) > (19.0 + x_21)? (2.0 + x_18) : (19.0 + x_21)) : ((13.0 + x_22) > ((8.0 + x_23) > (6.0 + x_24)? (8.0 + x_23) : (6.0 + x_24))? (13.0 + x_22) : ((8.0 + x_23) > (6.0 + x_24)? (8.0 + x_23) : (6.0 + x_24)))) > (((17.0 + x_25) > (6.0 + x_33)? (17.0 + x_25) : (6.0 + x_33)) > ((16.0 + x_34) > ((2.0 + x_37) > (17.0 + x_38)? (2.0 + x_37) : (17.0 + x_38))? (16.0 + x_34) : ((2.0 + x_37) > (17.0 + x_38)? (2.0 + x_37) : (17.0 + x_38)))? ((17.0 + x_25) > (6.0 + x_33)? (17.0 + x_25) : (6.0 + x_33)) : ((16.0 + x_34) > ((2.0 + x_37) > (17.0 + x_38)? (2.0 + x_37) : (17.0 + x_38))? (16.0 + x_34) : ((2.0 + x_37) > (17.0 + x_38)? (2.0 + x_37) : (17.0 + x_38))))? (((2.0 + x_18) > (19.0 + x_21)? (2.0 + x_18) : (19.0 + x_21)) > ((13.0 + x_22) > ((8.0 + x_23) > (6.0 + x_24)? (8.0 + x_23) : (6.0 + x_24))? (13.0 + x_22) : ((8.0 + x_23) > (6.0 + x_24)? (8.0 + x_23) : (6.0 + x_24)))? ((2.0 + x_18) > (19.0 + x_21)? (2.0 + x_18) : (19.0 + x_21)) : ((13.0 + x_22) > ((8.0 + x_23) > (6.0 + x_24)? (8.0 + x_23) : (6.0 + x_24))? (13.0 + x_22) : ((8.0 + x_23) > (6.0 + x_24)? (8.0 + x_23) : (6.0 + x_24)))) : (((17.0 + x_25) > (6.0 + x_33)? (17.0 + x_25) : (6.0 + x_33)) > ((16.0 + x_34) > ((2.0 + x_37) > (17.0 + x_38)? (2.0 + x_37) : (17.0 + x_38))? (16.0 + x_34) : ((2.0 + x_37) > (17.0 + x_38)? (2.0 + x_37) : (17.0 + x_38)))? ((17.0 + x_25) > (6.0 + x_33)? (17.0 + x_25) : (6.0 + x_33)) : ((16.0 + x_34) > ((2.0 + x_37) > (17.0 + x_38)? (2.0 + x_37) : (17.0 + x_38))? (16.0 + x_34) : ((2.0 + x_37) > (17.0 + x_38)? (2.0 + x_37) : (17.0 + x_38))))));
x_25_ = (((((4.0 + x_0) > (18.0 + x_4)? (4.0 + x_0) : (18.0 + x_4)) > ((12.0 + x_5) > ((10.0 + x_8) > (19.0 + x_11)? (10.0 + x_8) : (19.0 + x_11))? (12.0 + x_5) : ((10.0 + x_8) > (19.0 + x_11)? (10.0 + x_8) : (19.0 + x_11)))? ((4.0 + x_0) > (18.0 + x_4)? (4.0 + x_0) : (18.0 + x_4)) : ((12.0 + x_5) > ((10.0 + x_8) > (19.0 + x_11)? (10.0 + x_8) : (19.0 + x_11))? (12.0 + x_5) : ((10.0 + x_8) > (19.0 + x_11)? (10.0 + x_8) : (19.0 + x_11)))) > (((5.0 + x_15) > (10.0 + x_16)? (5.0 + x_15) : (10.0 + x_16)) > ((4.0 + x_18) > ((11.0 + x_19) > (2.0 + x_20)? (11.0 + x_19) : (2.0 + x_20))? (4.0 + x_18) : ((11.0 + x_19) > (2.0 + x_20)? (11.0 + x_19) : (2.0 + x_20)))? ((5.0 + x_15) > (10.0 + x_16)? (5.0 + x_15) : (10.0 + x_16)) : ((4.0 + x_18) > ((11.0 + x_19) > (2.0 + x_20)? (11.0 + x_19) : (2.0 + x_20))? (4.0 + x_18) : ((11.0 + x_19) > (2.0 + x_20)? (11.0 + x_19) : (2.0 + x_20))))? (((4.0 + x_0) > (18.0 + x_4)? (4.0 + x_0) : (18.0 + x_4)) > ((12.0 + x_5) > ((10.0 + x_8) > (19.0 + x_11)? (10.0 + x_8) : (19.0 + x_11))? (12.0 + x_5) : ((10.0 + x_8) > (19.0 + x_11)? (10.0 + x_8) : (19.0 + x_11)))? ((4.0 + x_0) > (18.0 + x_4)? (4.0 + x_0) : (18.0 + x_4)) : ((12.0 + x_5) > ((10.0 + x_8) > (19.0 + x_11)? (10.0 + x_8) : (19.0 + x_11))? (12.0 + x_5) : ((10.0 + x_8) > (19.0 + x_11)? (10.0 + x_8) : (19.0 + x_11)))) : (((5.0 + x_15) > (10.0 + x_16)? (5.0 + x_15) : (10.0 + x_16)) > ((4.0 + x_18) > ((11.0 + x_19) > (2.0 + x_20)? (11.0 + x_19) : (2.0 + x_20))? (4.0 + x_18) : ((11.0 + x_19) > (2.0 + x_20)? (11.0 + x_19) : (2.0 + x_20)))? ((5.0 + x_15) > (10.0 + x_16)? (5.0 + x_15) : (10.0 + x_16)) : ((4.0 + x_18) > ((11.0 + x_19) > (2.0 + x_20)? (11.0 + x_19) : (2.0 + x_20))? (4.0 + x_18) : ((11.0 + x_19) > (2.0 + x_20)? (11.0 + x_19) : (2.0 + x_20))))) > ((((13.0 + x_22) > (2.0 + x_24)? (13.0 + x_22) : (2.0 + x_24)) > ((7.0 + x_26) > ((14.0 + x_27) > (2.0 + x_28)? (14.0 + x_27) : (2.0 + x_28))? (7.0 + x_26) : ((14.0 + x_27) > (2.0 + x_28)? (14.0 + x_27) : (2.0 + x_28)))? ((13.0 + x_22) > (2.0 + x_24)? (13.0 + x_22) : (2.0 + x_24)) : ((7.0 + x_26) > ((14.0 + x_27) > (2.0 + x_28)? (14.0 + x_27) : (2.0 + x_28))? (7.0 + x_26) : ((14.0 + x_27) > (2.0 + x_28)? (14.0 + x_27) : (2.0 + x_28)))) > (((13.0 + x_29) > (7.0 + x_31)? (13.0 + x_29) : (7.0 + x_31)) > ((3.0 + x_32) > ((17.0 + x_37) > (11.0 + x_39)? (17.0 + x_37) : (11.0 + x_39))? (3.0 + x_32) : ((17.0 + x_37) > (11.0 + x_39)? (17.0 + x_37) : (11.0 + x_39)))? ((13.0 + x_29) > (7.0 + x_31)? (13.0 + x_29) : (7.0 + x_31)) : ((3.0 + x_32) > ((17.0 + x_37) > (11.0 + x_39)? (17.0 + x_37) : (11.0 + x_39))? (3.0 + x_32) : ((17.0 + x_37) > (11.0 + x_39)? (17.0 + x_37) : (11.0 + x_39))))? (((13.0 + x_22) > (2.0 + x_24)? (13.0 + x_22) : (2.0 + x_24)) > ((7.0 + x_26) > ((14.0 + x_27) > (2.0 + x_28)? (14.0 + x_27) : (2.0 + x_28))? (7.0 + x_26) : ((14.0 + x_27) > (2.0 + x_28)? (14.0 + x_27) : (2.0 + x_28)))? ((13.0 + x_22) > (2.0 + x_24)? (13.0 + x_22) : (2.0 + x_24)) : ((7.0 + x_26) > ((14.0 + x_27) > (2.0 + x_28)? (14.0 + x_27) : (2.0 + x_28))? (7.0 + x_26) : ((14.0 + x_27) > (2.0 + x_28)? (14.0 + x_27) : (2.0 + x_28)))) : (((13.0 + x_29) > (7.0 + x_31)? (13.0 + x_29) : (7.0 + x_31)) > ((3.0 + x_32) > ((17.0 + x_37) > (11.0 + x_39)? (17.0 + x_37) : (11.0 + x_39))? (3.0 + x_32) : ((17.0 + x_37) > (11.0 + x_39)? (17.0 + x_37) : (11.0 + x_39)))? ((13.0 + x_29) > (7.0 + x_31)? (13.0 + x_29) : (7.0 + x_31)) : ((3.0 + x_32) > ((17.0 + x_37) > (11.0 + x_39)? (17.0 + x_37) : (11.0 + x_39))? (3.0 + x_32) : ((17.0 + x_37) > (11.0 + x_39)? (17.0 + x_37) : (11.0 + x_39)))))? ((((4.0 + x_0) > (18.0 + x_4)? (4.0 + x_0) : (18.0 + x_4)) > ((12.0 + x_5) > ((10.0 + x_8) > (19.0 + x_11)? (10.0 + x_8) : (19.0 + x_11))? (12.0 + x_5) : ((10.0 + x_8) > (19.0 + x_11)? (10.0 + x_8) : (19.0 + x_11)))? ((4.0 + x_0) > (18.0 + x_4)? (4.0 + x_0) : (18.0 + x_4)) : ((12.0 + x_5) > ((10.0 + x_8) > (19.0 + x_11)? (10.0 + x_8) : (19.0 + x_11))? (12.0 + x_5) : ((10.0 + x_8) > (19.0 + x_11)? (10.0 + x_8) : (19.0 + x_11)))) > (((5.0 + x_15) > (10.0 + x_16)? (5.0 + x_15) : (10.0 + x_16)) > ((4.0 + x_18) > ((11.0 + x_19) > (2.0 + x_20)? (11.0 + x_19) : (2.0 + x_20))? (4.0 + x_18) : ((11.0 + x_19) > (2.0 + x_20)? (11.0 + x_19) : (2.0 + x_20)))? ((5.0 + x_15) > (10.0 + x_16)? (5.0 + x_15) : (10.0 + x_16)) : ((4.0 + x_18) > ((11.0 + x_19) > (2.0 + x_20)? (11.0 + x_19) : (2.0 + x_20))? (4.0 + x_18) : ((11.0 + x_19) > (2.0 + x_20)? (11.0 + x_19) : (2.0 + x_20))))? (((4.0 + x_0) > (18.0 + x_4)? (4.0 + x_0) : (18.0 + x_4)) > ((12.0 + x_5) > ((10.0 + x_8) > (19.0 + x_11)? (10.0 + x_8) : (19.0 + x_11))? (12.0 + x_5) : ((10.0 + x_8) > (19.0 + x_11)? (10.0 + x_8) : (19.0 + x_11)))? ((4.0 + x_0) > (18.0 + x_4)? (4.0 + x_0) : (18.0 + x_4)) : ((12.0 + x_5) > ((10.0 + x_8) > (19.0 + x_11)? (10.0 + x_8) : (19.0 + x_11))? (12.0 + x_5) : ((10.0 + x_8) > (19.0 + x_11)? (10.0 + x_8) : (19.0 + x_11)))) : (((5.0 + x_15) > (10.0 + x_16)? (5.0 + x_15) : (10.0 + x_16)) > ((4.0 + x_18) > ((11.0 + x_19) > (2.0 + x_20)? (11.0 + x_19) : (2.0 + x_20))? (4.0 + x_18) : ((11.0 + x_19) > (2.0 + x_20)? (11.0 + x_19) : (2.0 + x_20)))? ((5.0 + x_15) > (10.0 + x_16)? (5.0 + x_15) : (10.0 + x_16)) : ((4.0 + x_18) > ((11.0 + x_19) > (2.0 + x_20)? (11.0 + x_19) : (2.0 + x_20))? (4.0 + x_18) : ((11.0 + x_19) > (2.0 + x_20)? (11.0 + x_19) : (2.0 + x_20))))) : ((((13.0 + x_22) > (2.0 + x_24)? (13.0 + x_22) : (2.0 + x_24)) > ((7.0 + x_26) > ((14.0 + x_27) > (2.0 + x_28)? (14.0 + x_27) : (2.0 + x_28))? (7.0 + x_26) : ((14.0 + x_27) > (2.0 + x_28)? (14.0 + x_27) : (2.0 + x_28)))? ((13.0 + x_22) > (2.0 + x_24)? (13.0 + x_22) : (2.0 + x_24)) : ((7.0 + x_26) > ((14.0 + x_27) > (2.0 + x_28)? (14.0 + x_27) : (2.0 + x_28))? (7.0 + x_26) : ((14.0 + x_27) > (2.0 + x_28)? (14.0 + x_27) : (2.0 + x_28)))) > (((13.0 + x_29) > (7.0 + x_31)? (13.0 + x_29) : (7.0 + x_31)) > ((3.0 + x_32) > ((17.0 + x_37) > (11.0 + x_39)? (17.0 + x_37) : (11.0 + x_39))? (3.0 + x_32) : ((17.0 + x_37) > (11.0 + x_39)? (17.0 + x_37) : (11.0 + x_39)))? ((13.0 + x_29) > (7.0 + x_31)? (13.0 + x_29) : (7.0 + x_31)) : ((3.0 + x_32) > ((17.0 + x_37) > (11.0 + x_39)? (17.0 + x_37) : (11.0 + x_39))? (3.0 + x_32) : ((17.0 + x_37) > (11.0 + x_39)? (17.0 + x_37) : (11.0 + x_39))))? (((13.0 + x_22) > (2.0 + x_24)? (13.0 + x_22) : (2.0 + x_24)) > ((7.0 + x_26) > ((14.0 + x_27) > (2.0 + x_28)? (14.0 + x_27) : (2.0 + x_28))? (7.0 + x_26) : ((14.0 + x_27) > (2.0 + x_28)? (14.0 + x_27) : (2.0 + x_28)))? ((13.0 + x_22) > (2.0 + x_24)? (13.0 + x_22) : (2.0 + x_24)) : ((7.0 + x_26) > ((14.0 + x_27) > (2.0 + x_28)? (14.0 + x_27) : (2.0 + x_28))? (7.0 + x_26) : ((14.0 + x_27) > (2.0 + x_28)? (14.0 + x_27) : (2.0 + x_28)))) : (((13.0 + x_29) > (7.0 + x_31)? (13.0 + x_29) : (7.0 + x_31)) > ((3.0 + x_32) > ((17.0 + x_37) > (11.0 + x_39)? (17.0 + x_37) : (11.0 + x_39))? (3.0 + x_32) : ((17.0 + x_37) > (11.0 + x_39)? (17.0 + x_37) : (11.0 + x_39)))? ((13.0 + x_29) > (7.0 + x_31)? (13.0 + x_29) : (7.0 + x_31)) : ((3.0 + x_32) > ((17.0 + x_37) > (11.0 + x_39)? (17.0 + x_37) : (11.0 + x_39))? (3.0 + x_32) : ((17.0 + x_37) > (11.0 + x_39)? (17.0 + x_37) : (11.0 + x_39))))));
x_26_ = (((((17.0 + x_1) > (6.0 + x_2)? (17.0 + x_1) : (6.0 + x_2)) > ((3.0 + x_3) > ((9.0 + x_5) > (8.0 + x_6)? (9.0 + x_5) : (8.0 + x_6))? (3.0 + x_3) : ((9.0 + x_5) > (8.0 + x_6)? (9.0 + x_5) : (8.0 + x_6)))? ((17.0 + x_1) > (6.0 + x_2)? (17.0 + x_1) : (6.0 + x_2)) : ((3.0 + x_3) > ((9.0 + x_5) > (8.0 + x_6)? (9.0 + x_5) : (8.0 + x_6))? (3.0 + x_3) : ((9.0 + x_5) > (8.0 + x_6)? (9.0 + x_5) : (8.0 + x_6)))) > (((6.0 + x_7) > (2.0 + x_9)? (6.0 + x_7) : (2.0 + x_9)) > ((5.0 + x_10) > ((7.0 + x_12) > (13.0 + x_13)? (7.0 + x_12) : (13.0 + x_13))? (5.0 + x_10) : ((7.0 + x_12) > (13.0 + x_13)? (7.0 + x_12) : (13.0 + x_13)))? ((6.0 + x_7) > (2.0 + x_9)? (6.0 + x_7) : (2.0 + x_9)) : ((5.0 + x_10) > ((7.0 + x_12) > (13.0 + x_13)? (7.0 + x_12) : (13.0 + x_13))? (5.0 + x_10) : ((7.0 + x_12) > (13.0 + x_13)? (7.0 + x_12) : (13.0 + x_13))))? (((17.0 + x_1) > (6.0 + x_2)? (17.0 + x_1) : (6.0 + x_2)) > ((3.0 + x_3) > ((9.0 + x_5) > (8.0 + x_6)? (9.0 + x_5) : (8.0 + x_6))? (3.0 + x_3) : ((9.0 + x_5) > (8.0 + x_6)? (9.0 + x_5) : (8.0 + x_6)))? ((17.0 + x_1) > (6.0 + x_2)? (17.0 + x_1) : (6.0 + x_2)) : ((3.0 + x_3) > ((9.0 + x_5) > (8.0 + x_6)? (9.0 + x_5) : (8.0 + x_6))? (3.0 + x_3) : ((9.0 + x_5) > (8.0 + x_6)? (9.0 + x_5) : (8.0 + x_6)))) : (((6.0 + x_7) > (2.0 + x_9)? (6.0 + x_7) : (2.0 + x_9)) > ((5.0 + x_10) > ((7.0 + x_12) > (13.0 + x_13)? (7.0 + x_12) : (13.0 + x_13))? (5.0 + x_10) : ((7.0 + x_12) > (13.0 + x_13)? (7.0 + x_12) : (13.0 + x_13)))? ((6.0 + x_7) > (2.0 + x_9)? (6.0 + x_7) : (2.0 + x_9)) : ((5.0 + x_10) > ((7.0 + x_12) > (13.0 + x_13)? (7.0 + x_12) : (13.0 + x_13))? (5.0 + x_10) : ((7.0 + x_12) > (13.0 + x_13)? (7.0 + x_12) : (13.0 + x_13))))) > ((((12.0 + x_14) > (17.0 + x_18)? (12.0 + x_14) : (17.0 + x_18)) > ((10.0 + x_20) > ((6.0 + x_21) > (8.0 + x_25)? (6.0 + x_21) : (8.0 + x_25))? (10.0 + x_20) : ((6.0 + x_21) > (8.0 + x_25)? (6.0 + x_21) : (8.0 + x_25)))? ((12.0 + x_14) > (17.0 + x_18)? (12.0 + x_14) : (17.0 + x_18)) : ((10.0 + x_20) > ((6.0 + x_21) > (8.0 + x_25)? (6.0 + x_21) : (8.0 + x_25))? (10.0 + x_20) : ((6.0 + x_21) > (8.0 + x_25)? (6.0 + x_21) : (8.0 + x_25)))) > (((15.0 + x_26) > (4.0 + x_27)? (15.0 + x_26) : (4.0 + x_27)) > ((9.0 + x_30) > ((4.0 + x_32) > (12.0 + x_37)? (4.0 + x_32) : (12.0 + x_37))? (9.0 + x_30) : ((4.0 + x_32) > (12.0 + x_37)? (4.0 + x_32) : (12.0 + x_37)))? ((15.0 + x_26) > (4.0 + x_27)? (15.0 + x_26) : (4.0 + x_27)) : ((9.0 + x_30) > ((4.0 + x_32) > (12.0 + x_37)? (4.0 + x_32) : (12.0 + x_37))? (9.0 + x_30) : ((4.0 + x_32) > (12.0 + x_37)? (4.0 + x_32) : (12.0 + x_37))))? (((12.0 + x_14) > (17.0 + x_18)? (12.0 + x_14) : (17.0 + x_18)) > ((10.0 + x_20) > ((6.0 + x_21) > (8.0 + x_25)? (6.0 + x_21) : (8.0 + x_25))? (10.0 + x_20) : ((6.0 + x_21) > (8.0 + x_25)? (6.0 + x_21) : (8.0 + x_25)))? ((12.0 + x_14) > (17.0 + x_18)? (12.0 + x_14) : (17.0 + x_18)) : ((10.0 + x_20) > ((6.0 + x_21) > (8.0 + x_25)? (6.0 + x_21) : (8.0 + x_25))? (10.0 + x_20) : ((6.0 + x_21) > (8.0 + x_25)? (6.0 + x_21) : (8.0 + x_25)))) : (((15.0 + x_26) > (4.0 + x_27)? (15.0 + x_26) : (4.0 + x_27)) > ((9.0 + x_30) > ((4.0 + x_32) > (12.0 + x_37)? (4.0 + x_32) : (12.0 + x_37))? (9.0 + x_30) : ((4.0 + x_32) > (12.0 + x_37)? (4.0 + x_32) : (12.0 + x_37)))? ((15.0 + x_26) > (4.0 + x_27)? (15.0 + x_26) : (4.0 + x_27)) : ((9.0 + x_30) > ((4.0 + x_32) > (12.0 + x_37)? (4.0 + x_32) : (12.0 + x_37))? (9.0 + x_30) : ((4.0 + x_32) > (12.0 + x_37)? (4.0 + x_32) : (12.0 + x_37)))))? ((((17.0 + x_1) > (6.0 + x_2)? (17.0 + x_1) : (6.0 + x_2)) > ((3.0 + x_3) > ((9.0 + x_5) > (8.0 + x_6)? (9.0 + x_5) : (8.0 + x_6))? (3.0 + x_3) : ((9.0 + x_5) > (8.0 + x_6)? (9.0 + x_5) : (8.0 + x_6)))? ((17.0 + x_1) > (6.0 + x_2)? (17.0 + x_1) : (6.0 + x_2)) : ((3.0 + x_3) > ((9.0 + x_5) > (8.0 + x_6)? (9.0 + x_5) : (8.0 + x_6))? (3.0 + x_3) : ((9.0 + x_5) > (8.0 + x_6)? (9.0 + x_5) : (8.0 + x_6)))) > (((6.0 + x_7) > (2.0 + x_9)? (6.0 + x_7) : (2.0 + x_9)) > ((5.0 + x_10) > ((7.0 + x_12) > (13.0 + x_13)? (7.0 + x_12) : (13.0 + x_13))? (5.0 + x_10) : ((7.0 + x_12) > (13.0 + x_13)? (7.0 + x_12) : (13.0 + x_13)))? ((6.0 + x_7) > (2.0 + x_9)? (6.0 + x_7) : (2.0 + x_9)) : ((5.0 + x_10) > ((7.0 + x_12) > (13.0 + x_13)? (7.0 + x_12) : (13.0 + x_13))? (5.0 + x_10) : ((7.0 + x_12) > (13.0 + x_13)? (7.0 + x_12) : (13.0 + x_13))))? (((17.0 + x_1) > (6.0 + x_2)? (17.0 + x_1) : (6.0 + x_2)) > ((3.0 + x_3) > ((9.0 + x_5) > (8.0 + x_6)? (9.0 + x_5) : (8.0 + x_6))? (3.0 + x_3) : ((9.0 + x_5) > (8.0 + x_6)? (9.0 + x_5) : (8.0 + x_6)))? ((17.0 + x_1) > (6.0 + x_2)? (17.0 + x_1) : (6.0 + x_2)) : ((3.0 + x_3) > ((9.0 + x_5) > (8.0 + x_6)? (9.0 + x_5) : (8.0 + x_6))? (3.0 + x_3) : ((9.0 + x_5) > (8.0 + x_6)? (9.0 + x_5) : (8.0 + x_6)))) : (((6.0 + x_7) > (2.0 + x_9)? (6.0 + x_7) : (2.0 + x_9)) > ((5.0 + x_10) > ((7.0 + x_12) > (13.0 + x_13)? (7.0 + x_12) : (13.0 + x_13))? (5.0 + x_10) : ((7.0 + x_12) > (13.0 + x_13)? (7.0 + x_12) : (13.0 + x_13)))? ((6.0 + x_7) > (2.0 + x_9)? (6.0 + x_7) : (2.0 + x_9)) : ((5.0 + x_10) > ((7.0 + x_12) > (13.0 + x_13)? (7.0 + x_12) : (13.0 + x_13))? (5.0 + x_10) : ((7.0 + x_12) > (13.0 + x_13)? (7.0 + x_12) : (13.0 + x_13))))) : ((((12.0 + x_14) > (17.0 + x_18)? (12.0 + x_14) : (17.0 + x_18)) > ((10.0 + x_20) > ((6.0 + x_21) > (8.0 + x_25)? (6.0 + x_21) : (8.0 + x_25))? (10.0 + x_20) : ((6.0 + x_21) > (8.0 + x_25)? (6.0 + x_21) : (8.0 + x_25)))? ((12.0 + x_14) > (17.0 + x_18)? (12.0 + x_14) : (17.0 + x_18)) : ((10.0 + x_20) > ((6.0 + x_21) > (8.0 + x_25)? (6.0 + x_21) : (8.0 + x_25))? (10.0 + x_20) : ((6.0 + x_21) > (8.0 + x_25)? (6.0 + x_21) : (8.0 + x_25)))) > (((15.0 + x_26) > (4.0 + x_27)? (15.0 + x_26) : (4.0 + x_27)) > ((9.0 + x_30) > ((4.0 + x_32) > (12.0 + x_37)? (4.0 + x_32) : (12.0 + x_37))? (9.0 + x_30) : ((4.0 + x_32) > (12.0 + x_37)? (4.0 + x_32) : (12.0 + x_37)))? ((15.0 + x_26) > (4.0 + x_27)? (15.0 + x_26) : (4.0 + x_27)) : ((9.0 + x_30) > ((4.0 + x_32) > (12.0 + x_37)? (4.0 + x_32) : (12.0 + x_37))? (9.0 + x_30) : ((4.0 + x_32) > (12.0 + x_37)? (4.0 + x_32) : (12.0 + x_37))))? (((12.0 + x_14) > (17.0 + x_18)? (12.0 + x_14) : (17.0 + x_18)) > ((10.0 + x_20) > ((6.0 + x_21) > (8.0 + x_25)? (6.0 + x_21) : (8.0 + x_25))? (10.0 + x_20) : ((6.0 + x_21) > (8.0 + x_25)? (6.0 + x_21) : (8.0 + x_25)))? ((12.0 + x_14) > (17.0 + x_18)? (12.0 + x_14) : (17.0 + x_18)) : ((10.0 + x_20) > ((6.0 + x_21) > (8.0 + x_25)? (6.0 + x_21) : (8.0 + x_25))? (10.0 + x_20) : ((6.0 + x_21) > (8.0 + x_25)? (6.0 + x_21) : (8.0 + x_25)))) : (((15.0 + x_26) > (4.0 + x_27)? (15.0 + x_26) : (4.0 + x_27)) > ((9.0 + x_30) > ((4.0 + x_32) > (12.0 + x_37)? (4.0 + x_32) : (12.0 + x_37))? (9.0 + x_30) : ((4.0 + x_32) > (12.0 + x_37)? (4.0 + x_32) : (12.0 + x_37)))? ((15.0 + x_26) > (4.0 + x_27)? (15.0 + x_26) : (4.0 + x_27)) : ((9.0 + x_30) > ((4.0 + x_32) > (12.0 + x_37)? (4.0 + x_32) : (12.0 + x_37))? (9.0 + x_30) : ((4.0 + x_32) > (12.0 + x_37)? (4.0 + x_32) : (12.0 + x_37))))));
x_27_ = (((((1.0 + x_0) > (14.0 + x_6)? (1.0 + x_0) : (14.0 + x_6)) > ((3.0 + x_7) > ((2.0 + x_10) > (2.0 + x_11)? (2.0 + x_10) : (2.0 + x_11))? (3.0 + x_7) : ((2.0 + x_10) > (2.0 + x_11)? (2.0 + x_10) : (2.0 + x_11)))? ((1.0 + x_0) > (14.0 + x_6)? (1.0 + x_0) : (14.0 + x_6)) : ((3.0 + x_7) > ((2.0 + x_10) > (2.0 + x_11)? (2.0 + x_10) : (2.0 + x_11))? (3.0 + x_7) : ((2.0 + x_10) > (2.0 + x_11)? (2.0 + x_10) : (2.0 + x_11)))) > (((1.0 + x_12) > (8.0 + x_14)? (1.0 + x_12) : (8.0 + x_14)) > ((10.0 + x_15) > ((4.0 + x_16) > (3.0 + x_18)? (4.0 + x_16) : (3.0 + x_18))? (10.0 + x_15) : ((4.0 + x_16) > (3.0 + x_18)? (4.0 + x_16) : (3.0 + x_18)))? ((1.0 + x_12) > (8.0 + x_14)? (1.0 + x_12) : (8.0 + x_14)) : ((10.0 + x_15) > ((4.0 + x_16) > (3.0 + x_18)? (4.0 + x_16) : (3.0 + x_18))? (10.0 + x_15) : ((4.0 + x_16) > (3.0 + x_18)? (4.0 + x_16) : (3.0 + x_18))))? (((1.0 + x_0) > (14.0 + x_6)? (1.0 + x_0) : (14.0 + x_6)) > ((3.0 + x_7) > ((2.0 + x_10) > (2.0 + x_11)? (2.0 + x_10) : (2.0 + x_11))? (3.0 + x_7) : ((2.0 + x_10) > (2.0 + x_11)? (2.0 + x_10) : (2.0 + x_11)))? ((1.0 + x_0) > (14.0 + x_6)? (1.0 + x_0) : (14.0 + x_6)) : ((3.0 + x_7) > ((2.0 + x_10) > (2.0 + x_11)? (2.0 + x_10) : (2.0 + x_11))? (3.0 + x_7) : ((2.0 + x_10) > (2.0 + x_11)? (2.0 + x_10) : (2.0 + x_11)))) : (((1.0 + x_12) > (8.0 + x_14)? (1.0 + x_12) : (8.0 + x_14)) > ((10.0 + x_15) > ((4.0 + x_16) > (3.0 + x_18)? (4.0 + x_16) : (3.0 + x_18))? (10.0 + x_15) : ((4.0 + x_16) > (3.0 + x_18)? (4.0 + x_16) : (3.0 + x_18)))? ((1.0 + x_12) > (8.0 + x_14)? (1.0 + x_12) : (8.0 + x_14)) : ((10.0 + x_15) > ((4.0 + x_16) > (3.0 + x_18)? (4.0 + x_16) : (3.0 + x_18))? (10.0 + x_15) : ((4.0 + x_16) > (3.0 + x_18)? (4.0 + x_16) : (3.0 + x_18))))) > ((((10.0 + x_20) > (16.0 + x_23)? (10.0 + x_20) : (16.0 + x_23)) > ((2.0 + x_24) > ((18.0 + x_27) > (20.0 + x_31)? (18.0 + x_27) : (20.0 + x_31))? (2.0 + x_24) : ((18.0 + x_27) > (20.0 + x_31)? (18.0 + x_27) : (20.0 + x_31)))? ((10.0 + x_20) > (16.0 + x_23)? (10.0 + x_20) : (16.0 + x_23)) : ((2.0 + x_24) > ((18.0 + x_27) > (20.0 + x_31)? (18.0 + x_27) : (20.0 + x_31))? (2.0 + x_24) : ((18.0 + x_27) > (20.0 + x_31)? (18.0 + x_27) : (20.0 + x_31)))) > (((11.0 + x_32) > (3.0 + x_33)? (11.0 + x_32) : (3.0 + x_33)) > ((17.0 + x_34) > ((9.0 + x_38) > (20.0 + x_39)? (9.0 + x_38) : (20.0 + x_39))? (17.0 + x_34) : ((9.0 + x_38) > (20.0 + x_39)? (9.0 + x_38) : (20.0 + x_39)))? ((11.0 + x_32) > (3.0 + x_33)? (11.0 + x_32) : (3.0 + x_33)) : ((17.0 + x_34) > ((9.0 + x_38) > (20.0 + x_39)? (9.0 + x_38) : (20.0 + x_39))? (17.0 + x_34) : ((9.0 + x_38) > (20.0 + x_39)? (9.0 + x_38) : (20.0 + x_39))))? (((10.0 + x_20) > (16.0 + x_23)? (10.0 + x_20) : (16.0 + x_23)) > ((2.0 + x_24) > ((18.0 + x_27) > (20.0 + x_31)? (18.0 + x_27) : (20.0 + x_31))? (2.0 + x_24) : ((18.0 + x_27) > (20.0 + x_31)? (18.0 + x_27) : (20.0 + x_31)))? ((10.0 + x_20) > (16.0 + x_23)? (10.0 + x_20) : (16.0 + x_23)) : ((2.0 + x_24) > ((18.0 + x_27) > (20.0 + x_31)? (18.0 + x_27) : (20.0 + x_31))? (2.0 + x_24) : ((18.0 + x_27) > (20.0 + x_31)? (18.0 + x_27) : (20.0 + x_31)))) : (((11.0 + x_32) > (3.0 + x_33)? (11.0 + x_32) : (3.0 + x_33)) > ((17.0 + x_34) > ((9.0 + x_38) > (20.0 + x_39)? (9.0 + x_38) : (20.0 + x_39))? (17.0 + x_34) : ((9.0 + x_38) > (20.0 + x_39)? (9.0 + x_38) : (20.0 + x_39)))? ((11.0 + x_32) > (3.0 + x_33)? (11.0 + x_32) : (3.0 + x_33)) : ((17.0 + x_34) > ((9.0 + x_38) > (20.0 + x_39)? (9.0 + x_38) : (20.0 + x_39))? (17.0 + x_34) : ((9.0 + x_38) > (20.0 + x_39)? (9.0 + x_38) : (20.0 + x_39)))))? ((((1.0 + x_0) > (14.0 + x_6)? (1.0 + x_0) : (14.0 + x_6)) > ((3.0 + x_7) > ((2.0 + x_10) > (2.0 + x_11)? (2.0 + x_10) : (2.0 + x_11))? (3.0 + x_7) : ((2.0 + x_10) > (2.0 + x_11)? (2.0 + x_10) : (2.0 + x_11)))? ((1.0 + x_0) > (14.0 + x_6)? (1.0 + x_0) : (14.0 + x_6)) : ((3.0 + x_7) > ((2.0 + x_10) > (2.0 + x_11)? (2.0 + x_10) : (2.0 + x_11))? (3.0 + x_7) : ((2.0 + x_10) > (2.0 + x_11)? (2.0 + x_10) : (2.0 + x_11)))) > (((1.0 + x_12) > (8.0 + x_14)? (1.0 + x_12) : (8.0 + x_14)) > ((10.0 + x_15) > ((4.0 + x_16) > (3.0 + x_18)? (4.0 + x_16) : (3.0 + x_18))? (10.0 + x_15) : ((4.0 + x_16) > (3.0 + x_18)? (4.0 + x_16) : (3.0 + x_18)))? ((1.0 + x_12) > (8.0 + x_14)? (1.0 + x_12) : (8.0 + x_14)) : ((10.0 + x_15) > ((4.0 + x_16) > (3.0 + x_18)? (4.0 + x_16) : (3.0 + x_18))? (10.0 + x_15) : ((4.0 + x_16) > (3.0 + x_18)? (4.0 + x_16) : (3.0 + x_18))))? (((1.0 + x_0) > (14.0 + x_6)? (1.0 + x_0) : (14.0 + x_6)) > ((3.0 + x_7) > ((2.0 + x_10) > (2.0 + x_11)? (2.0 + x_10) : (2.0 + x_11))? (3.0 + x_7) : ((2.0 + x_10) > (2.0 + x_11)? (2.0 + x_10) : (2.0 + x_11)))? ((1.0 + x_0) > (14.0 + x_6)? (1.0 + x_0) : (14.0 + x_6)) : ((3.0 + x_7) > ((2.0 + x_10) > (2.0 + x_11)? (2.0 + x_10) : (2.0 + x_11))? (3.0 + x_7) : ((2.0 + x_10) > (2.0 + x_11)? (2.0 + x_10) : (2.0 + x_11)))) : (((1.0 + x_12) > (8.0 + x_14)? (1.0 + x_12) : (8.0 + x_14)) > ((10.0 + x_15) > ((4.0 + x_16) > (3.0 + x_18)? (4.0 + x_16) : (3.0 + x_18))? (10.0 + x_15) : ((4.0 + x_16) > (3.0 + x_18)? (4.0 + x_16) : (3.0 + x_18)))? ((1.0 + x_12) > (8.0 + x_14)? (1.0 + x_12) : (8.0 + x_14)) : ((10.0 + x_15) > ((4.0 + x_16) > (3.0 + x_18)? (4.0 + x_16) : (3.0 + x_18))? (10.0 + x_15) : ((4.0 + x_16) > (3.0 + x_18)? (4.0 + x_16) : (3.0 + x_18))))) : ((((10.0 + x_20) > (16.0 + x_23)? (10.0 + x_20) : (16.0 + x_23)) > ((2.0 + x_24) > ((18.0 + x_27) > (20.0 + x_31)? (18.0 + x_27) : (20.0 + x_31))? (2.0 + x_24) : ((18.0 + x_27) > (20.0 + x_31)? (18.0 + x_27) : (20.0 + x_31)))? ((10.0 + x_20) > (16.0 + x_23)? (10.0 + x_20) : (16.0 + x_23)) : ((2.0 + x_24) > ((18.0 + x_27) > (20.0 + x_31)? (18.0 + x_27) : (20.0 + x_31))? (2.0 + x_24) : ((18.0 + x_27) > (20.0 + x_31)? (18.0 + x_27) : (20.0 + x_31)))) > (((11.0 + x_32) > (3.0 + x_33)? (11.0 + x_32) : (3.0 + x_33)) > ((17.0 + x_34) > ((9.0 + x_38) > (20.0 + x_39)? (9.0 + x_38) : (20.0 + x_39))? (17.0 + x_34) : ((9.0 + x_38) > (20.0 + x_39)? (9.0 + x_38) : (20.0 + x_39)))? ((11.0 + x_32) > (3.0 + x_33)? (11.0 + x_32) : (3.0 + x_33)) : ((17.0 + x_34) > ((9.0 + x_38) > (20.0 + x_39)? (9.0 + x_38) : (20.0 + x_39))? (17.0 + x_34) : ((9.0 + x_38) > (20.0 + x_39)? (9.0 + x_38) : (20.0 + x_39))))? (((10.0 + x_20) > (16.0 + x_23)? (10.0 + x_20) : (16.0 + x_23)) > ((2.0 + x_24) > ((18.0 + x_27) > (20.0 + x_31)? (18.0 + x_27) : (20.0 + x_31))? (2.0 + x_24) : ((18.0 + x_27) > (20.0 + x_31)? (18.0 + x_27) : (20.0 + x_31)))? ((10.0 + x_20) > (16.0 + x_23)? (10.0 + x_20) : (16.0 + x_23)) : ((2.0 + x_24) > ((18.0 + x_27) > (20.0 + x_31)? (18.0 + x_27) : (20.0 + x_31))? (2.0 + x_24) : ((18.0 + x_27) > (20.0 + x_31)? (18.0 + x_27) : (20.0 + x_31)))) : (((11.0 + x_32) > (3.0 + x_33)? (11.0 + x_32) : (3.0 + x_33)) > ((17.0 + x_34) > ((9.0 + x_38) > (20.0 + x_39)? (9.0 + x_38) : (20.0 + x_39))? (17.0 + x_34) : ((9.0 + x_38) > (20.0 + x_39)? (9.0 + x_38) : (20.0 + x_39)))? ((11.0 + x_32) > (3.0 + x_33)? (11.0 + x_32) : (3.0 + x_33)) : ((17.0 + x_34) > ((9.0 + x_38) > (20.0 + x_39)? (9.0 + x_38) : (20.0 + x_39))? (17.0 + x_34) : ((9.0 + x_38) > (20.0 + x_39)? (9.0 + x_38) : (20.0 + x_39))))));
x_28_ = (((((20.0 + x_0) > (15.0 + x_2)? (20.0 + x_0) : (15.0 + x_2)) > ((8.0 + x_3) > ((14.0 + x_4) > (5.0 + x_6)? (14.0 + x_4) : (5.0 + x_6))? (8.0 + x_3) : ((14.0 + x_4) > (5.0 + x_6)? (14.0 + x_4) : (5.0 + x_6)))? ((20.0 + x_0) > (15.0 + x_2)? (20.0 + x_0) : (15.0 + x_2)) : ((8.0 + x_3) > ((14.0 + x_4) > (5.0 + x_6)? (14.0 + x_4) : (5.0 + x_6))? (8.0 + x_3) : ((14.0 + x_4) > (5.0 + x_6)? (14.0 + x_4) : (5.0 + x_6)))) > (((7.0 + x_7) > (19.0 + x_10)? (7.0 + x_7) : (19.0 + x_10)) > ((1.0 + x_11) > ((17.0 + x_13) > (19.0 + x_14)? (17.0 + x_13) : (19.0 + x_14))? (1.0 + x_11) : ((17.0 + x_13) > (19.0 + x_14)? (17.0 + x_13) : (19.0 + x_14)))? ((7.0 + x_7) > (19.0 + x_10)? (7.0 + x_7) : (19.0 + x_10)) : ((1.0 + x_11) > ((17.0 + x_13) > (19.0 + x_14)? (17.0 + x_13) : (19.0 + x_14))? (1.0 + x_11) : ((17.0 + x_13) > (19.0 + x_14)? (17.0 + x_13) : (19.0 + x_14))))? (((20.0 + x_0) > (15.0 + x_2)? (20.0 + x_0) : (15.0 + x_2)) > ((8.0 + x_3) > ((14.0 + x_4) > (5.0 + x_6)? (14.0 + x_4) : (5.0 + x_6))? (8.0 + x_3) : ((14.0 + x_4) > (5.0 + x_6)? (14.0 + x_4) : (5.0 + x_6)))? ((20.0 + x_0) > (15.0 + x_2)? (20.0 + x_0) : (15.0 + x_2)) : ((8.0 + x_3) > ((14.0 + x_4) > (5.0 + x_6)? (14.0 + x_4) : (5.0 + x_6))? (8.0 + x_3) : ((14.0 + x_4) > (5.0 + x_6)? (14.0 + x_4) : (5.0 + x_6)))) : (((7.0 + x_7) > (19.0 + x_10)? (7.0 + x_7) : (19.0 + x_10)) > ((1.0 + x_11) > ((17.0 + x_13) > (19.0 + x_14)? (17.0 + x_13) : (19.0 + x_14))? (1.0 + x_11) : ((17.0 + x_13) > (19.0 + x_14)? (17.0 + x_13) : (19.0 + x_14)))? ((7.0 + x_7) > (19.0 + x_10)? (7.0 + x_7) : (19.0 + x_10)) : ((1.0 + x_11) > ((17.0 + x_13) > (19.0 + x_14)? (17.0 + x_13) : (19.0 + x_14))? (1.0 + x_11) : ((17.0 + x_13) > (19.0 + x_14)? (17.0 + x_13) : (19.0 + x_14))))) > ((((19.0 + x_17) > (13.0 + x_21)? (19.0 + x_17) : (13.0 + x_21)) > ((4.0 + x_22) > ((2.0 + x_26) > (1.0 + x_31)? (2.0 + x_26) : (1.0 + x_31))? (4.0 + x_22) : ((2.0 + x_26) > (1.0 + x_31)? (2.0 + x_26) : (1.0 + x_31)))? ((19.0 + x_17) > (13.0 + x_21)? (19.0 + x_17) : (13.0 + x_21)) : ((4.0 + x_22) > ((2.0 + x_26) > (1.0 + x_31)? (2.0 + x_26) : (1.0 + x_31))? (4.0 + x_22) : ((2.0 + x_26) > (1.0 + x_31)? (2.0 + x_26) : (1.0 + x_31)))) > (((18.0 + x_33) > (18.0 + x_34)? (18.0 + x_33) : (18.0 + x_34)) > ((19.0 + x_35) > ((8.0 + x_36) > (19.0 + x_39)? (8.0 + x_36) : (19.0 + x_39))? (19.0 + x_35) : ((8.0 + x_36) > (19.0 + x_39)? (8.0 + x_36) : (19.0 + x_39)))? ((18.0 + x_33) > (18.0 + x_34)? (18.0 + x_33) : (18.0 + x_34)) : ((19.0 + x_35) > ((8.0 + x_36) > (19.0 + x_39)? (8.0 + x_36) : (19.0 + x_39))? (19.0 + x_35) : ((8.0 + x_36) > (19.0 + x_39)? (8.0 + x_36) : (19.0 + x_39))))? (((19.0 + x_17) > (13.0 + x_21)? (19.0 + x_17) : (13.0 + x_21)) > ((4.0 + x_22) > ((2.0 + x_26) > (1.0 + x_31)? (2.0 + x_26) : (1.0 + x_31))? (4.0 + x_22) : ((2.0 + x_26) > (1.0 + x_31)? (2.0 + x_26) : (1.0 + x_31)))? ((19.0 + x_17) > (13.0 + x_21)? (19.0 + x_17) : (13.0 + x_21)) : ((4.0 + x_22) > ((2.0 + x_26) > (1.0 + x_31)? (2.0 + x_26) : (1.0 + x_31))? (4.0 + x_22) : ((2.0 + x_26) > (1.0 + x_31)? (2.0 + x_26) : (1.0 + x_31)))) : (((18.0 + x_33) > (18.0 + x_34)? (18.0 + x_33) : (18.0 + x_34)) > ((19.0 + x_35) > ((8.0 + x_36) > (19.0 + x_39)? (8.0 + x_36) : (19.0 + x_39))? (19.0 + x_35) : ((8.0 + x_36) > (19.0 + x_39)? (8.0 + x_36) : (19.0 + x_39)))? ((18.0 + x_33) > (18.0 + x_34)? (18.0 + x_33) : (18.0 + x_34)) : ((19.0 + x_35) > ((8.0 + x_36) > (19.0 + x_39)? (8.0 + x_36) : (19.0 + x_39))? (19.0 + x_35) : ((8.0 + x_36) > (19.0 + x_39)? (8.0 + x_36) : (19.0 + x_39)))))? ((((20.0 + x_0) > (15.0 + x_2)? (20.0 + x_0) : (15.0 + x_2)) > ((8.0 + x_3) > ((14.0 + x_4) > (5.0 + x_6)? (14.0 + x_4) : (5.0 + x_6))? (8.0 + x_3) : ((14.0 + x_4) > (5.0 + x_6)? (14.0 + x_4) : (5.0 + x_6)))? ((20.0 + x_0) > (15.0 + x_2)? (20.0 + x_0) : (15.0 + x_2)) : ((8.0 + x_3) > ((14.0 + x_4) > (5.0 + x_6)? (14.0 + x_4) : (5.0 + x_6))? (8.0 + x_3) : ((14.0 + x_4) > (5.0 + x_6)? (14.0 + x_4) : (5.0 + x_6)))) > (((7.0 + x_7) > (19.0 + x_10)? (7.0 + x_7) : (19.0 + x_10)) > ((1.0 + x_11) > ((17.0 + x_13) > (19.0 + x_14)? (17.0 + x_13) : (19.0 + x_14))? (1.0 + x_11) : ((17.0 + x_13) > (19.0 + x_14)? (17.0 + x_13) : (19.0 + x_14)))? ((7.0 + x_7) > (19.0 + x_10)? (7.0 + x_7) : (19.0 + x_10)) : ((1.0 + x_11) > ((17.0 + x_13) > (19.0 + x_14)? (17.0 + x_13) : (19.0 + x_14))? (1.0 + x_11) : ((17.0 + x_13) > (19.0 + x_14)? (17.0 + x_13) : (19.0 + x_14))))? (((20.0 + x_0) > (15.0 + x_2)? (20.0 + x_0) : (15.0 + x_2)) > ((8.0 + x_3) > ((14.0 + x_4) > (5.0 + x_6)? (14.0 + x_4) : (5.0 + x_6))? (8.0 + x_3) : ((14.0 + x_4) > (5.0 + x_6)? (14.0 + x_4) : (5.0 + x_6)))? ((20.0 + x_0) > (15.0 + x_2)? (20.0 + x_0) : (15.0 + x_2)) : ((8.0 + x_3) > ((14.0 + x_4) > (5.0 + x_6)? (14.0 + x_4) : (5.0 + x_6))? (8.0 + x_3) : ((14.0 + x_4) > (5.0 + x_6)? (14.0 + x_4) : (5.0 + x_6)))) : (((7.0 + x_7) > (19.0 + x_10)? (7.0 + x_7) : (19.0 + x_10)) > ((1.0 + x_11) > ((17.0 + x_13) > (19.0 + x_14)? (17.0 + x_13) : (19.0 + x_14))? (1.0 + x_11) : ((17.0 + x_13) > (19.0 + x_14)? (17.0 + x_13) : (19.0 + x_14)))? ((7.0 + x_7) > (19.0 + x_10)? (7.0 + x_7) : (19.0 + x_10)) : ((1.0 + x_11) > ((17.0 + x_13) > (19.0 + x_14)? (17.0 + x_13) : (19.0 + x_14))? (1.0 + x_11) : ((17.0 + x_13) > (19.0 + x_14)? (17.0 + x_13) : (19.0 + x_14))))) : ((((19.0 + x_17) > (13.0 + x_21)? (19.0 + x_17) : (13.0 + x_21)) > ((4.0 + x_22) > ((2.0 + x_26) > (1.0 + x_31)? (2.0 + x_26) : (1.0 + x_31))? (4.0 + x_22) : ((2.0 + x_26) > (1.0 + x_31)? (2.0 + x_26) : (1.0 + x_31)))? ((19.0 + x_17) > (13.0 + x_21)? (19.0 + x_17) : (13.0 + x_21)) : ((4.0 + x_22) > ((2.0 + x_26) > (1.0 + x_31)? (2.0 + x_26) : (1.0 + x_31))? (4.0 + x_22) : ((2.0 + x_26) > (1.0 + x_31)? (2.0 + x_26) : (1.0 + x_31)))) > (((18.0 + x_33) > (18.0 + x_34)? (18.0 + x_33) : (18.0 + x_34)) > ((19.0 + x_35) > ((8.0 + x_36) > (19.0 + x_39)? (8.0 + x_36) : (19.0 + x_39))? (19.0 + x_35) : ((8.0 + x_36) > (19.0 + x_39)? (8.0 + x_36) : (19.0 + x_39)))? ((18.0 + x_33) > (18.0 + x_34)? (18.0 + x_33) : (18.0 + x_34)) : ((19.0 + x_35) > ((8.0 + x_36) > (19.0 + x_39)? (8.0 + x_36) : (19.0 + x_39))? (19.0 + x_35) : ((8.0 + x_36) > (19.0 + x_39)? (8.0 + x_36) : (19.0 + x_39))))? (((19.0 + x_17) > (13.0 + x_21)? (19.0 + x_17) : (13.0 + x_21)) > ((4.0 + x_22) > ((2.0 + x_26) > (1.0 + x_31)? (2.0 + x_26) : (1.0 + x_31))? (4.0 + x_22) : ((2.0 + x_26) > (1.0 + x_31)? (2.0 + x_26) : (1.0 + x_31)))? ((19.0 + x_17) > (13.0 + x_21)? (19.0 + x_17) : (13.0 + x_21)) : ((4.0 + x_22) > ((2.0 + x_26) > (1.0 + x_31)? (2.0 + x_26) : (1.0 + x_31))? (4.0 + x_22) : ((2.0 + x_26) > (1.0 + x_31)? (2.0 + x_26) : (1.0 + x_31)))) : (((18.0 + x_33) > (18.0 + x_34)? (18.0 + x_33) : (18.0 + x_34)) > ((19.0 + x_35) > ((8.0 + x_36) > (19.0 + x_39)? (8.0 + x_36) : (19.0 + x_39))? (19.0 + x_35) : ((8.0 + x_36) > (19.0 + x_39)? (8.0 + x_36) : (19.0 + x_39)))? ((18.0 + x_33) > (18.0 + x_34)? (18.0 + x_33) : (18.0 + x_34)) : ((19.0 + x_35) > ((8.0 + x_36) > (19.0 + x_39)? (8.0 + x_36) : (19.0 + x_39))? (19.0 + x_35) : ((8.0 + x_36) > (19.0 + x_39)? (8.0 + x_36) : (19.0 + x_39))))));
x_29_ = (((((4.0 + x_3) > (16.0 + x_4)? (4.0 + x_3) : (16.0 + x_4)) > ((17.0 + x_6) > ((2.0 + x_9) > (16.0 + x_10)? (2.0 + x_9) : (16.0 + x_10))? (17.0 + x_6) : ((2.0 + x_9) > (16.0 + x_10)? (2.0 + x_9) : (16.0 + x_10)))? ((4.0 + x_3) > (16.0 + x_4)? (4.0 + x_3) : (16.0 + x_4)) : ((17.0 + x_6) > ((2.0 + x_9) > (16.0 + x_10)? (2.0 + x_9) : (16.0 + x_10))? (17.0 + x_6) : ((2.0 + x_9) > (16.0 + x_10)? (2.0 + x_9) : (16.0 + x_10)))) > (((15.0 + x_12) > (15.0 + x_14)? (15.0 + x_12) : (15.0 + x_14)) > ((10.0 + x_18) > ((19.0 + x_19) > (20.0 + x_23)? (19.0 + x_19) : (20.0 + x_23))? (10.0 + x_18) : ((19.0 + x_19) > (20.0 + x_23)? (19.0 + x_19) : (20.0 + x_23)))? ((15.0 + x_12) > (15.0 + x_14)? (15.0 + x_12) : (15.0 + x_14)) : ((10.0 + x_18) > ((19.0 + x_19) > (20.0 + x_23)? (19.0 + x_19) : (20.0 + x_23))? (10.0 + x_18) : ((19.0 + x_19) > (20.0 + x_23)? (19.0 + x_19) : (20.0 + x_23))))? (((4.0 + x_3) > (16.0 + x_4)? (4.0 + x_3) : (16.0 + x_4)) > ((17.0 + x_6) > ((2.0 + x_9) > (16.0 + x_10)? (2.0 + x_9) : (16.0 + x_10))? (17.0 + x_6) : ((2.0 + x_9) > (16.0 + x_10)? (2.0 + x_9) : (16.0 + x_10)))? ((4.0 + x_3) > (16.0 + x_4)? (4.0 + x_3) : (16.0 + x_4)) : ((17.0 + x_6) > ((2.0 + x_9) > (16.0 + x_10)? (2.0 + x_9) : (16.0 + x_10))? (17.0 + x_6) : ((2.0 + x_9) > (16.0 + x_10)? (2.0 + x_9) : (16.0 + x_10)))) : (((15.0 + x_12) > (15.0 + x_14)? (15.0 + x_12) : (15.0 + x_14)) > ((10.0 + x_18) > ((19.0 + x_19) > (20.0 + x_23)? (19.0 + x_19) : (20.0 + x_23))? (10.0 + x_18) : ((19.0 + x_19) > (20.0 + x_23)? (19.0 + x_19) : (20.0 + x_23)))? ((15.0 + x_12) > (15.0 + x_14)? (15.0 + x_12) : (15.0 + x_14)) : ((10.0 + x_18) > ((19.0 + x_19) > (20.0 + x_23)? (19.0 + x_19) : (20.0 + x_23))? (10.0 + x_18) : ((19.0 + x_19) > (20.0 + x_23)? (19.0 + x_19) : (20.0 + x_23))))) > ((((3.0 + x_24) > (6.0 + x_25)? (3.0 + x_24) : (6.0 + x_25)) > ((20.0 + x_28) > ((8.0 + x_29) > (17.0 + x_30)? (8.0 + x_29) : (17.0 + x_30))? (20.0 + x_28) : ((8.0 + x_29) > (17.0 + x_30)? (8.0 + x_29) : (17.0 + x_30)))? ((3.0 + x_24) > (6.0 + x_25)? (3.0 + x_24) : (6.0 + x_25)) : ((20.0 + x_28) > ((8.0 + x_29) > (17.0 + x_30)? (8.0 + x_29) : (17.0 + x_30))? (20.0 + x_28) : ((8.0 + x_29) > (17.0 + x_30)? (8.0 + x_29) : (17.0 + x_30)))) > (((9.0 + x_32) > (9.0 + x_33)? (9.0 + x_32) : (9.0 + x_33)) > ((2.0 + x_35) > ((20.0 + x_36) > (10.0 + x_37)? (20.0 + x_36) : (10.0 + x_37))? (2.0 + x_35) : ((20.0 + x_36) > (10.0 + x_37)? (20.0 + x_36) : (10.0 + x_37)))? ((9.0 + x_32) > (9.0 + x_33)? (9.0 + x_32) : (9.0 + x_33)) : ((2.0 + x_35) > ((20.0 + x_36) > (10.0 + x_37)? (20.0 + x_36) : (10.0 + x_37))? (2.0 + x_35) : ((20.0 + x_36) > (10.0 + x_37)? (20.0 + x_36) : (10.0 + x_37))))? (((3.0 + x_24) > (6.0 + x_25)? (3.0 + x_24) : (6.0 + x_25)) > ((20.0 + x_28) > ((8.0 + x_29) > (17.0 + x_30)? (8.0 + x_29) : (17.0 + x_30))? (20.0 + x_28) : ((8.0 + x_29) > (17.0 + x_30)? (8.0 + x_29) : (17.0 + x_30)))? ((3.0 + x_24) > (6.0 + x_25)? (3.0 + x_24) : (6.0 + x_25)) : ((20.0 + x_28) > ((8.0 + x_29) > (17.0 + x_30)? (8.0 + x_29) : (17.0 + x_30))? (20.0 + x_28) : ((8.0 + x_29) > (17.0 + x_30)? (8.0 + x_29) : (17.0 + x_30)))) : (((9.0 + x_32) > (9.0 + x_33)? (9.0 + x_32) : (9.0 + x_33)) > ((2.0 + x_35) > ((20.0 + x_36) > (10.0 + x_37)? (20.0 + x_36) : (10.0 + x_37))? (2.0 + x_35) : ((20.0 + x_36) > (10.0 + x_37)? (20.0 + x_36) : (10.0 + x_37)))? ((9.0 + x_32) > (9.0 + x_33)? (9.0 + x_32) : (9.0 + x_33)) : ((2.0 + x_35) > ((20.0 + x_36) > (10.0 + x_37)? (20.0 + x_36) : (10.0 + x_37))? (2.0 + x_35) : ((20.0 + x_36) > (10.0 + x_37)? (20.0 + x_36) : (10.0 + x_37)))))? ((((4.0 + x_3) > (16.0 + x_4)? (4.0 + x_3) : (16.0 + x_4)) > ((17.0 + x_6) > ((2.0 + x_9) > (16.0 + x_10)? (2.0 + x_9) : (16.0 + x_10))? (17.0 + x_6) : ((2.0 + x_9) > (16.0 + x_10)? (2.0 + x_9) : (16.0 + x_10)))? ((4.0 + x_3) > (16.0 + x_4)? (4.0 + x_3) : (16.0 + x_4)) : ((17.0 + x_6) > ((2.0 + x_9) > (16.0 + x_10)? (2.0 + x_9) : (16.0 + x_10))? (17.0 + x_6) : ((2.0 + x_9) > (16.0 + x_10)? (2.0 + x_9) : (16.0 + x_10)))) > (((15.0 + x_12) > (15.0 + x_14)? (15.0 + x_12) : (15.0 + x_14)) > ((10.0 + x_18) > ((19.0 + x_19) > (20.0 + x_23)? (19.0 + x_19) : (20.0 + x_23))? (10.0 + x_18) : ((19.0 + x_19) > (20.0 + x_23)? (19.0 + x_19) : (20.0 + x_23)))? ((15.0 + x_12) > (15.0 + x_14)? (15.0 + x_12) : (15.0 + x_14)) : ((10.0 + x_18) > ((19.0 + x_19) > (20.0 + x_23)? (19.0 + x_19) : (20.0 + x_23))? (10.0 + x_18) : ((19.0 + x_19) > (20.0 + x_23)? (19.0 + x_19) : (20.0 + x_23))))? (((4.0 + x_3) > (16.0 + x_4)? (4.0 + x_3) : (16.0 + x_4)) > ((17.0 + x_6) > ((2.0 + x_9) > (16.0 + x_10)? (2.0 + x_9) : (16.0 + x_10))? (17.0 + x_6) : ((2.0 + x_9) > (16.0 + x_10)? (2.0 + x_9) : (16.0 + x_10)))? ((4.0 + x_3) > (16.0 + x_4)? (4.0 + x_3) : (16.0 + x_4)) : ((17.0 + x_6) > ((2.0 + x_9) > (16.0 + x_10)? (2.0 + x_9) : (16.0 + x_10))? (17.0 + x_6) : ((2.0 + x_9) > (16.0 + x_10)? (2.0 + x_9) : (16.0 + x_10)))) : (((15.0 + x_12) > (15.0 + x_14)? (15.0 + x_12) : (15.0 + x_14)) > ((10.0 + x_18) > ((19.0 + x_19) > (20.0 + x_23)? (19.0 + x_19) : (20.0 + x_23))? (10.0 + x_18) : ((19.0 + x_19) > (20.0 + x_23)? (19.0 + x_19) : (20.0 + x_23)))? ((15.0 + x_12) > (15.0 + x_14)? (15.0 + x_12) : (15.0 + x_14)) : ((10.0 + x_18) > ((19.0 + x_19) > (20.0 + x_23)? (19.0 + x_19) : (20.0 + x_23))? (10.0 + x_18) : ((19.0 + x_19) > (20.0 + x_23)? (19.0 + x_19) : (20.0 + x_23))))) : ((((3.0 + x_24) > (6.0 + x_25)? (3.0 + x_24) : (6.0 + x_25)) > ((20.0 + x_28) > ((8.0 + x_29) > (17.0 + x_30)? (8.0 + x_29) : (17.0 + x_30))? (20.0 + x_28) : ((8.0 + x_29) > (17.0 + x_30)? (8.0 + x_29) : (17.0 + x_30)))? ((3.0 + x_24) > (6.0 + x_25)? (3.0 + x_24) : (6.0 + x_25)) : ((20.0 + x_28) > ((8.0 + x_29) > (17.0 + x_30)? (8.0 + x_29) : (17.0 + x_30))? (20.0 + x_28) : ((8.0 + x_29) > (17.0 + x_30)? (8.0 + x_29) : (17.0 + x_30)))) > (((9.0 + x_32) > (9.0 + x_33)? (9.0 + x_32) : (9.0 + x_33)) > ((2.0 + x_35) > ((20.0 + x_36) > (10.0 + x_37)? (20.0 + x_36) : (10.0 + x_37))? (2.0 + x_35) : ((20.0 + x_36) > (10.0 + x_37)? (20.0 + x_36) : (10.0 + x_37)))? ((9.0 + x_32) > (9.0 + x_33)? (9.0 + x_32) : (9.0 + x_33)) : ((2.0 + x_35) > ((20.0 + x_36) > (10.0 + x_37)? (20.0 + x_36) : (10.0 + x_37))? (2.0 + x_35) : ((20.0 + x_36) > (10.0 + x_37)? (20.0 + x_36) : (10.0 + x_37))))? (((3.0 + x_24) > (6.0 + x_25)? (3.0 + x_24) : (6.0 + x_25)) > ((20.0 + x_28) > ((8.0 + x_29) > (17.0 + x_30)? (8.0 + x_29) : (17.0 + x_30))? (20.0 + x_28) : ((8.0 + x_29) > (17.0 + x_30)? (8.0 + x_29) : (17.0 + x_30)))? ((3.0 + x_24) > (6.0 + x_25)? (3.0 + x_24) : (6.0 + x_25)) : ((20.0 + x_28) > ((8.0 + x_29) > (17.0 + x_30)? (8.0 + x_29) : (17.0 + x_30))? (20.0 + x_28) : ((8.0 + x_29) > (17.0 + x_30)? (8.0 + x_29) : (17.0 + x_30)))) : (((9.0 + x_32) > (9.0 + x_33)? (9.0 + x_32) : (9.0 + x_33)) > ((2.0 + x_35) > ((20.0 + x_36) > (10.0 + x_37)? (20.0 + x_36) : (10.0 + x_37))? (2.0 + x_35) : ((20.0 + x_36) > (10.0 + x_37)? (20.0 + x_36) : (10.0 + x_37)))? ((9.0 + x_32) > (9.0 + x_33)? (9.0 + x_32) : (9.0 + x_33)) : ((2.0 + x_35) > ((20.0 + x_36) > (10.0 + x_37)? (20.0 + x_36) : (10.0 + x_37))? (2.0 + x_35) : ((20.0 + x_36) > (10.0 + x_37)? (20.0 + x_36) : (10.0 + x_37))))));
x_30_ = (((((8.0 + x_0) > (16.0 + x_1)? (8.0 + x_0) : (16.0 + x_1)) > ((20.0 + x_4) > ((5.0 + x_5) > (14.0 + x_7)? (5.0 + x_5) : (14.0 + x_7))? (20.0 + x_4) : ((5.0 + x_5) > (14.0 + x_7)? (5.0 + x_5) : (14.0 + x_7)))? ((8.0 + x_0) > (16.0 + x_1)? (8.0 + x_0) : (16.0 + x_1)) : ((20.0 + x_4) > ((5.0 + x_5) > (14.0 + x_7)? (5.0 + x_5) : (14.0 + x_7))? (20.0 + x_4) : ((5.0 + x_5) > (14.0 + x_7)? (5.0 + x_5) : (14.0 + x_7)))) > (((7.0 + x_8) > (11.0 + x_9)? (7.0 + x_8) : (11.0 + x_9)) > ((2.0 + x_12) > ((15.0 + x_13) > (8.0 + x_14)? (15.0 + x_13) : (8.0 + x_14))? (2.0 + x_12) : ((15.0 + x_13) > (8.0 + x_14)? (15.0 + x_13) : (8.0 + x_14)))? ((7.0 + x_8) > (11.0 + x_9)? (7.0 + x_8) : (11.0 + x_9)) : ((2.0 + x_12) > ((15.0 + x_13) > (8.0 + x_14)? (15.0 + x_13) : (8.0 + x_14))? (2.0 + x_12) : ((15.0 + x_13) > (8.0 + x_14)? (15.0 + x_13) : (8.0 + x_14))))? (((8.0 + x_0) > (16.0 + x_1)? (8.0 + x_0) : (16.0 + x_1)) > ((20.0 + x_4) > ((5.0 + x_5) > (14.0 + x_7)? (5.0 + x_5) : (14.0 + x_7))? (20.0 + x_4) : ((5.0 + x_5) > (14.0 + x_7)? (5.0 + x_5) : (14.0 + x_7)))? ((8.0 + x_0) > (16.0 + x_1)? (8.0 + x_0) : (16.0 + x_1)) : ((20.0 + x_4) > ((5.0 + x_5) > (14.0 + x_7)? (5.0 + x_5) : (14.0 + x_7))? (20.0 + x_4) : ((5.0 + x_5) > (14.0 + x_7)? (5.0 + x_5) : (14.0 + x_7)))) : (((7.0 + x_8) > (11.0 + x_9)? (7.0 + x_8) : (11.0 + x_9)) > ((2.0 + x_12) > ((15.0 + x_13) > (8.0 + x_14)? (15.0 + x_13) : (8.0 + x_14))? (2.0 + x_12) : ((15.0 + x_13) > (8.0 + x_14)? (15.0 + x_13) : (8.0 + x_14)))? ((7.0 + x_8) > (11.0 + x_9)? (7.0 + x_8) : (11.0 + x_9)) : ((2.0 + x_12) > ((15.0 + x_13) > (8.0 + x_14)? (15.0 + x_13) : (8.0 + x_14))? (2.0 + x_12) : ((15.0 + x_13) > (8.0 + x_14)? (15.0 + x_13) : (8.0 + x_14))))) > ((((11.0 + x_16) > (2.0 + x_18)? (11.0 + x_16) : (2.0 + x_18)) > ((10.0 + x_19) > ((18.0 + x_20) > (7.0 + x_22)? (18.0 + x_20) : (7.0 + x_22))? (10.0 + x_19) : ((18.0 + x_20) > (7.0 + x_22)? (18.0 + x_20) : (7.0 + x_22)))? ((11.0 + x_16) > (2.0 + x_18)? (11.0 + x_16) : (2.0 + x_18)) : ((10.0 + x_19) > ((18.0 + x_20) > (7.0 + x_22)? (18.0 + x_20) : (7.0 + x_22))? (10.0 + x_19) : ((18.0 + x_20) > (7.0 + x_22)? (18.0 + x_20) : (7.0 + x_22)))) > (((11.0 + x_23) > (17.0 + x_25)? (11.0 + x_23) : (17.0 + x_25)) > ((12.0 + x_29) > ((1.0 + x_36) > (9.0 + x_37)? (1.0 + x_36) : (9.0 + x_37))? (12.0 + x_29) : ((1.0 + x_36) > (9.0 + x_37)? (1.0 + x_36) : (9.0 + x_37)))? ((11.0 + x_23) > (17.0 + x_25)? (11.0 + x_23) : (17.0 + x_25)) : ((12.0 + x_29) > ((1.0 + x_36) > (9.0 + x_37)? (1.0 + x_36) : (9.0 + x_37))? (12.0 + x_29) : ((1.0 + x_36) > (9.0 + x_37)? (1.0 + x_36) : (9.0 + x_37))))? (((11.0 + x_16) > (2.0 + x_18)? (11.0 + x_16) : (2.0 + x_18)) > ((10.0 + x_19) > ((18.0 + x_20) > (7.0 + x_22)? (18.0 + x_20) : (7.0 + x_22))? (10.0 + x_19) : ((18.0 + x_20) > (7.0 + x_22)? (18.0 + x_20) : (7.0 + x_22)))? ((11.0 + x_16) > (2.0 + x_18)? (11.0 + x_16) : (2.0 + x_18)) : ((10.0 + x_19) > ((18.0 + x_20) > (7.0 + x_22)? (18.0 + x_20) : (7.0 + x_22))? (10.0 + x_19) : ((18.0 + x_20) > (7.0 + x_22)? (18.0 + x_20) : (7.0 + x_22)))) : (((11.0 + x_23) > (17.0 + x_25)? (11.0 + x_23) : (17.0 + x_25)) > ((12.0 + x_29) > ((1.0 + x_36) > (9.0 + x_37)? (1.0 + x_36) : (9.0 + x_37))? (12.0 + x_29) : ((1.0 + x_36) > (9.0 + x_37)? (1.0 + x_36) : (9.0 + x_37)))? ((11.0 + x_23) > (17.0 + x_25)? (11.0 + x_23) : (17.0 + x_25)) : ((12.0 + x_29) > ((1.0 + x_36) > (9.0 + x_37)? (1.0 + x_36) : (9.0 + x_37))? (12.0 + x_29) : ((1.0 + x_36) > (9.0 + x_37)? (1.0 + x_36) : (9.0 + x_37)))))? ((((8.0 + x_0) > (16.0 + x_1)? (8.0 + x_0) : (16.0 + x_1)) > ((20.0 + x_4) > ((5.0 + x_5) > (14.0 + x_7)? (5.0 + x_5) : (14.0 + x_7))? (20.0 + x_4) : ((5.0 + x_5) > (14.0 + x_7)? (5.0 + x_5) : (14.0 + x_7)))? ((8.0 + x_0) > (16.0 + x_1)? (8.0 + x_0) : (16.0 + x_1)) : ((20.0 + x_4) > ((5.0 + x_5) > (14.0 + x_7)? (5.0 + x_5) : (14.0 + x_7))? (20.0 + x_4) : ((5.0 + x_5) > (14.0 + x_7)? (5.0 + x_5) : (14.0 + x_7)))) > (((7.0 + x_8) > (11.0 + x_9)? (7.0 + x_8) : (11.0 + x_9)) > ((2.0 + x_12) > ((15.0 + x_13) > (8.0 + x_14)? (15.0 + x_13) : (8.0 + x_14))? (2.0 + x_12) : ((15.0 + x_13) > (8.0 + x_14)? (15.0 + x_13) : (8.0 + x_14)))? ((7.0 + x_8) > (11.0 + x_9)? (7.0 + x_8) : (11.0 + x_9)) : ((2.0 + x_12) > ((15.0 + x_13) > (8.0 + x_14)? (15.0 + x_13) : (8.0 + x_14))? (2.0 + x_12) : ((15.0 + x_13) > (8.0 + x_14)? (15.0 + x_13) : (8.0 + x_14))))? (((8.0 + x_0) > (16.0 + x_1)? (8.0 + x_0) : (16.0 + x_1)) > ((20.0 + x_4) > ((5.0 + x_5) > (14.0 + x_7)? (5.0 + x_5) : (14.0 + x_7))? (20.0 + x_4) : ((5.0 + x_5) > (14.0 + x_7)? (5.0 + x_5) : (14.0 + x_7)))? ((8.0 + x_0) > (16.0 + x_1)? (8.0 + x_0) : (16.0 + x_1)) : ((20.0 + x_4) > ((5.0 + x_5) > (14.0 + x_7)? (5.0 + x_5) : (14.0 + x_7))? (20.0 + x_4) : ((5.0 + x_5) > (14.0 + x_7)? (5.0 + x_5) : (14.0 + x_7)))) : (((7.0 + x_8) > (11.0 + x_9)? (7.0 + x_8) : (11.0 + x_9)) > ((2.0 + x_12) > ((15.0 + x_13) > (8.0 + x_14)? (15.0 + x_13) : (8.0 + x_14))? (2.0 + x_12) : ((15.0 + x_13) > (8.0 + x_14)? (15.0 + x_13) : (8.0 + x_14)))? ((7.0 + x_8) > (11.0 + x_9)? (7.0 + x_8) : (11.0 + x_9)) : ((2.0 + x_12) > ((15.0 + x_13) > (8.0 + x_14)? (15.0 + x_13) : (8.0 + x_14))? (2.0 + x_12) : ((15.0 + x_13) > (8.0 + x_14)? (15.0 + x_13) : (8.0 + x_14))))) : ((((11.0 + x_16) > (2.0 + x_18)? (11.0 + x_16) : (2.0 + x_18)) > ((10.0 + x_19) > ((18.0 + x_20) > (7.0 + x_22)? (18.0 + x_20) : (7.0 + x_22))? (10.0 + x_19) : ((18.0 + x_20) > (7.0 + x_22)? (18.0 + x_20) : (7.0 + x_22)))? ((11.0 + x_16) > (2.0 + x_18)? (11.0 + x_16) : (2.0 + x_18)) : ((10.0 + x_19) > ((18.0 + x_20) > (7.0 + x_22)? (18.0 + x_20) : (7.0 + x_22))? (10.0 + x_19) : ((18.0 + x_20) > (7.0 + x_22)? (18.0 + x_20) : (7.0 + x_22)))) > (((11.0 + x_23) > (17.0 + x_25)? (11.0 + x_23) : (17.0 + x_25)) > ((12.0 + x_29) > ((1.0 + x_36) > (9.0 + x_37)? (1.0 + x_36) : (9.0 + x_37))? (12.0 + x_29) : ((1.0 + x_36) > (9.0 + x_37)? (1.0 + x_36) : (9.0 + x_37)))? ((11.0 + x_23) > (17.0 + x_25)? (11.0 + x_23) : (17.0 + x_25)) : ((12.0 + x_29) > ((1.0 + x_36) > (9.0 + x_37)? (1.0 + x_36) : (9.0 + x_37))? (12.0 + x_29) : ((1.0 + x_36) > (9.0 + x_37)? (1.0 + x_36) : (9.0 + x_37))))? (((11.0 + x_16) > (2.0 + x_18)? (11.0 + x_16) : (2.0 + x_18)) > ((10.0 + x_19) > ((18.0 + x_20) > (7.0 + x_22)? (18.0 + x_20) : (7.0 + x_22))? (10.0 + x_19) : ((18.0 + x_20) > (7.0 + x_22)? (18.0 + x_20) : (7.0 + x_22)))? ((11.0 + x_16) > (2.0 + x_18)? (11.0 + x_16) : (2.0 + x_18)) : ((10.0 + x_19) > ((18.0 + x_20) > (7.0 + x_22)? (18.0 + x_20) : (7.0 + x_22))? (10.0 + x_19) : ((18.0 + x_20) > (7.0 + x_22)? (18.0 + x_20) : (7.0 + x_22)))) : (((11.0 + x_23) > (17.0 + x_25)? (11.0 + x_23) : (17.0 + x_25)) > ((12.0 + x_29) > ((1.0 + x_36) > (9.0 + x_37)? (1.0 + x_36) : (9.0 + x_37))? (12.0 + x_29) : ((1.0 + x_36) > (9.0 + x_37)? (1.0 + x_36) : (9.0 + x_37)))? ((11.0 + x_23) > (17.0 + x_25)? (11.0 + x_23) : (17.0 + x_25)) : ((12.0 + x_29) > ((1.0 + x_36) > (9.0 + x_37)? (1.0 + x_36) : (9.0 + x_37))? (12.0 + x_29) : ((1.0 + x_36) > (9.0 + x_37)? (1.0 + x_36) : (9.0 + x_37))))));
x_31_ = (((((12.0 + x_0) > (9.0 + x_4)? (12.0 + x_0) : (9.0 + x_4)) > ((12.0 + x_8) > ((12.0 + x_9) > (10.0 + x_10)? (12.0 + x_9) : (10.0 + x_10))? (12.0 + x_8) : ((12.0 + x_9) > (10.0 + x_10)? (12.0 + x_9) : (10.0 + x_10)))? ((12.0 + x_0) > (9.0 + x_4)? (12.0 + x_0) : (9.0 + x_4)) : ((12.0 + x_8) > ((12.0 + x_9) > (10.0 + x_10)? (12.0 + x_9) : (10.0 + x_10))? (12.0 + x_8) : ((12.0 + x_9) > (10.0 + x_10)? (12.0 + x_9) : (10.0 + x_10)))) > (((13.0 + x_11) > (19.0 + x_12)? (13.0 + x_11) : (19.0 + x_12)) > ((10.0 + x_14) > ((16.0 + x_15) > (11.0 + x_17)? (16.0 + x_15) : (11.0 + x_17))? (10.0 + x_14) : ((16.0 + x_15) > (11.0 + x_17)? (16.0 + x_15) : (11.0 + x_17)))? ((13.0 + x_11) > (19.0 + x_12)? (13.0 + x_11) : (19.0 + x_12)) : ((10.0 + x_14) > ((16.0 + x_15) > (11.0 + x_17)? (16.0 + x_15) : (11.0 + x_17))? (10.0 + x_14) : ((16.0 + x_15) > (11.0 + x_17)? (16.0 + x_15) : (11.0 + x_17))))? (((12.0 + x_0) > (9.0 + x_4)? (12.0 + x_0) : (9.0 + x_4)) > ((12.0 + x_8) > ((12.0 + x_9) > (10.0 + x_10)? (12.0 + x_9) : (10.0 + x_10))? (12.0 + x_8) : ((12.0 + x_9) > (10.0 + x_10)? (12.0 + x_9) : (10.0 + x_10)))? ((12.0 + x_0) > (9.0 + x_4)? (12.0 + x_0) : (9.0 + x_4)) : ((12.0 + x_8) > ((12.0 + x_9) > (10.0 + x_10)? (12.0 + x_9) : (10.0 + x_10))? (12.0 + x_8) : ((12.0 + x_9) > (10.0 + x_10)? (12.0 + x_9) : (10.0 + x_10)))) : (((13.0 + x_11) > (19.0 + x_12)? (13.0 + x_11) : (19.0 + x_12)) > ((10.0 + x_14) > ((16.0 + x_15) > (11.0 + x_17)? (16.0 + x_15) : (11.0 + x_17))? (10.0 + x_14) : ((16.0 + x_15) > (11.0 + x_17)? (16.0 + x_15) : (11.0 + x_17)))? ((13.0 + x_11) > (19.0 + x_12)? (13.0 + x_11) : (19.0 + x_12)) : ((10.0 + x_14) > ((16.0 + x_15) > (11.0 + x_17)? (16.0 + x_15) : (11.0 + x_17))? (10.0 + x_14) : ((16.0 + x_15) > (11.0 + x_17)? (16.0 + x_15) : (11.0 + x_17))))) > ((((1.0 + x_18) > (19.0 + x_21)? (1.0 + x_18) : (19.0 + x_21)) > ((13.0 + x_22) > ((1.0 + x_23) > (5.0 + x_25)? (1.0 + x_23) : (5.0 + x_25))? (13.0 + x_22) : ((1.0 + x_23) > (5.0 + x_25)? (1.0 + x_23) : (5.0 + x_25)))? ((1.0 + x_18) > (19.0 + x_21)? (1.0 + x_18) : (19.0 + x_21)) : ((13.0 + x_22) > ((1.0 + x_23) > (5.0 + x_25)? (1.0 + x_23) : (5.0 + x_25))? (13.0 + x_22) : ((1.0 + x_23) > (5.0 + x_25)? (1.0 + x_23) : (5.0 + x_25)))) > (((11.0 + x_28) > (9.0 + x_29)? (11.0 + x_28) : (9.0 + x_29)) > ((1.0 + x_36) > ((10.0 + x_38) > (5.0 + x_39)? (10.0 + x_38) : (5.0 + x_39))? (1.0 + x_36) : ((10.0 + x_38) > (5.0 + x_39)? (10.0 + x_38) : (5.0 + x_39)))? ((11.0 + x_28) > (9.0 + x_29)? (11.0 + x_28) : (9.0 + x_29)) : ((1.0 + x_36) > ((10.0 + x_38) > (5.0 + x_39)? (10.0 + x_38) : (5.0 + x_39))? (1.0 + x_36) : ((10.0 + x_38) > (5.0 + x_39)? (10.0 + x_38) : (5.0 + x_39))))? (((1.0 + x_18) > (19.0 + x_21)? (1.0 + x_18) : (19.0 + x_21)) > ((13.0 + x_22) > ((1.0 + x_23) > (5.0 + x_25)? (1.0 + x_23) : (5.0 + x_25))? (13.0 + x_22) : ((1.0 + x_23) > (5.0 + x_25)? (1.0 + x_23) : (5.0 + x_25)))? ((1.0 + x_18) > (19.0 + x_21)? (1.0 + x_18) : (19.0 + x_21)) : ((13.0 + x_22) > ((1.0 + x_23) > (5.0 + x_25)? (1.0 + x_23) : (5.0 + x_25))? (13.0 + x_22) : ((1.0 + x_23) > (5.0 + x_25)? (1.0 + x_23) : (5.0 + x_25)))) : (((11.0 + x_28) > (9.0 + x_29)? (11.0 + x_28) : (9.0 + x_29)) > ((1.0 + x_36) > ((10.0 + x_38) > (5.0 + x_39)? (10.0 + x_38) : (5.0 + x_39))? (1.0 + x_36) : ((10.0 + x_38) > (5.0 + x_39)? (10.0 + x_38) : (5.0 + x_39)))? ((11.0 + x_28) > (9.0 + x_29)? (11.0 + x_28) : (9.0 + x_29)) : ((1.0 + x_36) > ((10.0 + x_38) > (5.0 + x_39)? (10.0 + x_38) : (5.0 + x_39))? (1.0 + x_36) : ((10.0 + x_38) > (5.0 + x_39)? (10.0 + x_38) : (5.0 + x_39)))))? ((((12.0 + x_0) > (9.0 + x_4)? (12.0 + x_0) : (9.0 + x_4)) > ((12.0 + x_8) > ((12.0 + x_9) > (10.0 + x_10)? (12.0 + x_9) : (10.0 + x_10))? (12.0 + x_8) : ((12.0 + x_9) > (10.0 + x_10)? (12.0 + x_9) : (10.0 + x_10)))? ((12.0 + x_0) > (9.0 + x_4)? (12.0 + x_0) : (9.0 + x_4)) : ((12.0 + x_8) > ((12.0 + x_9) > (10.0 + x_10)? (12.0 + x_9) : (10.0 + x_10))? (12.0 + x_8) : ((12.0 + x_9) > (10.0 + x_10)? (12.0 + x_9) : (10.0 + x_10)))) > (((13.0 + x_11) > (19.0 + x_12)? (13.0 + x_11) : (19.0 + x_12)) > ((10.0 + x_14) > ((16.0 + x_15) > (11.0 + x_17)? (16.0 + x_15) : (11.0 + x_17))? (10.0 + x_14) : ((16.0 + x_15) > (11.0 + x_17)? (16.0 + x_15) : (11.0 + x_17)))? ((13.0 + x_11) > (19.0 + x_12)? (13.0 + x_11) : (19.0 + x_12)) : ((10.0 + x_14) > ((16.0 + x_15) > (11.0 + x_17)? (16.0 + x_15) : (11.0 + x_17))? (10.0 + x_14) : ((16.0 + x_15) > (11.0 + x_17)? (16.0 + x_15) : (11.0 + x_17))))? (((12.0 + x_0) > (9.0 + x_4)? (12.0 + x_0) : (9.0 + x_4)) > ((12.0 + x_8) > ((12.0 + x_9) > (10.0 + x_10)? (12.0 + x_9) : (10.0 + x_10))? (12.0 + x_8) : ((12.0 + x_9) > (10.0 + x_10)? (12.0 + x_9) : (10.0 + x_10)))? ((12.0 + x_0) > (9.0 + x_4)? (12.0 + x_0) : (9.0 + x_4)) : ((12.0 + x_8) > ((12.0 + x_9) > (10.0 + x_10)? (12.0 + x_9) : (10.0 + x_10))? (12.0 + x_8) : ((12.0 + x_9) > (10.0 + x_10)? (12.0 + x_9) : (10.0 + x_10)))) : (((13.0 + x_11) > (19.0 + x_12)? (13.0 + x_11) : (19.0 + x_12)) > ((10.0 + x_14) > ((16.0 + x_15) > (11.0 + x_17)? (16.0 + x_15) : (11.0 + x_17))? (10.0 + x_14) : ((16.0 + x_15) > (11.0 + x_17)? (16.0 + x_15) : (11.0 + x_17)))? ((13.0 + x_11) > (19.0 + x_12)? (13.0 + x_11) : (19.0 + x_12)) : ((10.0 + x_14) > ((16.0 + x_15) > (11.0 + x_17)? (16.0 + x_15) : (11.0 + x_17))? (10.0 + x_14) : ((16.0 + x_15) > (11.0 + x_17)? (16.0 + x_15) : (11.0 + x_17))))) : ((((1.0 + x_18) > (19.0 + x_21)? (1.0 + x_18) : (19.0 + x_21)) > ((13.0 + x_22) > ((1.0 + x_23) > (5.0 + x_25)? (1.0 + x_23) : (5.0 + x_25))? (13.0 + x_22) : ((1.0 + x_23) > (5.0 + x_25)? (1.0 + x_23) : (5.0 + x_25)))? ((1.0 + x_18) > (19.0 + x_21)? (1.0 + x_18) : (19.0 + x_21)) : ((13.0 + x_22) > ((1.0 + x_23) > (5.0 + x_25)? (1.0 + x_23) : (5.0 + x_25))? (13.0 + x_22) : ((1.0 + x_23) > (5.0 + x_25)? (1.0 + x_23) : (5.0 + x_25)))) > (((11.0 + x_28) > (9.0 + x_29)? (11.0 + x_28) : (9.0 + x_29)) > ((1.0 + x_36) > ((10.0 + x_38) > (5.0 + x_39)? (10.0 + x_38) : (5.0 + x_39))? (1.0 + x_36) : ((10.0 + x_38) > (5.0 + x_39)? (10.0 + x_38) : (5.0 + x_39)))? ((11.0 + x_28) > (9.0 + x_29)? (11.0 + x_28) : (9.0 + x_29)) : ((1.0 + x_36) > ((10.0 + x_38) > (5.0 + x_39)? (10.0 + x_38) : (5.0 + x_39))? (1.0 + x_36) : ((10.0 + x_38) > (5.0 + x_39)? (10.0 + x_38) : (5.0 + x_39))))? (((1.0 + x_18) > (19.0 + x_21)? (1.0 + x_18) : (19.0 + x_21)) > ((13.0 + x_22) > ((1.0 + x_23) > (5.0 + x_25)? (1.0 + x_23) : (5.0 + x_25))? (13.0 + x_22) : ((1.0 + x_23) > (5.0 + x_25)? (1.0 + x_23) : (5.0 + x_25)))? ((1.0 + x_18) > (19.0 + x_21)? (1.0 + x_18) : (19.0 + x_21)) : ((13.0 + x_22) > ((1.0 + x_23) > (5.0 + x_25)? (1.0 + x_23) : (5.0 + x_25))? (13.0 + x_22) : ((1.0 + x_23) > (5.0 + x_25)? (1.0 + x_23) : (5.0 + x_25)))) : (((11.0 + x_28) > (9.0 + x_29)? (11.0 + x_28) : (9.0 + x_29)) > ((1.0 + x_36) > ((10.0 + x_38) > (5.0 + x_39)? (10.0 + x_38) : (5.0 + x_39))? (1.0 + x_36) : ((10.0 + x_38) > (5.0 + x_39)? (10.0 + x_38) : (5.0 + x_39)))? ((11.0 + x_28) > (9.0 + x_29)? (11.0 + x_28) : (9.0 + x_29)) : ((1.0 + x_36) > ((10.0 + x_38) > (5.0 + x_39)? (10.0 + x_38) : (5.0 + x_39))? (1.0 + x_36) : ((10.0 + x_38) > (5.0 + x_39)? (10.0 + x_38) : (5.0 + x_39))))));
x_32_ = (((((5.0 + x_1) > (3.0 + x_5)? (5.0 + x_1) : (3.0 + x_5)) > ((12.0 + x_6) > ((14.0 + x_11) > (12.0 + x_12)? (14.0 + x_11) : (12.0 + x_12))? (12.0 + x_6) : ((14.0 + x_11) > (12.0 + x_12)? (14.0 + x_11) : (12.0 + x_12)))? ((5.0 + x_1) > (3.0 + x_5)? (5.0 + x_1) : (3.0 + x_5)) : ((12.0 + x_6) > ((14.0 + x_11) > (12.0 + x_12)? (14.0 + x_11) : (12.0 + x_12))? (12.0 + x_6) : ((14.0 + x_11) > (12.0 + x_12)? (14.0 + x_11) : (12.0 + x_12)))) > (((12.0 + x_15) > (8.0 + x_17)? (12.0 + x_15) : (8.0 + x_17)) > ((9.0 + x_18) > ((4.0 + x_23) > (14.0 + x_25)? (4.0 + x_23) : (14.0 + x_25))? (9.0 + x_18) : ((4.0 + x_23) > (14.0 + x_25)? (4.0 + x_23) : (14.0 + x_25)))? ((12.0 + x_15) > (8.0 + x_17)? (12.0 + x_15) : (8.0 + x_17)) : ((9.0 + x_18) > ((4.0 + x_23) > (14.0 + x_25)? (4.0 + x_23) : (14.0 + x_25))? (9.0 + x_18) : ((4.0 + x_23) > (14.0 + x_25)? (4.0 + x_23) : (14.0 + x_25))))? (((5.0 + x_1) > (3.0 + x_5)? (5.0 + x_1) : (3.0 + x_5)) > ((12.0 + x_6) > ((14.0 + x_11) > (12.0 + x_12)? (14.0 + x_11) : (12.0 + x_12))? (12.0 + x_6) : ((14.0 + x_11) > (12.0 + x_12)? (14.0 + x_11) : (12.0 + x_12)))? ((5.0 + x_1) > (3.0 + x_5)? (5.0 + x_1) : (3.0 + x_5)) : ((12.0 + x_6) > ((14.0 + x_11) > (12.0 + x_12)? (14.0 + x_11) : (12.0 + x_12))? (12.0 + x_6) : ((14.0 + x_11) > (12.0 + x_12)? (14.0 + x_11) : (12.0 + x_12)))) : (((12.0 + x_15) > (8.0 + x_17)? (12.0 + x_15) : (8.0 + x_17)) > ((9.0 + x_18) > ((4.0 + x_23) > (14.0 + x_25)? (4.0 + x_23) : (14.0 + x_25))? (9.0 + x_18) : ((4.0 + x_23) > (14.0 + x_25)? (4.0 + x_23) : (14.0 + x_25)))? ((12.0 + x_15) > (8.0 + x_17)? (12.0 + x_15) : (8.0 + x_17)) : ((9.0 + x_18) > ((4.0 + x_23) > (14.0 + x_25)? (4.0 + x_23) : (14.0 + x_25))? (9.0 + x_18) : ((4.0 + x_23) > (14.0 + x_25)? (4.0 + x_23) : (14.0 + x_25))))) > ((((3.0 + x_26) > (10.0 + x_27)? (3.0 + x_26) : (10.0 + x_27)) > ((20.0 + x_28) > ((8.0 + x_29) > (13.0 + x_30)? (8.0 + x_29) : (13.0 + x_30))? (20.0 + x_28) : ((8.0 + x_29) > (13.0 + x_30)? (8.0 + x_29) : (13.0 + x_30)))? ((3.0 + x_26) > (10.0 + x_27)? (3.0 + x_26) : (10.0 + x_27)) : ((20.0 + x_28) > ((8.0 + x_29) > (13.0 + x_30)? (8.0 + x_29) : (13.0 + x_30))? (20.0 + x_28) : ((8.0 + x_29) > (13.0 + x_30)? (8.0 + x_29) : (13.0 + x_30)))) > (((14.0 + x_31) > (2.0 + x_32)? (14.0 + x_31) : (2.0 + x_32)) > ((9.0 + x_33) > ((1.0 + x_35) > (18.0 + x_39)? (1.0 + x_35) : (18.0 + x_39))? (9.0 + x_33) : ((1.0 + x_35) > (18.0 + x_39)? (1.0 + x_35) : (18.0 + x_39)))? ((14.0 + x_31) > (2.0 + x_32)? (14.0 + x_31) : (2.0 + x_32)) : ((9.0 + x_33) > ((1.0 + x_35) > (18.0 + x_39)? (1.0 + x_35) : (18.0 + x_39))? (9.0 + x_33) : ((1.0 + x_35) > (18.0 + x_39)? (1.0 + x_35) : (18.0 + x_39))))? (((3.0 + x_26) > (10.0 + x_27)? (3.0 + x_26) : (10.0 + x_27)) > ((20.0 + x_28) > ((8.0 + x_29) > (13.0 + x_30)? (8.0 + x_29) : (13.0 + x_30))? (20.0 + x_28) : ((8.0 + x_29) > (13.0 + x_30)? (8.0 + x_29) : (13.0 + x_30)))? ((3.0 + x_26) > (10.0 + x_27)? (3.0 + x_26) : (10.0 + x_27)) : ((20.0 + x_28) > ((8.0 + x_29) > (13.0 + x_30)? (8.0 + x_29) : (13.0 + x_30))? (20.0 + x_28) : ((8.0 + x_29) > (13.0 + x_30)? (8.0 + x_29) : (13.0 + x_30)))) : (((14.0 + x_31) > (2.0 + x_32)? (14.0 + x_31) : (2.0 + x_32)) > ((9.0 + x_33) > ((1.0 + x_35) > (18.0 + x_39)? (1.0 + x_35) : (18.0 + x_39))? (9.0 + x_33) : ((1.0 + x_35) > (18.0 + x_39)? (1.0 + x_35) : (18.0 + x_39)))? ((14.0 + x_31) > (2.0 + x_32)? (14.0 + x_31) : (2.0 + x_32)) : ((9.0 + x_33) > ((1.0 + x_35) > (18.0 + x_39)? (1.0 + x_35) : (18.0 + x_39))? (9.0 + x_33) : ((1.0 + x_35) > (18.0 + x_39)? (1.0 + x_35) : (18.0 + x_39)))))? ((((5.0 + x_1) > (3.0 + x_5)? (5.0 + x_1) : (3.0 + x_5)) > ((12.0 + x_6) > ((14.0 + x_11) > (12.0 + x_12)? (14.0 + x_11) : (12.0 + x_12))? (12.0 + x_6) : ((14.0 + x_11) > (12.0 + x_12)? (14.0 + x_11) : (12.0 + x_12)))? ((5.0 + x_1) > (3.0 + x_5)? (5.0 + x_1) : (3.0 + x_5)) : ((12.0 + x_6) > ((14.0 + x_11) > (12.0 + x_12)? (14.0 + x_11) : (12.0 + x_12))? (12.0 + x_6) : ((14.0 + x_11) > (12.0 + x_12)? (14.0 + x_11) : (12.0 + x_12)))) > (((12.0 + x_15) > (8.0 + x_17)? (12.0 + x_15) : (8.0 + x_17)) > ((9.0 + x_18) > ((4.0 + x_23) > (14.0 + x_25)? (4.0 + x_23) : (14.0 + x_25))? (9.0 + x_18) : ((4.0 + x_23) > (14.0 + x_25)? (4.0 + x_23) : (14.0 + x_25)))? ((12.0 + x_15) > (8.0 + x_17)? (12.0 + x_15) : (8.0 + x_17)) : ((9.0 + x_18) > ((4.0 + x_23) > (14.0 + x_25)? (4.0 + x_23) : (14.0 + x_25))? (9.0 + x_18) : ((4.0 + x_23) > (14.0 + x_25)? (4.0 + x_23) : (14.0 + x_25))))? (((5.0 + x_1) > (3.0 + x_5)? (5.0 + x_1) : (3.0 + x_5)) > ((12.0 + x_6) > ((14.0 + x_11) > (12.0 + x_12)? (14.0 + x_11) : (12.0 + x_12))? (12.0 + x_6) : ((14.0 + x_11) > (12.0 + x_12)? (14.0 + x_11) : (12.0 + x_12)))? ((5.0 + x_1) > (3.0 + x_5)? (5.0 + x_1) : (3.0 + x_5)) : ((12.0 + x_6) > ((14.0 + x_11) > (12.0 + x_12)? (14.0 + x_11) : (12.0 + x_12))? (12.0 + x_6) : ((14.0 + x_11) > (12.0 + x_12)? (14.0 + x_11) : (12.0 + x_12)))) : (((12.0 + x_15) > (8.0 + x_17)? (12.0 + x_15) : (8.0 + x_17)) > ((9.0 + x_18) > ((4.0 + x_23) > (14.0 + x_25)? (4.0 + x_23) : (14.0 + x_25))? (9.0 + x_18) : ((4.0 + x_23) > (14.0 + x_25)? (4.0 + x_23) : (14.0 + x_25)))? ((12.0 + x_15) > (8.0 + x_17)? (12.0 + x_15) : (8.0 + x_17)) : ((9.0 + x_18) > ((4.0 + x_23) > (14.0 + x_25)? (4.0 + x_23) : (14.0 + x_25))? (9.0 + x_18) : ((4.0 + x_23) > (14.0 + x_25)? (4.0 + x_23) : (14.0 + x_25))))) : ((((3.0 + x_26) > (10.0 + x_27)? (3.0 + x_26) : (10.0 + x_27)) > ((20.0 + x_28) > ((8.0 + x_29) > (13.0 + x_30)? (8.0 + x_29) : (13.0 + x_30))? (20.0 + x_28) : ((8.0 + x_29) > (13.0 + x_30)? (8.0 + x_29) : (13.0 + x_30)))? ((3.0 + x_26) > (10.0 + x_27)? (3.0 + x_26) : (10.0 + x_27)) : ((20.0 + x_28) > ((8.0 + x_29) > (13.0 + x_30)? (8.0 + x_29) : (13.0 + x_30))? (20.0 + x_28) : ((8.0 + x_29) > (13.0 + x_30)? (8.0 + x_29) : (13.0 + x_30)))) > (((14.0 + x_31) > (2.0 + x_32)? (14.0 + x_31) : (2.0 + x_32)) > ((9.0 + x_33) > ((1.0 + x_35) > (18.0 + x_39)? (1.0 + x_35) : (18.0 + x_39))? (9.0 + x_33) : ((1.0 + x_35) > (18.0 + x_39)? (1.0 + x_35) : (18.0 + x_39)))? ((14.0 + x_31) > (2.0 + x_32)? (14.0 + x_31) : (2.0 + x_32)) : ((9.0 + x_33) > ((1.0 + x_35) > (18.0 + x_39)? (1.0 + x_35) : (18.0 + x_39))? (9.0 + x_33) : ((1.0 + x_35) > (18.0 + x_39)? (1.0 + x_35) : (18.0 + x_39))))? (((3.0 + x_26) > (10.0 + x_27)? (3.0 + x_26) : (10.0 + x_27)) > ((20.0 + x_28) > ((8.0 + x_29) > (13.0 + x_30)? (8.0 + x_29) : (13.0 + x_30))? (20.0 + x_28) : ((8.0 + x_29) > (13.0 + x_30)? (8.0 + x_29) : (13.0 + x_30)))? ((3.0 + x_26) > (10.0 + x_27)? (3.0 + x_26) : (10.0 + x_27)) : ((20.0 + x_28) > ((8.0 + x_29) > (13.0 + x_30)? (8.0 + x_29) : (13.0 + x_30))? (20.0 + x_28) : ((8.0 + x_29) > (13.0 + x_30)? (8.0 + x_29) : (13.0 + x_30)))) : (((14.0 + x_31) > (2.0 + x_32)? (14.0 + x_31) : (2.0 + x_32)) > ((9.0 + x_33) > ((1.0 + x_35) > (18.0 + x_39)? (1.0 + x_35) : (18.0 + x_39))? (9.0 + x_33) : ((1.0 + x_35) > (18.0 + x_39)? (1.0 + x_35) : (18.0 + x_39)))? ((14.0 + x_31) > (2.0 + x_32)? (14.0 + x_31) : (2.0 + x_32)) : ((9.0 + x_33) > ((1.0 + x_35) > (18.0 + x_39)? (1.0 + x_35) : (18.0 + x_39))? (9.0 + x_33) : ((1.0 + x_35) > (18.0 + x_39)? (1.0 + x_35) : (18.0 + x_39))))));
x_33_ = (((((15.0 + x_0) > (6.0 + x_2)? (15.0 + x_0) : (6.0 + x_2)) > ((5.0 + x_3) > ((11.0 + x_4) > (17.0 + x_9)? (11.0 + x_4) : (17.0 + x_9))? (5.0 + x_3) : ((11.0 + x_4) > (17.0 + x_9)? (11.0 + x_4) : (17.0 + x_9)))? ((15.0 + x_0) > (6.0 + x_2)? (15.0 + x_0) : (6.0 + x_2)) : ((5.0 + x_3) > ((11.0 + x_4) > (17.0 + x_9)? (11.0 + x_4) : (17.0 + x_9))? (5.0 + x_3) : ((11.0 + x_4) > (17.0 + x_9)? (11.0 + x_4) : (17.0 + x_9)))) > (((5.0 + x_12) > (18.0 + x_13)? (5.0 + x_12) : (18.0 + x_13)) > ((20.0 + x_16) > ((8.0 + x_17) > (7.0 + x_19)? (8.0 + x_17) : (7.0 + x_19))? (20.0 + x_16) : ((8.0 + x_17) > (7.0 + x_19)? (8.0 + x_17) : (7.0 + x_19)))? ((5.0 + x_12) > (18.0 + x_13)? (5.0 + x_12) : (18.0 + x_13)) : ((20.0 + x_16) > ((8.0 + x_17) > (7.0 + x_19)? (8.0 + x_17) : (7.0 + x_19))? (20.0 + x_16) : ((8.0 + x_17) > (7.0 + x_19)? (8.0 + x_17) : (7.0 + x_19))))? (((15.0 + x_0) > (6.0 + x_2)? (15.0 + x_0) : (6.0 + x_2)) > ((5.0 + x_3) > ((11.0 + x_4) > (17.0 + x_9)? (11.0 + x_4) : (17.0 + x_9))? (5.0 + x_3) : ((11.0 + x_4) > (17.0 + x_9)? (11.0 + x_4) : (17.0 + x_9)))? ((15.0 + x_0) > (6.0 + x_2)? (15.0 + x_0) : (6.0 + x_2)) : ((5.0 + x_3) > ((11.0 + x_4) > (17.0 + x_9)? (11.0 + x_4) : (17.0 + x_9))? (5.0 + x_3) : ((11.0 + x_4) > (17.0 + x_9)? (11.0 + x_4) : (17.0 + x_9)))) : (((5.0 + x_12) > (18.0 + x_13)? (5.0 + x_12) : (18.0 + x_13)) > ((20.0 + x_16) > ((8.0 + x_17) > (7.0 + x_19)? (8.0 + x_17) : (7.0 + x_19))? (20.0 + x_16) : ((8.0 + x_17) > (7.0 + x_19)? (8.0 + x_17) : (7.0 + x_19)))? ((5.0 + x_12) > (18.0 + x_13)? (5.0 + x_12) : (18.0 + x_13)) : ((20.0 + x_16) > ((8.0 + x_17) > (7.0 + x_19)? (8.0 + x_17) : (7.0 + x_19))? (20.0 + x_16) : ((8.0 + x_17) > (7.0 + x_19)? (8.0 + x_17) : (7.0 + x_19))))) > ((((18.0 + x_21) > (7.0 + x_23)? (18.0 + x_21) : (7.0 + x_23)) > ((14.0 + x_24) > ((9.0 + x_25) > (12.0 + x_26)? (9.0 + x_25) : (12.0 + x_26))? (14.0 + x_24) : ((9.0 + x_25) > (12.0 + x_26)? (9.0 + x_25) : (12.0 + x_26)))? ((18.0 + x_21) > (7.0 + x_23)? (18.0 + x_21) : (7.0 + x_23)) : ((14.0 + x_24) > ((9.0 + x_25) > (12.0 + x_26)? (9.0 + x_25) : (12.0 + x_26))? (14.0 + x_24) : ((9.0 + x_25) > (12.0 + x_26)? (9.0 + x_25) : (12.0 + x_26)))) > (((17.0 + x_27) > (10.0 + x_30)? (17.0 + x_27) : (10.0 + x_30)) > ((8.0 + x_32) > ((6.0 + x_33) > (13.0 + x_38)? (6.0 + x_33) : (13.0 + x_38))? (8.0 + x_32) : ((6.0 + x_33) > (13.0 + x_38)? (6.0 + x_33) : (13.0 + x_38)))? ((17.0 + x_27) > (10.0 + x_30)? (17.0 + x_27) : (10.0 + x_30)) : ((8.0 + x_32) > ((6.0 + x_33) > (13.0 + x_38)? (6.0 + x_33) : (13.0 + x_38))? (8.0 + x_32) : ((6.0 + x_33) > (13.0 + x_38)? (6.0 + x_33) : (13.0 + x_38))))? (((18.0 + x_21) > (7.0 + x_23)? (18.0 + x_21) : (7.0 + x_23)) > ((14.0 + x_24) > ((9.0 + x_25) > (12.0 + x_26)? (9.0 + x_25) : (12.0 + x_26))? (14.0 + x_24) : ((9.0 + x_25) > (12.0 + x_26)? (9.0 + x_25) : (12.0 + x_26)))? ((18.0 + x_21) > (7.0 + x_23)? (18.0 + x_21) : (7.0 + x_23)) : ((14.0 + x_24) > ((9.0 + x_25) > (12.0 + x_26)? (9.0 + x_25) : (12.0 + x_26))? (14.0 + x_24) : ((9.0 + x_25) > (12.0 + x_26)? (9.0 + x_25) : (12.0 + x_26)))) : (((17.0 + x_27) > (10.0 + x_30)? (17.0 + x_27) : (10.0 + x_30)) > ((8.0 + x_32) > ((6.0 + x_33) > (13.0 + x_38)? (6.0 + x_33) : (13.0 + x_38))? (8.0 + x_32) : ((6.0 + x_33) > (13.0 + x_38)? (6.0 + x_33) : (13.0 + x_38)))? ((17.0 + x_27) > (10.0 + x_30)? (17.0 + x_27) : (10.0 + x_30)) : ((8.0 + x_32) > ((6.0 + x_33) > (13.0 + x_38)? (6.0 + x_33) : (13.0 + x_38))? (8.0 + x_32) : ((6.0 + x_33) > (13.0 + x_38)? (6.0 + x_33) : (13.0 + x_38)))))? ((((15.0 + x_0) > (6.0 + x_2)? (15.0 + x_0) : (6.0 + x_2)) > ((5.0 + x_3) > ((11.0 + x_4) > (17.0 + x_9)? (11.0 + x_4) : (17.0 + x_9))? (5.0 + x_3) : ((11.0 + x_4) > (17.0 + x_9)? (11.0 + x_4) : (17.0 + x_9)))? ((15.0 + x_0) > (6.0 + x_2)? (15.0 + x_0) : (6.0 + x_2)) : ((5.0 + x_3) > ((11.0 + x_4) > (17.0 + x_9)? (11.0 + x_4) : (17.0 + x_9))? (5.0 + x_3) : ((11.0 + x_4) > (17.0 + x_9)? (11.0 + x_4) : (17.0 + x_9)))) > (((5.0 + x_12) > (18.0 + x_13)? (5.0 + x_12) : (18.0 + x_13)) > ((20.0 + x_16) > ((8.0 + x_17) > (7.0 + x_19)? (8.0 + x_17) : (7.0 + x_19))? (20.0 + x_16) : ((8.0 + x_17) > (7.0 + x_19)? (8.0 + x_17) : (7.0 + x_19)))? ((5.0 + x_12) > (18.0 + x_13)? (5.0 + x_12) : (18.0 + x_13)) : ((20.0 + x_16) > ((8.0 + x_17) > (7.0 + x_19)? (8.0 + x_17) : (7.0 + x_19))? (20.0 + x_16) : ((8.0 + x_17) > (7.0 + x_19)? (8.0 + x_17) : (7.0 + x_19))))? (((15.0 + x_0) > (6.0 + x_2)? (15.0 + x_0) : (6.0 + x_2)) > ((5.0 + x_3) > ((11.0 + x_4) > (17.0 + x_9)? (11.0 + x_4) : (17.0 + x_9))? (5.0 + x_3) : ((11.0 + x_4) > (17.0 + x_9)? (11.0 + x_4) : (17.0 + x_9)))? ((15.0 + x_0) > (6.0 + x_2)? (15.0 + x_0) : (6.0 + x_2)) : ((5.0 + x_3) > ((11.0 + x_4) > (17.0 + x_9)? (11.0 + x_4) : (17.0 + x_9))? (5.0 + x_3) : ((11.0 + x_4) > (17.0 + x_9)? (11.0 + x_4) : (17.0 + x_9)))) : (((5.0 + x_12) > (18.0 + x_13)? (5.0 + x_12) : (18.0 + x_13)) > ((20.0 + x_16) > ((8.0 + x_17) > (7.0 + x_19)? (8.0 + x_17) : (7.0 + x_19))? (20.0 + x_16) : ((8.0 + x_17) > (7.0 + x_19)? (8.0 + x_17) : (7.0 + x_19)))? ((5.0 + x_12) > (18.0 + x_13)? (5.0 + x_12) : (18.0 + x_13)) : ((20.0 + x_16) > ((8.0 + x_17) > (7.0 + x_19)? (8.0 + x_17) : (7.0 + x_19))? (20.0 + x_16) : ((8.0 + x_17) > (7.0 + x_19)? (8.0 + x_17) : (7.0 + x_19))))) : ((((18.0 + x_21) > (7.0 + x_23)? (18.0 + x_21) : (7.0 + x_23)) > ((14.0 + x_24) > ((9.0 + x_25) > (12.0 + x_26)? (9.0 + x_25) : (12.0 + x_26))? (14.0 + x_24) : ((9.0 + x_25) > (12.0 + x_26)? (9.0 + x_25) : (12.0 + x_26)))? ((18.0 + x_21) > (7.0 + x_23)? (18.0 + x_21) : (7.0 + x_23)) : ((14.0 + x_24) > ((9.0 + x_25) > (12.0 + x_26)? (9.0 + x_25) : (12.0 + x_26))? (14.0 + x_24) : ((9.0 + x_25) > (12.0 + x_26)? (9.0 + x_25) : (12.0 + x_26)))) > (((17.0 + x_27) > (10.0 + x_30)? (17.0 + x_27) : (10.0 + x_30)) > ((8.0 + x_32) > ((6.0 + x_33) > (13.0 + x_38)? (6.0 + x_33) : (13.0 + x_38))? (8.0 + x_32) : ((6.0 + x_33) > (13.0 + x_38)? (6.0 + x_33) : (13.0 + x_38)))? ((17.0 + x_27) > (10.0 + x_30)? (17.0 + x_27) : (10.0 + x_30)) : ((8.0 + x_32) > ((6.0 + x_33) > (13.0 + x_38)? (6.0 + x_33) : (13.0 + x_38))? (8.0 + x_32) : ((6.0 + x_33) > (13.0 + x_38)? (6.0 + x_33) : (13.0 + x_38))))? (((18.0 + x_21) > (7.0 + x_23)? (18.0 + x_21) : (7.0 + x_23)) > ((14.0 + x_24) > ((9.0 + x_25) > (12.0 + x_26)? (9.0 + x_25) : (12.0 + x_26))? (14.0 + x_24) : ((9.0 + x_25) > (12.0 + x_26)? (9.0 + x_25) : (12.0 + x_26)))? ((18.0 + x_21) > (7.0 + x_23)? (18.0 + x_21) : (7.0 + x_23)) : ((14.0 + x_24) > ((9.0 + x_25) > (12.0 + x_26)? (9.0 + x_25) : (12.0 + x_26))? (14.0 + x_24) : ((9.0 + x_25) > (12.0 + x_26)? (9.0 + x_25) : (12.0 + x_26)))) : (((17.0 + x_27) > (10.0 + x_30)? (17.0 + x_27) : (10.0 + x_30)) > ((8.0 + x_32) > ((6.0 + x_33) > (13.0 + x_38)? (6.0 + x_33) : (13.0 + x_38))? (8.0 + x_32) : ((6.0 + x_33) > (13.0 + x_38)? (6.0 + x_33) : (13.0 + x_38)))? ((17.0 + x_27) > (10.0 + x_30)? (17.0 + x_27) : (10.0 + x_30)) : ((8.0 + x_32) > ((6.0 + x_33) > (13.0 + x_38)? (6.0 + x_33) : (13.0 + x_38))? (8.0 + x_32) : ((6.0 + x_33) > (13.0 + x_38)? (6.0 + x_33) : (13.0 + x_38))))));
x_34_ = (((((13.0 + x_1) > (16.0 + x_2)? (13.0 + x_1) : (16.0 + x_2)) > ((17.0 + x_4) > ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8))? (17.0 + x_4) : ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8)))? ((13.0 + x_1) > (16.0 + x_2)? (13.0 + x_1) : (16.0 + x_2)) : ((17.0 + x_4) > ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8))? (17.0 + x_4) : ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8)))) > (((17.0 + x_9) > (16.0 + x_10)? (17.0 + x_9) : (16.0 + x_10)) > ((1.0 + x_14) > ((19.0 + x_16) > (4.0 + x_19)? (19.0 + x_16) : (4.0 + x_19))? (1.0 + x_14) : ((19.0 + x_16) > (4.0 + x_19)? (19.0 + x_16) : (4.0 + x_19)))? ((17.0 + x_9) > (16.0 + x_10)? (17.0 + x_9) : (16.0 + x_10)) : ((1.0 + x_14) > ((19.0 + x_16) > (4.0 + x_19)? (19.0 + x_16) : (4.0 + x_19))? (1.0 + x_14) : ((19.0 + x_16) > (4.0 + x_19)? (19.0 + x_16) : (4.0 + x_19))))? (((13.0 + x_1) > (16.0 + x_2)? (13.0 + x_1) : (16.0 + x_2)) > ((17.0 + x_4) > ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8))? (17.0 + x_4) : ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8)))? ((13.0 + x_1) > (16.0 + x_2)? (13.0 + x_1) : (16.0 + x_2)) : ((17.0 + x_4) > ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8))? (17.0 + x_4) : ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8)))) : (((17.0 + x_9) > (16.0 + x_10)? (17.0 + x_9) : (16.0 + x_10)) > ((1.0 + x_14) > ((19.0 + x_16) > (4.0 + x_19)? (19.0 + x_16) : (4.0 + x_19))? (1.0 + x_14) : ((19.0 + x_16) > (4.0 + x_19)? (19.0 + x_16) : (4.0 + x_19)))? ((17.0 + x_9) > (16.0 + x_10)? (17.0 + x_9) : (16.0 + x_10)) : ((1.0 + x_14) > ((19.0 + x_16) > (4.0 + x_19)? (19.0 + x_16) : (4.0 + x_19))? (1.0 + x_14) : ((19.0 + x_16) > (4.0 + x_19)? (19.0 + x_16) : (4.0 + x_19))))) > ((((15.0 + x_20) > (10.0 + x_21)? (15.0 + x_20) : (10.0 + x_21)) > ((12.0 + x_22) > ((9.0 + x_24) > (5.0 + x_25)? (9.0 + x_24) : (5.0 + x_25))? (12.0 + x_22) : ((9.0 + x_24) > (5.0 + x_25)? (9.0 + x_24) : (5.0 + x_25)))? ((15.0 + x_20) > (10.0 + x_21)? (15.0 + x_20) : (10.0 + x_21)) : ((12.0 + x_22) > ((9.0 + x_24) > (5.0 + x_25)? (9.0 + x_24) : (5.0 + x_25))? (12.0 + x_22) : ((9.0 + x_24) > (5.0 + x_25)? (9.0 + x_24) : (5.0 + x_25)))) > (((9.0 + x_27) > (15.0 + x_28)? (9.0 + x_27) : (15.0 + x_28)) > ((8.0 + x_31) > ((15.0 + x_35) > (10.0 + x_37)? (15.0 + x_35) : (10.0 + x_37))? (8.0 + x_31) : ((15.0 + x_35) > (10.0 + x_37)? (15.0 + x_35) : (10.0 + x_37)))? ((9.0 + x_27) > (15.0 + x_28)? (9.0 + x_27) : (15.0 + x_28)) : ((8.0 + x_31) > ((15.0 + x_35) > (10.0 + x_37)? (15.0 + x_35) : (10.0 + x_37))? (8.0 + x_31) : ((15.0 + x_35) > (10.0 + x_37)? (15.0 + x_35) : (10.0 + x_37))))? (((15.0 + x_20) > (10.0 + x_21)? (15.0 + x_20) : (10.0 + x_21)) > ((12.0 + x_22) > ((9.0 + x_24) > (5.0 + x_25)? (9.0 + x_24) : (5.0 + x_25))? (12.0 + x_22) : ((9.0 + x_24) > (5.0 + x_25)? (9.0 + x_24) : (5.0 + x_25)))? ((15.0 + x_20) > (10.0 + x_21)? (15.0 + x_20) : (10.0 + x_21)) : ((12.0 + x_22) > ((9.0 + x_24) > (5.0 + x_25)? (9.0 + x_24) : (5.0 + x_25))? (12.0 + x_22) : ((9.0 + x_24) > (5.0 + x_25)? (9.0 + x_24) : (5.0 + x_25)))) : (((9.0 + x_27) > (15.0 + x_28)? (9.0 + x_27) : (15.0 + x_28)) > ((8.0 + x_31) > ((15.0 + x_35) > (10.0 + x_37)? (15.0 + x_35) : (10.0 + x_37))? (8.0 + x_31) : ((15.0 + x_35) > (10.0 + x_37)? (15.0 + x_35) : (10.0 + x_37)))? ((9.0 + x_27) > (15.0 + x_28)? (9.0 + x_27) : (15.0 + x_28)) : ((8.0 + x_31) > ((15.0 + x_35) > (10.0 + x_37)? (15.0 + x_35) : (10.0 + x_37))? (8.0 + x_31) : ((15.0 + x_35) > (10.0 + x_37)? (15.0 + x_35) : (10.0 + x_37)))))? ((((13.0 + x_1) > (16.0 + x_2)? (13.0 + x_1) : (16.0 + x_2)) > ((17.0 + x_4) > ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8))? (17.0 + x_4) : ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8)))? ((13.0 + x_1) > (16.0 + x_2)? (13.0 + x_1) : (16.0 + x_2)) : ((17.0 + x_4) > ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8))? (17.0 + x_4) : ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8)))) > (((17.0 + x_9) > (16.0 + x_10)? (17.0 + x_9) : (16.0 + x_10)) > ((1.0 + x_14) > ((19.0 + x_16) > (4.0 + x_19)? (19.0 + x_16) : (4.0 + x_19))? (1.0 + x_14) : ((19.0 + x_16) > (4.0 + x_19)? (19.0 + x_16) : (4.0 + x_19)))? ((17.0 + x_9) > (16.0 + x_10)? (17.0 + x_9) : (16.0 + x_10)) : ((1.0 + x_14) > ((19.0 + x_16) > (4.0 + x_19)? (19.0 + x_16) : (4.0 + x_19))? (1.0 + x_14) : ((19.0 + x_16) > (4.0 + x_19)? (19.0 + x_16) : (4.0 + x_19))))? (((13.0 + x_1) > (16.0 + x_2)? (13.0 + x_1) : (16.0 + x_2)) > ((17.0 + x_4) > ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8))? (17.0 + x_4) : ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8)))? ((13.0 + x_1) > (16.0 + x_2)? (13.0 + x_1) : (16.0 + x_2)) : ((17.0 + x_4) > ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8))? (17.0 + x_4) : ((18.0 + x_7) > (7.0 + x_8)? (18.0 + x_7) : (7.0 + x_8)))) : (((17.0 + x_9) > (16.0 + x_10)? (17.0 + x_9) : (16.0 + x_10)) > ((1.0 + x_14) > ((19.0 + x_16) > (4.0 + x_19)? (19.0 + x_16) : (4.0 + x_19))? (1.0 + x_14) : ((19.0 + x_16) > (4.0 + x_19)? (19.0 + x_16) : (4.0 + x_19)))? ((17.0 + x_9) > (16.0 + x_10)? (17.0 + x_9) : (16.0 + x_10)) : ((1.0 + x_14) > ((19.0 + x_16) > (4.0 + x_19)? (19.0 + x_16) : (4.0 + x_19))? (1.0 + x_14) : ((19.0 + x_16) > (4.0 + x_19)? (19.0 + x_16) : (4.0 + x_19))))) : ((((15.0 + x_20) > (10.0 + x_21)? (15.0 + x_20) : (10.0 + x_21)) > ((12.0 + x_22) > ((9.0 + x_24) > (5.0 + x_25)? (9.0 + x_24) : (5.0 + x_25))? (12.0 + x_22) : ((9.0 + x_24) > (5.0 + x_25)? (9.0 + x_24) : (5.0 + x_25)))? ((15.0 + x_20) > (10.0 + x_21)? (15.0 + x_20) : (10.0 + x_21)) : ((12.0 + x_22) > ((9.0 + x_24) > (5.0 + x_25)? (9.0 + x_24) : (5.0 + x_25))? (12.0 + x_22) : ((9.0 + x_24) > (5.0 + x_25)? (9.0 + x_24) : (5.0 + x_25)))) > (((9.0 + x_27) > (15.0 + x_28)? (9.0 + x_27) : (15.0 + x_28)) > ((8.0 + x_31) > ((15.0 + x_35) > (10.0 + x_37)? (15.0 + x_35) : (10.0 + x_37))? (8.0 + x_31) : ((15.0 + x_35) > (10.0 + x_37)? (15.0 + x_35) : (10.0 + x_37)))? ((9.0 + x_27) > (15.0 + x_28)? (9.0 + x_27) : (15.0 + x_28)) : ((8.0 + x_31) > ((15.0 + x_35) > (10.0 + x_37)? (15.0 + x_35) : (10.0 + x_37))? (8.0 + x_31) : ((15.0 + x_35) > (10.0 + x_37)? (15.0 + x_35) : (10.0 + x_37))))? (((15.0 + x_20) > (10.0 + x_21)? (15.0 + x_20) : (10.0 + x_21)) > ((12.0 + x_22) > ((9.0 + x_24) > (5.0 + x_25)? (9.0 + x_24) : (5.0 + x_25))? (12.0 + x_22) : ((9.0 + x_24) > (5.0 + x_25)? (9.0 + x_24) : (5.0 + x_25)))? ((15.0 + x_20) > (10.0 + x_21)? (15.0 + x_20) : (10.0 + x_21)) : ((12.0 + x_22) > ((9.0 + x_24) > (5.0 + x_25)? (9.0 + x_24) : (5.0 + x_25))? (12.0 + x_22) : ((9.0 + x_24) > (5.0 + x_25)? (9.0 + x_24) : (5.0 + x_25)))) : (((9.0 + x_27) > (15.0 + x_28)? (9.0 + x_27) : (15.0 + x_28)) > ((8.0 + x_31) > ((15.0 + x_35) > (10.0 + x_37)? (15.0 + x_35) : (10.0 + x_37))? (8.0 + x_31) : ((15.0 + x_35) > (10.0 + x_37)? (15.0 + x_35) : (10.0 + x_37)))? ((9.0 + x_27) > (15.0 + x_28)? (9.0 + x_27) : (15.0 + x_28)) : ((8.0 + x_31) > ((15.0 + x_35) > (10.0 + x_37)? (15.0 + x_35) : (10.0 + x_37))? (8.0 + x_31) : ((15.0 + x_35) > (10.0 + x_37)? (15.0 + x_35) : (10.0 + x_37))))));
x_35_ = (((((4.0 + x_0) > (3.0 + x_1)? (4.0 + x_0) : (3.0 + x_1)) > ((7.0 + x_3) > ((8.0 + x_4) > (19.0 + x_5)? (8.0 + x_4) : (19.0 + x_5))? (7.0 + x_3) : ((8.0 + x_4) > (19.0 + x_5)? (8.0 + x_4) : (19.0 + x_5)))? ((4.0 + x_0) > (3.0 + x_1)? (4.0 + x_0) : (3.0 + x_1)) : ((7.0 + x_3) > ((8.0 + x_4) > (19.0 + x_5)? (8.0 + x_4) : (19.0 + x_5))? (7.0 + x_3) : ((8.0 + x_4) > (19.0 + x_5)? (8.0 + x_4) : (19.0 + x_5)))) > (((3.0 + x_8) > (16.0 + x_11)? (3.0 + x_8) : (16.0 + x_11)) > ((3.0 + x_14) > ((18.0 + x_16) > (4.0 + x_17)? (18.0 + x_16) : (4.0 + x_17))? (3.0 + x_14) : ((18.0 + x_16) > (4.0 + x_17)? (18.0 + x_16) : (4.0 + x_17)))? ((3.0 + x_8) > (16.0 + x_11)? (3.0 + x_8) : (16.0 + x_11)) : ((3.0 + x_14) > ((18.0 + x_16) > (4.0 + x_17)? (18.0 + x_16) : (4.0 + x_17))? (3.0 + x_14) : ((18.0 + x_16) > (4.0 + x_17)? (18.0 + x_16) : (4.0 + x_17))))? (((4.0 + x_0) > (3.0 + x_1)? (4.0 + x_0) : (3.0 + x_1)) > ((7.0 + x_3) > ((8.0 + x_4) > (19.0 + x_5)? (8.0 + x_4) : (19.0 + x_5))? (7.0 + x_3) : ((8.0 + x_4) > (19.0 + x_5)? (8.0 + x_4) : (19.0 + x_5)))? ((4.0 + x_0) > (3.0 + x_1)? (4.0 + x_0) : (3.0 + x_1)) : ((7.0 + x_3) > ((8.0 + x_4) > (19.0 + x_5)? (8.0 + x_4) : (19.0 + x_5))? (7.0 + x_3) : ((8.0 + x_4) > (19.0 + x_5)? (8.0 + x_4) : (19.0 + x_5)))) : (((3.0 + x_8) > (16.0 + x_11)? (3.0 + x_8) : (16.0 + x_11)) > ((3.0 + x_14) > ((18.0 + x_16) > (4.0 + x_17)? (18.0 + x_16) : (4.0 + x_17))? (3.0 + x_14) : ((18.0 + x_16) > (4.0 + x_17)? (18.0 + x_16) : (4.0 + x_17)))? ((3.0 + x_8) > (16.0 + x_11)? (3.0 + x_8) : (16.0 + x_11)) : ((3.0 + x_14) > ((18.0 + x_16) > (4.0 + x_17)? (18.0 + x_16) : (4.0 + x_17))? (3.0 + x_14) : ((18.0 + x_16) > (4.0 + x_17)? (18.0 + x_16) : (4.0 + x_17))))) > ((((12.0 + x_21) > (12.0 + x_23)? (12.0 + x_21) : (12.0 + x_23)) > ((19.0 + x_24) > ((20.0 + x_27) > (6.0 + x_28)? (20.0 + x_27) : (6.0 + x_28))? (19.0 + x_24) : ((20.0 + x_27) > (6.0 + x_28)? (20.0 + x_27) : (6.0 + x_28)))? ((12.0 + x_21) > (12.0 + x_23)? (12.0 + x_21) : (12.0 + x_23)) : ((19.0 + x_24) > ((20.0 + x_27) > (6.0 + x_28)? (20.0 + x_27) : (6.0 + x_28))? (19.0 + x_24) : ((20.0 + x_27) > (6.0 + x_28)? (20.0 + x_27) : (6.0 + x_28)))) > (((20.0 + x_31) > (3.0 + x_34)? (20.0 + x_31) : (3.0 + x_34)) > ((16.0 + x_35) > ((17.0 + x_36) > (18.0 + x_37)? (17.0 + x_36) : (18.0 + x_37))? (16.0 + x_35) : ((17.0 + x_36) > (18.0 + x_37)? (17.0 + x_36) : (18.0 + x_37)))? ((20.0 + x_31) > (3.0 + x_34)? (20.0 + x_31) : (3.0 + x_34)) : ((16.0 + x_35) > ((17.0 + x_36) > (18.0 + x_37)? (17.0 + x_36) : (18.0 + x_37))? (16.0 + x_35) : ((17.0 + x_36) > (18.0 + x_37)? (17.0 + x_36) : (18.0 + x_37))))? (((12.0 + x_21) > (12.0 + x_23)? (12.0 + x_21) : (12.0 + x_23)) > ((19.0 + x_24) > ((20.0 + x_27) > (6.0 + x_28)? (20.0 + x_27) : (6.0 + x_28))? (19.0 + x_24) : ((20.0 + x_27) > (6.0 + x_28)? (20.0 + x_27) : (6.0 + x_28)))? ((12.0 + x_21) > (12.0 + x_23)? (12.0 + x_21) : (12.0 + x_23)) : ((19.0 + x_24) > ((20.0 + x_27) > (6.0 + x_28)? (20.0 + x_27) : (6.0 + x_28))? (19.0 + x_24) : ((20.0 + x_27) > (6.0 + x_28)? (20.0 + x_27) : (6.0 + x_28)))) : (((20.0 + x_31) > (3.0 + x_34)? (20.0 + x_31) : (3.0 + x_34)) > ((16.0 + x_35) > ((17.0 + x_36) > (18.0 + x_37)? (17.0 + x_36) : (18.0 + x_37))? (16.0 + x_35) : ((17.0 + x_36) > (18.0 + x_37)? (17.0 + x_36) : (18.0 + x_37)))? ((20.0 + x_31) > (3.0 + x_34)? (20.0 + x_31) : (3.0 + x_34)) : ((16.0 + x_35) > ((17.0 + x_36) > (18.0 + x_37)? (17.0 + x_36) : (18.0 + x_37))? (16.0 + x_35) : ((17.0 + x_36) > (18.0 + x_37)? (17.0 + x_36) : (18.0 + x_37)))))? ((((4.0 + x_0) > (3.0 + x_1)? (4.0 + x_0) : (3.0 + x_1)) > ((7.0 + x_3) > ((8.0 + x_4) > (19.0 + x_5)? (8.0 + x_4) : (19.0 + x_5))? (7.0 + x_3) : ((8.0 + x_4) > (19.0 + x_5)? (8.0 + x_4) : (19.0 + x_5)))? ((4.0 + x_0) > (3.0 + x_1)? (4.0 + x_0) : (3.0 + x_1)) : ((7.0 + x_3) > ((8.0 + x_4) > (19.0 + x_5)? (8.0 + x_4) : (19.0 + x_5))? (7.0 + x_3) : ((8.0 + x_4) > (19.0 + x_5)? (8.0 + x_4) : (19.0 + x_5)))) > (((3.0 + x_8) > (16.0 + x_11)? (3.0 + x_8) : (16.0 + x_11)) > ((3.0 + x_14) > ((18.0 + x_16) > (4.0 + x_17)? (18.0 + x_16) : (4.0 + x_17))? (3.0 + x_14) : ((18.0 + x_16) > (4.0 + x_17)? (18.0 + x_16) : (4.0 + x_17)))? ((3.0 + x_8) > (16.0 + x_11)? (3.0 + x_8) : (16.0 + x_11)) : ((3.0 + x_14) > ((18.0 + x_16) > (4.0 + x_17)? (18.0 + x_16) : (4.0 + x_17))? (3.0 + x_14) : ((18.0 + x_16) > (4.0 + x_17)? (18.0 + x_16) : (4.0 + x_17))))? (((4.0 + x_0) > (3.0 + x_1)? (4.0 + x_0) : (3.0 + x_1)) > ((7.0 + x_3) > ((8.0 + x_4) > (19.0 + x_5)? (8.0 + x_4) : (19.0 + x_5))? (7.0 + x_3) : ((8.0 + x_4) > (19.0 + x_5)? (8.0 + x_4) : (19.0 + x_5)))? ((4.0 + x_0) > (3.0 + x_1)? (4.0 + x_0) : (3.0 + x_1)) : ((7.0 + x_3) > ((8.0 + x_4) > (19.0 + x_5)? (8.0 + x_4) : (19.0 + x_5))? (7.0 + x_3) : ((8.0 + x_4) > (19.0 + x_5)? (8.0 + x_4) : (19.0 + x_5)))) : (((3.0 + x_8) > (16.0 + x_11)? (3.0 + x_8) : (16.0 + x_11)) > ((3.0 + x_14) > ((18.0 + x_16) > (4.0 + x_17)? (18.0 + x_16) : (4.0 + x_17))? (3.0 + x_14) : ((18.0 + x_16) > (4.0 + x_17)? (18.0 + x_16) : (4.0 + x_17)))? ((3.0 + x_8) > (16.0 + x_11)? (3.0 + x_8) : (16.0 + x_11)) : ((3.0 + x_14) > ((18.0 + x_16) > (4.0 + x_17)? (18.0 + x_16) : (4.0 + x_17))? (3.0 + x_14) : ((18.0 + x_16) > (4.0 + x_17)? (18.0 + x_16) : (4.0 + x_17))))) : ((((12.0 + x_21) > (12.0 + x_23)? (12.0 + x_21) : (12.0 + x_23)) > ((19.0 + x_24) > ((20.0 + x_27) > (6.0 + x_28)? (20.0 + x_27) : (6.0 + x_28))? (19.0 + x_24) : ((20.0 + x_27) > (6.0 + x_28)? (20.0 + x_27) : (6.0 + x_28)))? ((12.0 + x_21) > (12.0 + x_23)? (12.0 + x_21) : (12.0 + x_23)) : ((19.0 + x_24) > ((20.0 + x_27) > (6.0 + x_28)? (20.0 + x_27) : (6.0 + x_28))? (19.0 + x_24) : ((20.0 + x_27) > (6.0 + x_28)? (20.0 + x_27) : (6.0 + x_28)))) > (((20.0 + x_31) > (3.0 + x_34)? (20.0 + x_31) : (3.0 + x_34)) > ((16.0 + x_35) > ((17.0 + x_36) > (18.0 + x_37)? (17.0 + x_36) : (18.0 + x_37))? (16.0 + x_35) : ((17.0 + x_36) > (18.0 + x_37)? (17.0 + x_36) : (18.0 + x_37)))? ((20.0 + x_31) > (3.0 + x_34)? (20.0 + x_31) : (3.0 + x_34)) : ((16.0 + x_35) > ((17.0 + x_36) > (18.0 + x_37)? (17.0 + x_36) : (18.0 + x_37))? (16.0 + x_35) : ((17.0 + x_36) > (18.0 + x_37)? (17.0 + x_36) : (18.0 + x_37))))? (((12.0 + x_21) > (12.0 + x_23)? (12.0 + x_21) : (12.0 + x_23)) > ((19.0 + x_24) > ((20.0 + x_27) > (6.0 + x_28)? (20.0 + x_27) : (6.0 + x_28))? (19.0 + x_24) : ((20.0 + x_27) > (6.0 + x_28)? (20.0 + x_27) : (6.0 + x_28)))? ((12.0 + x_21) > (12.0 + x_23)? (12.0 + x_21) : (12.0 + x_23)) : ((19.0 + x_24) > ((20.0 + x_27) > (6.0 + x_28)? (20.0 + x_27) : (6.0 + x_28))? (19.0 + x_24) : ((20.0 + x_27) > (6.0 + x_28)? (20.0 + x_27) : (6.0 + x_28)))) : (((20.0 + x_31) > (3.0 + x_34)? (20.0 + x_31) : (3.0 + x_34)) > ((16.0 + x_35) > ((17.0 + x_36) > (18.0 + x_37)? (17.0 + x_36) : (18.0 + x_37))? (16.0 + x_35) : ((17.0 + x_36) > (18.0 + x_37)? (17.0 + x_36) : (18.0 + x_37)))? ((20.0 + x_31) > (3.0 + x_34)? (20.0 + x_31) : (3.0 + x_34)) : ((16.0 + x_35) > ((17.0 + x_36) > (18.0 + x_37)? (17.0 + x_36) : (18.0 + x_37))? (16.0 + x_35) : ((17.0 + x_36) > (18.0 + x_37)? (17.0 + x_36) : (18.0 + x_37))))));
x_36_ = (((((6.0 + x_2) > (6.0 + x_5)? (6.0 + x_2) : (6.0 + x_5)) > ((18.0 + x_6) > ((7.0 + x_9) > (10.0 + x_10)? (7.0 + x_9) : (10.0 + x_10))? (18.0 + x_6) : ((7.0 + x_9) > (10.0 + x_10)? (7.0 + x_9) : (10.0 + x_10)))? ((6.0 + x_2) > (6.0 + x_5)? (6.0 + x_2) : (6.0 + x_5)) : ((18.0 + x_6) > ((7.0 + x_9) > (10.0 + x_10)? (7.0 + x_9) : (10.0 + x_10))? (18.0 + x_6) : ((7.0 + x_9) > (10.0 + x_10)? (7.0 + x_9) : (10.0 + x_10)))) > (((20.0 + x_15) > (1.0 + x_16)? (20.0 + x_15) : (1.0 + x_16)) > ((1.0 + x_19) > ((15.0 + x_21) > (5.0 + x_23)? (15.0 + x_21) : (5.0 + x_23))? (1.0 + x_19) : ((15.0 + x_21) > (5.0 + x_23)? (15.0 + x_21) : (5.0 + x_23)))? ((20.0 + x_15) > (1.0 + x_16)? (20.0 + x_15) : (1.0 + x_16)) : ((1.0 + x_19) > ((15.0 + x_21) > (5.0 + x_23)? (15.0 + x_21) : (5.0 + x_23))? (1.0 + x_19) : ((15.0 + x_21) > (5.0 + x_23)? (15.0 + x_21) : (5.0 + x_23))))? (((6.0 + x_2) > (6.0 + x_5)? (6.0 + x_2) : (6.0 + x_5)) > ((18.0 + x_6) > ((7.0 + x_9) > (10.0 + x_10)? (7.0 + x_9) : (10.0 + x_10))? (18.0 + x_6) : ((7.0 + x_9) > (10.0 + x_10)? (7.0 + x_9) : (10.0 + x_10)))? ((6.0 + x_2) > (6.0 + x_5)? (6.0 + x_2) : (6.0 + x_5)) : ((18.0 + x_6) > ((7.0 + x_9) > (10.0 + x_10)? (7.0 + x_9) : (10.0 + x_10))? (18.0 + x_6) : ((7.0 + x_9) > (10.0 + x_10)? (7.0 + x_9) : (10.0 + x_10)))) : (((20.0 + x_15) > (1.0 + x_16)? (20.0 + x_15) : (1.0 + x_16)) > ((1.0 + x_19) > ((15.0 + x_21) > (5.0 + x_23)? (15.0 + x_21) : (5.0 + x_23))? (1.0 + x_19) : ((15.0 + x_21) > (5.0 + x_23)? (15.0 + x_21) : (5.0 + x_23)))? ((20.0 + x_15) > (1.0 + x_16)? (20.0 + x_15) : (1.0 + x_16)) : ((1.0 + x_19) > ((15.0 + x_21) > (5.0 + x_23)? (15.0 + x_21) : (5.0 + x_23))? (1.0 + x_19) : ((15.0 + x_21) > (5.0 + x_23)? (15.0 + x_21) : (5.0 + x_23))))) > ((((6.0 + x_24) > (13.0 + x_26)? (6.0 + x_24) : (13.0 + x_26)) > ((2.0 + x_27) > ((10.0 + x_29) > (6.0 + x_32)? (10.0 + x_29) : (6.0 + x_32))? (2.0 + x_27) : ((10.0 + x_29) > (6.0 + x_32)? (10.0 + x_29) : (6.0 + x_32)))? ((6.0 + x_24) > (13.0 + x_26)? (6.0 + x_24) : (13.0 + x_26)) : ((2.0 + x_27) > ((10.0 + x_29) > (6.0 + x_32)? (10.0 + x_29) : (6.0 + x_32))? (2.0 + x_27) : ((10.0 + x_29) > (6.0 + x_32)? (10.0 + x_29) : (6.0 + x_32)))) > (((17.0 + x_34) > (13.0 + x_35)? (17.0 + x_34) : (13.0 + x_35)) > ((9.0 + x_36) > ((2.0 + x_38) > (5.0 + x_39)? (2.0 + x_38) : (5.0 + x_39))? (9.0 + x_36) : ((2.0 + x_38) > (5.0 + x_39)? (2.0 + x_38) : (5.0 + x_39)))? ((17.0 + x_34) > (13.0 + x_35)? (17.0 + x_34) : (13.0 + x_35)) : ((9.0 + x_36) > ((2.0 + x_38) > (5.0 + x_39)? (2.0 + x_38) : (5.0 + x_39))? (9.0 + x_36) : ((2.0 + x_38) > (5.0 + x_39)? (2.0 + x_38) : (5.0 + x_39))))? (((6.0 + x_24) > (13.0 + x_26)? (6.0 + x_24) : (13.0 + x_26)) > ((2.0 + x_27) > ((10.0 + x_29) > (6.0 + x_32)? (10.0 + x_29) : (6.0 + x_32))? (2.0 + x_27) : ((10.0 + x_29) > (6.0 + x_32)? (10.0 + x_29) : (6.0 + x_32)))? ((6.0 + x_24) > (13.0 + x_26)? (6.0 + x_24) : (13.0 + x_26)) : ((2.0 + x_27) > ((10.0 + x_29) > (6.0 + x_32)? (10.0 + x_29) : (6.0 + x_32))? (2.0 + x_27) : ((10.0 + x_29) > (6.0 + x_32)? (10.0 + x_29) : (6.0 + x_32)))) : (((17.0 + x_34) > (13.0 + x_35)? (17.0 + x_34) : (13.0 + x_35)) > ((9.0 + x_36) > ((2.0 + x_38) > (5.0 + x_39)? (2.0 + x_38) : (5.0 + x_39))? (9.0 + x_36) : ((2.0 + x_38) > (5.0 + x_39)? (2.0 + x_38) : (5.0 + x_39)))? ((17.0 + x_34) > (13.0 + x_35)? (17.0 + x_34) : (13.0 + x_35)) : ((9.0 + x_36) > ((2.0 + x_38) > (5.0 + x_39)? (2.0 + x_38) : (5.0 + x_39))? (9.0 + x_36) : ((2.0 + x_38) > (5.0 + x_39)? (2.0 + x_38) : (5.0 + x_39)))))? ((((6.0 + x_2) > (6.0 + x_5)? (6.0 + x_2) : (6.0 + x_5)) > ((18.0 + x_6) > ((7.0 + x_9) > (10.0 + x_10)? (7.0 + x_9) : (10.0 + x_10))? (18.0 + x_6) : ((7.0 + x_9) > (10.0 + x_10)? (7.0 + x_9) : (10.0 + x_10)))? ((6.0 + x_2) > (6.0 + x_5)? (6.0 + x_2) : (6.0 + x_5)) : ((18.0 + x_6) > ((7.0 + x_9) > (10.0 + x_10)? (7.0 + x_9) : (10.0 + x_10))? (18.0 + x_6) : ((7.0 + x_9) > (10.0 + x_10)? (7.0 + x_9) : (10.0 + x_10)))) > (((20.0 + x_15) > (1.0 + x_16)? (20.0 + x_15) : (1.0 + x_16)) > ((1.0 + x_19) > ((15.0 + x_21) > (5.0 + x_23)? (15.0 + x_21) : (5.0 + x_23))? (1.0 + x_19) : ((15.0 + x_21) > (5.0 + x_23)? (15.0 + x_21) : (5.0 + x_23)))? ((20.0 + x_15) > (1.0 + x_16)? (20.0 + x_15) : (1.0 + x_16)) : ((1.0 + x_19) > ((15.0 + x_21) > (5.0 + x_23)? (15.0 + x_21) : (5.0 + x_23))? (1.0 + x_19) : ((15.0 + x_21) > (5.0 + x_23)? (15.0 + x_21) : (5.0 + x_23))))? (((6.0 + x_2) > (6.0 + x_5)? (6.0 + x_2) : (6.0 + x_5)) > ((18.0 + x_6) > ((7.0 + x_9) > (10.0 + x_10)? (7.0 + x_9) : (10.0 + x_10))? (18.0 + x_6) : ((7.0 + x_9) > (10.0 + x_10)? (7.0 + x_9) : (10.0 + x_10)))? ((6.0 + x_2) > (6.0 + x_5)? (6.0 + x_2) : (6.0 + x_5)) : ((18.0 + x_6) > ((7.0 + x_9) > (10.0 + x_10)? (7.0 + x_9) : (10.0 + x_10))? (18.0 + x_6) : ((7.0 + x_9) > (10.0 + x_10)? (7.0 + x_9) : (10.0 + x_10)))) : (((20.0 + x_15) > (1.0 + x_16)? (20.0 + x_15) : (1.0 + x_16)) > ((1.0 + x_19) > ((15.0 + x_21) > (5.0 + x_23)? (15.0 + x_21) : (5.0 + x_23))? (1.0 + x_19) : ((15.0 + x_21) > (5.0 + x_23)? (15.0 + x_21) : (5.0 + x_23)))? ((20.0 + x_15) > (1.0 + x_16)? (20.0 + x_15) : (1.0 + x_16)) : ((1.0 + x_19) > ((15.0 + x_21) > (5.0 + x_23)? (15.0 + x_21) : (5.0 + x_23))? (1.0 + x_19) : ((15.0 + x_21) > (5.0 + x_23)? (15.0 + x_21) : (5.0 + x_23))))) : ((((6.0 + x_24) > (13.0 + x_26)? (6.0 + x_24) : (13.0 + x_26)) > ((2.0 + x_27) > ((10.0 + x_29) > (6.0 + x_32)? (10.0 + x_29) : (6.0 + x_32))? (2.0 + x_27) : ((10.0 + x_29) > (6.0 + x_32)? (10.0 + x_29) : (6.0 + x_32)))? ((6.0 + x_24) > (13.0 + x_26)? (6.0 + x_24) : (13.0 + x_26)) : ((2.0 + x_27) > ((10.0 + x_29) > (6.0 + x_32)? (10.0 + x_29) : (6.0 + x_32))? (2.0 + x_27) : ((10.0 + x_29) > (6.0 + x_32)? (10.0 + x_29) : (6.0 + x_32)))) > (((17.0 + x_34) > (13.0 + x_35)? (17.0 + x_34) : (13.0 + x_35)) > ((9.0 + x_36) > ((2.0 + x_38) > (5.0 + x_39)? (2.0 + x_38) : (5.0 + x_39))? (9.0 + x_36) : ((2.0 + x_38) > (5.0 + x_39)? (2.0 + x_38) : (5.0 + x_39)))? ((17.0 + x_34) > (13.0 + x_35)? (17.0 + x_34) : (13.0 + x_35)) : ((9.0 + x_36) > ((2.0 + x_38) > (5.0 + x_39)? (2.0 + x_38) : (5.0 + x_39))? (9.0 + x_36) : ((2.0 + x_38) > (5.0 + x_39)? (2.0 + x_38) : (5.0 + x_39))))? (((6.0 + x_24) > (13.0 + x_26)? (6.0 + x_24) : (13.0 + x_26)) > ((2.0 + x_27) > ((10.0 + x_29) > (6.0 + x_32)? (10.0 + x_29) : (6.0 + x_32))? (2.0 + x_27) : ((10.0 + x_29) > (6.0 + x_32)? (10.0 + x_29) : (6.0 + x_32)))? ((6.0 + x_24) > (13.0 + x_26)? (6.0 + x_24) : (13.0 + x_26)) : ((2.0 + x_27) > ((10.0 + x_29) > (6.0 + x_32)? (10.0 + x_29) : (6.0 + x_32))? (2.0 + x_27) : ((10.0 + x_29) > (6.0 + x_32)? (10.0 + x_29) : (6.0 + x_32)))) : (((17.0 + x_34) > (13.0 + x_35)? (17.0 + x_34) : (13.0 + x_35)) > ((9.0 + x_36) > ((2.0 + x_38) > (5.0 + x_39)? (2.0 + x_38) : (5.0 + x_39))? (9.0 + x_36) : ((2.0 + x_38) > (5.0 + x_39)? (2.0 + x_38) : (5.0 + x_39)))? ((17.0 + x_34) > (13.0 + x_35)? (17.0 + x_34) : (13.0 + x_35)) : ((9.0 + x_36) > ((2.0 + x_38) > (5.0 + x_39)? (2.0 + x_38) : (5.0 + x_39))? (9.0 + x_36) : ((2.0 + x_38) > (5.0 + x_39)? (2.0 + x_38) : (5.0 + x_39))))));
x_37_ = (((((14.0 + x_3) > (6.0 + x_4)? (14.0 + x_3) : (6.0 + x_4)) > ((10.0 + x_5) > ((4.0 + x_8) > (6.0 + x_10)? (4.0 + x_8) : (6.0 + x_10))? (10.0 + x_5) : ((4.0 + x_8) > (6.0 + x_10)? (4.0 + x_8) : (6.0 + x_10)))? ((14.0 + x_3) > (6.0 + x_4)? (14.0 + x_3) : (6.0 + x_4)) : ((10.0 + x_5) > ((4.0 + x_8) > (6.0 + x_10)? (4.0 + x_8) : (6.0 + x_10))? (10.0 + x_5) : ((4.0 + x_8) > (6.0 + x_10)? (4.0 + x_8) : (6.0 + x_10)))) > (((10.0 + x_11) > (9.0 + x_14)? (10.0 + x_11) : (9.0 + x_14)) > ((15.0 + x_16) > ((16.0 + x_18) > (6.0 + x_19)? (16.0 + x_18) : (6.0 + x_19))? (15.0 + x_16) : ((16.0 + x_18) > (6.0 + x_19)? (16.0 + x_18) : (6.0 + x_19)))? ((10.0 + x_11) > (9.0 + x_14)? (10.0 + x_11) : (9.0 + x_14)) : ((15.0 + x_16) > ((16.0 + x_18) > (6.0 + x_19)? (16.0 + x_18) : (6.0 + x_19))? (15.0 + x_16) : ((16.0 + x_18) > (6.0 + x_19)? (16.0 + x_18) : (6.0 + x_19))))? (((14.0 + x_3) > (6.0 + x_4)? (14.0 + x_3) : (6.0 + x_4)) > ((10.0 + x_5) > ((4.0 + x_8) > (6.0 + x_10)? (4.0 + x_8) : (6.0 + x_10))? (10.0 + x_5) : ((4.0 + x_8) > (6.0 + x_10)? (4.0 + x_8) : (6.0 + x_10)))? ((14.0 + x_3) > (6.0 + x_4)? (14.0 + x_3) : (6.0 + x_4)) : ((10.0 + x_5) > ((4.0 + x_8) > (6.0 + x_10)? (4.0 + x_8) : (6.0 + x_10))? (10.0 + x_5) : ((4.0 + x_8) > (6.0 + x_10)? (4.0 + x_8) : (6.0 + x_10)))) : (((10.0 + x_11) > (9.0 + x_14)? (10.0 + x_11) : (9.0 + x_14)) > ((15.0 + x_16) > ((16.0 + x_18) > (6.0 + x_19)? (16.0 + x_18) : (6.0 + x_19))? (15.0 + x_16) : ((16.0 + x_18) > (6.0 + x_19)? (16.0 + x_18) : (6.0 + x_19)))? ((10.0 + x_11) > (9.0 + x_14)? (10.0 + x_11) : (9.0 + x_14)) : ((15.0 + x_16) > ((16.0 + x_18) > (6.0 + x_19)? (16.0 + x_18) : (6.0 + x_19))? (15.0 + x_16) : ((16.0 + x_18) > (6.0 + x_19)? (16.0 + x_18) : (6.0 + x_19))))) > ((((6.0 + x_20) > (14.0 + x_21)? (6.0 + x_20) : (14.0 + x_21)) > ((4.0 + x_26) > ((2.0 + x_29) > (15.0 + x_31)? (2.0 + x_29) : (15.0 + x_31))? (4.0 + x_26) : ((2.0 + x_29) > (15.0 + x_31)? (2.0 + x_29) : (15.0 + x_31)))? ((6.0 + x_20) > (14.0 + x_21)? (6.0 + x_20) : (14.0 + x_21)) : ((4.0 + x_26) > ((2.0 + x_29) > (15.0 + x_31)? (2.0 + x_29) : (15.0 + x_31))? (4.0 + x_26) : ((2.0 + x_29) > (15.0 + x_31)? (2.0 + x_29) : (15.0 + x_31)))) > (((6.0 + x_32) > (17.0 + x_35)? (6.0 + x_32) : (17.0 + x_35)) > ((1.0 + x_36) > ((8.0 + x_38) > (1.0 + x_39)? (8.0 + x_38) : (1.0 + x_39))? (1.0 + x_36) : ((8.0 + x_38) > (1.0 + x_39)? (8.0 + x_38) : (1.0 + x_39)))? ((6.0 + x_32) > (17.0 + x_35)? (6.0 + x_32) : (17.0 + x_35)) : ((1.0 + x_36) > ((8.0 + x_38) > (1.0 + x_39)? (8.0 + x_38) : (1.0 + x_39))? (1.0 + x_36) : ((8.0 + x_38) > (1.0 + x_39)? (8.0 + x_38) : (1.0 + x_39))))? (((6.0 + x_20) > (14.0 + x_21)? (6.0 + x_20) : (14.0 + x_21)) > ((4.0 + x_26) > ((2.0 + x_29) > (15.0 + x_31)? (2.0 + x_29) : (15.0 + x_31))? (4.0 + x_26) : ((2.0 + x_29) > (15.0 + x_31)? (2.0 + x_29) : (15.0 + x_31)))? ((6.0 + x_20) > (14.0 + x_21)? (6.0 + x_20) : (14.0 + x_21)) : ((4.0 + x_26) > ((2.0 + x_29) > (15.0 + x_31)? (2.0 + x_29) : (15.0 + x_31))? (4.0 + x_26) : ((2.0 + x_29) > (15.0 + x_31)? (2.0 + x_29) : (15.0 + x_31)))) : (((6.0 + x_32) > (17.0 + x_35)? (6.0 + x_32) : (17.0 + x_35)) > ((1.0 + x_36) > ((8.0 + x_38) > (1.0 + x_39)? (8.0 + x_38) : (1.0 + x_39))? (1.0 + x_36) : ((8.0 + x_38) > (1.0 + x_39)? (8.0 + x_38) : (1.0 + x_39)))? ((6.0 + x_32) > (17.0 + x_35)? (6.0 + x_32) : (17.0 + x_35)) : ((1.0 + x_36) > ((8.0 + x_38) > (1.0 + x_39)? (8.0 + x_38) : (1.0 + x_39))? (1.0 + x_36) : ((8.0 + x_38) > (1.0 + x_39)? (8.0 + x_38) : (1.0 + x_39)))))? ((((14.0 + x_3) > (6.0 + x_4)? (14.0 + x_3) : (6.0 + x_4)) > ((10.0 + x_5) > ((4.0 + x_8) > (6.0 + x_10)? (4.0 + x_8) : (6.0 + x_10))? (10.0 + x_5) : ((4.0 + x_8) > (6.0 + x_10)? (4.0 + x_8) : (6.0 + x_10)))? ((14.0 + x_3) > (6.0 + x_4)? (14.0 + x_3) : (6.0 + x_4)) : ((10.0 + x_5) > ((4.0 + x_8) > (6.0 + x_10)? (4.0 + x_8) : (6.0 + x_10))? (10.0 + x_5) : ((4.0 + x_8) > (6.0 + x_10)? (4.0 + x_8) : (6.0 + x_10)))) > (((10.0 + x_11) > (9.0 + x_14)? (10.0 + x_11) : (9.0 + x_14)) > ((15.0 + x_16) > ((16.0 + x_18) > (6.0 + x_19)? (16.0 + x_18) : (6.0 + x_19))? (15.0 + x_16) : ((16.0 + x_18) > (6.0 + x_19)? (16.0 + x_18) : (6.0 + x_19)))? ((10.0 + x_11) > (9.0 + x_14)? (10.0 + x_11) : (9.0 + x_14)) : ((15.0 + x_16) > ((16.0 + x_18) > (6.0 + x_19)? (16.0 + x_18) : (6.0 + x_19))? (15.0 + x_16) : ((16.0 + x_18) > (6.0 + x_19)? (16.0 + x_18) : (6.0 + x_19))))? (((14.0 + x_3) > (6.0 + x_4)? (14.0 + x_3) : (6.0 + x_4)) > ((10.0 + x_5) > ((4.0 + x_8) > (6.0 + x_10)? (4.0 + x_8) : (6.0 + x_10))? (10.0 + x_5) : ((4.0 + x_8) > (6.0 + x_10)? (4.0 + x_8) : (6.0 + x_10)))? ((14.0 + x_3) > (6.0 + x_4)? (14.0 + x_3) : (6.0 + x_4)) : ((10.0 + x_5) > ((4.0 + x_8) > (6.0 + x_10)? (4.0 + x_8) : (6.0 + x_10))? (10.0 + x_5) : ((4.0 + x_8) > (6.0 + x_10)? (4.0 + x_8) : (6.0 + x_10)))) : (((10.0 + x_11) > (9.0 + x_14)? (10.0 + x_11) : (9.0 + x_14)) > ((15.0 + x_16) > ((16.0 + x_18) > (6.0 + x_19)? (16.0 + x_18) : (6.0 + x_19))? (15.0 + x_16) : ((16.0 + x_18) > (6.0 + x_19)? (16.0 + x_18) : (6.0 + x_19)))? ((10.0 + x_11) > (9.0 + x_14)? (10.0 + x_11) : (9.0 + x_14)) : ((15.0 + x_16) > ((16.0 + x_18) > (6.0 + x_19)? (16.0 + x_18) : (6.0 + x_19))? (15.0 + x_16) : ((16.0 + x_18) > (6.0 + x_19)? (16.0 + x_18) : (6.0 + x_19))))) : ((((6.0 + x_20) > (14.0 + x_21)? (6.0 + x_20) : (14.0 + x_21)) > ((4.0 + x_26) > ((2.0 + x_29) > (15.0 + x_31)? (2.0 + x_29) : (15.0 + x_31))? (4.0 + x_26) : ((2.0 + x_29) > (15.0 + x_31)? (2.0 + x_29) : (15.0 + x_31)))? ((6.0 + x_20) > (14.0 + x_21)? (6.0 + x_20) : (14.0 + x_21)) : ((4.0 + x_26) > ((2.0 + x_29) > (15.0 + x_31)? (2.0 + x_29) : (15.0 + x_31))? (4.0 + x_26) : ((2.0 + x_29) > (15.0 + x_31)? (2.0 + x_29) : (15.0 + x_31)))) > (((6.0 + x_32) > (17.0 + x_35)? (6.0 + x_32) : (17.0 + x_35)) > ((1.0 + x_36) > ((8.0 + x_38) > (1.0 + x_39)? (8.0 + x_38) : (1.0 + x_39))? (1.0 + x_36) : ((8.0 + x_38) > (1.0 + x_39)? (8.0 + x_38) : (1.0 + x_39)))? ((6.0 + x_32) > (17.0 + x_35)? (6.0 + x_32) : (17.0 + x_35)) : ((1.0 + x_36) > ((8.0 + x_38) > (1.0 + x_39)? (8.0 + x_38) : (1.0 + x_39))? (1.0 + x_36) : ((8.0 + x_38) > (1.0 + x_39)? (8.0 + x_38) : (1.0 + x_39))))? (((6.0 + x_20) > (14.0 + x_21)? (6.0 + x_20) : (14.0 + x_21)) > ((4.0 + x_26) > ((2.0 + x_29) > (15.0 + x_31)? (2.0 + x_29) : (15.0 + x_31))? (4.0 + x_26) : ((2.0 + x_29) > (15.0 + x_31)? (2.0 + x_29) : (15.0 + x_31)))? ((6.0 + x_20) > (14.0 + x_21)? (6.0 + x_20) : (14.0 + x_21)) : ((4.0 + x_26) > ((2.0 + x_29) > (15.0 + x_31)? (2.0 + x_29) : (15.0 + x_31))? (4.0 + x_26) : ((2.0 + x_29) > (15.0 + x_31)? (2.0 + x_29) : (15.0 + x_31)))) : (((6.0 + x_32) > (17.0 + x_35)? (6.0 + x_32) : (17.0 + x_35)) > ((1.0 + x_36) > ((8.0 + x_38) > (1.0 + x_39)? (8.0 + x_38) : (1.0 + x_39))? (1.0 + x_36) : ((8.0 + x_38) > (1.0 + x_39)? (8.0 + x_38) : (1.0 + x_39)))? ((6.0 + x_32) > (17.0 + x_35)? (6.0 + x_32) : (17.0 + x_35)) : ((1.0 + x_36) > ((8.0 + x_38) > (1.0 + x_39)? (8.0 + x_38) : (1.0 + x_39))? (1.0 + x_36) : ((8.0 + x_38) > (1.0 + x_39)? (8.0 + x_38) : (1.0 + x_39))))));
x_38_ = (((((4.0 + x_0) > (20.0 + x_3)? (4.0 + x_0) : (20.0 + x_3)) > ((18.0 + x_5) > ((8.0 + x_8) > (10.0 + x_11)? (8.0 + x_8) : (10.0 + x_11))? (18.0 + x_5) : ((8.0 + x_8) > (10.0 + x_11)? (8.0 + x_8) : (10.0 + x_11)))? ((4.0 + x_0) > (20.0 + x_3)? (4.0 + x_0) : (20.0 + x_3)) : ((18.0 + x_5) > ((8.0 + x_8) > (10.0 + x_11)? (8.0 + x_8) : (10.0 + x_11))? (18.0 + x_5) : ((8.0 + x_8) > (10.0 + x_11)? (8.0 + x_8) : (10.0 + x_11)))) > (((4.0 + x_12) > (2.0 + x_14)? (4.0 + x_12) : (2.0 + x_14)) > ((6.0 + x_16) > ((4.0 + x_18) > (16.0 + x_19)? (4.0 + x_18) : (16.0 + x_19))? (6.0 + x_16) : ((4.0 + x_18) > (16.0 + x_19)? (4.0 + x_18) : (16.0 + x_19)))? ((4.0 + x_12) > (2.0 + x_14)? (4.0 + x_12) : (2.0 + x_14)) : ((6.0 + x_16) > ((4.0 + x_18) > (16.0 + x_19)? (4.0 + x_18) : (16.0 + x_19))? (6.0 + x_16) : ((4.0 + x_18) > (16.0 + x_19)? (4.0 + x_18) : (16.0 + x_19))))? (((4.0 + x_0) > (20.0 + x_3)? (4.0 + x_0) : (20.0 + x_3)) > ((18.0 + x_5) > ((8.0 + x_8) > (10.0 + x_11)? (8.0 + x_8) : (10.0 + x_11))? (18.0 + x_5) : ((8.0 + x_8) > (10.0 + x_11)? (8.0 + x_8) : (10.0 + x_11)))? ((4.0 + x_0) > (20.0 + x_3)? (4.0 + x_0) : (20.0 + x_3)) : ((18.0 + x_5) > ((8.0 + x_8) > (10.0 + x_11)? (8.0 + x_8) : (10.0 + x_11))? (18.0 + x_5) : ((8.0 + x_8) > (10.0 + x_11)? (8.0 + x_8) : (10.0 + x_11)))) : (((4.0 + x_12) > (2.0 + x_14)? (4.0 + x_12) : (2.0 + x_14)) > ((6.0 + x_16) > ((4.0 + x_18) > (16.0 + x_19)? (4.0 + x_18) : (16.0 + x_19))? (6.0 + x_16) : ((4.0 + x_18) > (16.0 + x_19)? (4.0 + x_18) : (16.0 + x_19)))? ((4.0 + x_12) > (2.0 + x_14)? (4.0 + x_12) : (2.0 + x_14)) : ((6.0 + x_16) > ((4.0 + x_18) > (16.0 + x_19)? (4.0 + x_18) : (16.0 + x_19))? (6.0 + x_16) : ((4.0 + x_18) > (16.0 + x_19)? (4.0 + x_18) : (16.0 + x_19))))) > ((((1.0 + x_21) > (9.0 + x_23)? (1.0 + x_21) : (9.0 + x_23)) > ((14.0 + x_25) > ((7.0 + x_26) > (19.0 + x_29)? (7.0 + x_26) : (19.0 + x_29))? (14.0 + x_25) : ((7.0 + x_26) > (19.0 + x_29)? (7.0 + x_26) : (19.0 + x_29)))? ((1.0 + x_21) > (9.0 + x_23)? (1.0 + x_21) : (9.0 + x_23)) : ((14.0 + x_25) > ((7.0 + x_26) > (19.0 + x_29)? (7.0 + x_26) : (19.0 + x_29))? (14.0 + x_25) : ((7.0 + x_26) > (19.0 + x_29)? (7.0 + x_26) : (19.0 + x_29)))) > (((18.0 + x_32) > (19.0 + x_34)? (18.0 + x_32) : (19.0 + x_34)) > ((11.0 + x_36) > ((5.0 + x_37) > (17.0 + x_38)? (5.0 + x_37) : (17.0 + x_38))? (11.0 + x_36) : ((5.0 + x_37) > (17.0 + x_38)? (5.0 + x_37) : (17.0 + x_38)))? ((18.0 + x_32) > (19.0 + x_34)? (18.0 + x_32) : (19.0 + x_34)) : ((11.0 + x_36) > ((5.0 + x_37) > (17.0 + x_38)? (5.0 + x_37) : (17.0 + x_38))? (11.0 + x_36) : ((5.0 + x_37) > (17.0 + x_38)? (5.0 + x_37) : (17.0 + x_38))))? (((1.0 + x_21) > (9.0 + x_23)? (1.0 + x_21) : (9.0 + x_23)) > ((14.0 + x_25) > ((7.0 + x_26) > (19.0 + x_29)? (7.0 + x_26) : (19.0 + x_29))? (14.0 + x_25) : ((7.0 + x_26) > (19.0 + x_29)? (7.0 + x_26) : (19.0 + x_29)))? ((1.0 + x_21) > (9.0 + x_23)? (1.0 + x_21) : (9.0 + x_23)) : ((14.0 + x_25) > ((7.0 + x_26) > (19.0 + x_29)? (7.0 + x_26) : (19.0 + x_29))? (14.0 + x_25) : ((7.0 + x_26) > (19.0 + x_29)? (7.0 + x_26) : (19.0 + x_29)))) : (((18.0 + x_32) > (19.0 + x_34)? (18.0 + x_32) : (19.0 + x_34)) > ((11.0 + x_36) > ((5.0 + x_37) > (17.0 + x_38)? (5.0 + x_37) : (17.0 + x_38))? (11.0 + x_36) : ((5.0 + x_37) > (17.0 + x_38)? (5.0 + x_37) : (17.0 + x_38)))? ((18.0 + x_32) > (19.0 + x_34)? (18.0 + x_32) : (19.0 + x_34)) : ((11.0 + x_36) > ((5.0 + x_37) > (17.0 + x_38)? (5.0 + x_37) : (17.0 + x_38))? (11.0 + x_36) : ((5.0 + x_37) > (17.0 + x_38)? (5.0 + x_37) : (17.0 + x_38)))))? ((((4.0 + x_0) > (20.0 + x_3)? (4.0 + x_0) : (20.0 + x_3)) > ((18.0 + x_5) > ((8.0 + x_8) > (10.0 + x_11)? (8.0 + x_8) : (10.0 + x_11))? (18.0 + x_5) : ((8.0 + x_8) > (10.0 + x_11)? (8.0 + x_8) : (10.0 + x_11)))? ((4.0 + x_0) > (20.0 + x_3)? (4.0 + x_0) : (20.0 + x_3)) : ((18.0 + x_5) > ((8.0 + x_8) > (10.0 + x_11)? (8.0 + x_8) : (10.0 + x_11))? (18.0 + x_5) : ((8.0 + x_8) > (10.0 + x_11)? (8.0 + x_8) : (10.0 + x_11)))) > (((4.0 + x_12) > (2.0 + x_14)? (4.0 + x_12) : (2.0 + x_14)) > ((6.0 + x_16) > ((4.0 + x_18) > (16.0 + x_19)? (4.0 + x_18) : (16.0 + x_19))? (6.0 + x_16) : ((4.0 + x_18) > (16.0 + x_19)? (4.0 + x_18) : (16.0 + x_19)))? ((4.0 + x_12) > (2.0 + x_14)? (4.0 + x_12) : (2.0 + x_14)) : ((6.0 + x_16) > ((4.0 + x_18) > (16.0 + x_19)? (4.0 + x_18) : (16.0 + x_19))? (6.0 + x_16) : ((4.0 + x_18) > (16.0 + x_19)? (4.0 + x_18) : (16.0 + x_19))))? (((4.0 + x_0) > (20.0 + x_3)? (4.0 + x_0) : (20.0 + x_3)) > ((18.0 + x_5) > ((8.0 + x_8) > (10.0 + x_11)? (8.0 + x_8) : (10.0 + x_11))? (18.0 + x_5) : ((8.0 + x_8) > (10.0 + x_11)? (8.0 + x_8) : (10.0 + x_11)))? ((4.0 + x_0) > (20.0 + x_3)? (4.0 + x_0) : (20.0 + x_3)) : ((18.0 + x_5) > ((8.0 + x_8) > (10.0 + x_11)? (8.0 + x_8) : (10.0 + x_11))? (18.0 + x_5) : ((8.0 + x_8) > (10.0 + x_11)? (8.0 + x_8) : (10.0 + x_11)))) : (((4.0 + x_12) > (2.0 + x_14)? (4.0 + x_12) : (2.0 + x_14)) > ((6.0 + x_16) > ((4.0 + x_18) > (16.0 + x_19)? (4.0 + x_18) : (16.0 + x_19))? (6.0 + x_16) : ((4.0 + x_18) > (16.0 + x_19)? (4.0 + x_18) : (16.0 + x_19)))? ((4.0 + x_12) > (2.0 + x_14)? (4.0 + x_12) : (2.0 + x_14)) : ((6.0 + x_16) > ((4.0 + x_18) > (16.0 + x_19)? (4.0 + x_18) : (16.0 + x_19))? (6.0 + x_16) : ((4.0 + x_18) > (16.0 + x_19)? (4.0 + x_18) : (16.0 + x_19))))) : ((((1.0 + x_21) > (9.0 + x_23)? (1.0 + x_21) : (9.0 + x_23)) > ((14.0 + x_25) > ((7.0 + x_26) > (19.0 + x_29)? (7.0 + x_26) : (19.0 + x_29))? (14.0 + x_25) : ((7.0 + x_26) > (19.0 + x_29)? (7.0 + x_26) : (19.0 + x_29)))? ((1.0 + x_21) > (9.0 + x_23)? (1.0 + x_21) : (9.0 + x_23)) : ((14.0 + x_25) > ((7.0 + x_26) > (19.0 + x_29)? (7.0 + x_26) : (19.0 + x_29))? (14.0 + x_25) : ((7.0 + x_26) > (19.0 + x_29)? (7.0 + x_26) : (19.0 + x_29)))) > (((18.0 + x_32) > (19.0 + x_34)? (18.0 + x_32) : (19.0 + x_34)) > ((11.0 + x_36) > ((5.0 + x_37) > (17.0 + x_38)? (5.0 + x_37) : (17.0 + x_38))? (11.0 + x_36) : ((5.0 + x_37) > (17.0 + x_38)? (5.0 + x_37) : (17.0 + x_38)))? ((18.0 + x_32) > (19.0 + x_34)? (18.0 + x_32) : (19.0 + x_34)) : ((11.0 + x_36) > ((5.0 + x_37) > (17.0 + x_38)? (5.0 + x_37) : (17.0 + x_38))? (11.0 + x_36) : ((5.0 + x_37) > (17.0 + x_38)? (5.0 + x_37) : (17.0 + x_38))))? (((1.0 + x_21) > (9.0 + x_23)? (1.0 + x_21) : (9.0 + x_23)) > ((14.0 + x_25) > ((7.0 + x_26) > (19.0 + x_29)? (7.0 + x_26) : (19.0 + x_29))? (14.0 + x_25) : ((7.0 + x_26) > (19.0 + x_29)? (7.0 + x_26) : (19.0 + x_29)))? ((1.0 + x_21) > (9.0 + x_23)? (1.0 + x_21) : (9.0 + x_23)) : ((14.0 + x_25) > ((7.0 + x_26) > (19.0 + x_29)? (7.0 + x_26) : (19.0 + x_29))? (14.0 + x_25) : ((7.0 + x_26) > (19.0 + x_29)? (7.0 + x_26) : (19.0 + x_29)))) : (((18.0 + x_32) > (19.0 + x_34)? (18.0 + x_32) : (19.0 + x_34)) > ((11.0 + x_36) > ((5.0 + x_37) > (17.0 + x_38)? (5.0 + x_37) : (17.0 + x_38))? (11.0 + x_36) : ((5.0 + x_37) > (17.0 + x_38)? (5.0 + x_37) : (17.0 + x_38)))? ((18.0 + x_32) > (19.0 + x_34)? (18.0 + x_32) : (19.0 + x_34)) : ((11.0 + x_36) > ((5.0 + x_37) > (17.0 + x_38)? (5.0 + x_37) : (17.0 + x_38))? (11.0 + x_36) : ((5.0 + x_37) > (17.0 + x_38)? (5.0 + x_37) : (17.0 + x_38))))));
x_39_ = (((((1.0 + x_0) > (6.0 + x_2)? (1.0 + x_0) : (6.0 + x_2)) > ((19.0 + x_4) > ((10.0 + x_8) > (13.0 + x_9)? (10.0 + x_8) : (13.0 + x_9))? (19.0 + x_4) : ((10.0 + x_8) > (13.0 + x_9)? (10.0 + x_8) : (13.0 + x_9)))? ((1.0 + x_0) > (6.0 + x_2)? (1.0 + x_0) : (6.0 + x_2)) : ((19.0 + x_4) > ((10.0 + x_8) > (13.0 + x_9)? (10.0 + x_8) : (13.0 + x_9))? (19.0 + x_4) : ((10.0 + x_8) > (13.0 + x_9)? (10.0 + x_8) : (13.0 + x_9)))) > (((6.0 + x_10) > (10.0 + x_11)? (6.0 + x_10) : (10.0 + x_11)) > ((13.0 + x_12) > ((2.0 + x_13) > (11.0 + x_15)? (2.0 + x_13) : (11.0 + x_15))? (13.0 + x_12) : ((2.0 + x_13) > (11.0 + x_15)? (2.0 + x_13) : (11.0 + x_15)))? ((6.0 + x_10) > (10.0 + x_11)? (6.0 + x_10) : (10.0 + x_11)) : ((13.0 + x_12) > ((2.0 + x_13) > (11.0 + x_15)? (2.0 + x_13) : (11.0 + x_15))? (13.0 + x_12) : ((2.0 + x_13) > (11.0 + x_15)? (2.0 + x_13) : (11.0 + x_15))))? (((1.0 + x_0) > (6.0 + x_2)? (1.0 + x_0) : (6.0 + x_2)) > ((19.0 + x_4) > ((10.0 + x_8) > (13.0 + x_9)? (10.0 + x_8) : (13.0 + x_9))? (19.0 + x_4) : ((10.0 + x_8) > (13.0 + x_9)? (10.0 + x_8) : (13.0 + x_9)))? ((1.0 + x_0) > (6.0 + x_2)? (1.0 + x_0) : (6.0 + x_2)) : ((19.0 + x_4) > ((10.0 + x_8) > (13.0 + x_9)? (10.0 + x_8) : (13.0 + x_9))? (19.0 + x_4) : ((10.0 + x_8) > (13.0 + x_9)? (10.0 + x_8) : (13.0 + x_9)))) : (((6.0 + x_10) > (10.0 + x_11)? (6.0 + x_10) : (10.0 + x_11)) > ((13.0 + x_12) > ((2.0 + x_13) > (11.0 + x_15)? (2.0 + x_13) : (11.0 + x_15))? (13.0 + x_12) : ((2.0 + x_13) > (11.0 + x_15)? (2.0 + x_13) : (11.0 + x_15)))? ((6.0 + x_10) > (10.0 + x_11)? (6.0 + x_10) : (10.0 + x_11)) : ((13.0 + x_12) > ((2.0 + x_13) > (11.0 + x_15)? (2.0 + x_13) : (11.0 + x_15))? (13.0 + x_12) : ((2.0 + x_13) > (11.0 + x_15)? (2.0 + x_13) : (11.0 + x_15))))) > ((((2.0 + x_16) > (4.0 + x_21)? (2.0 + x_16) : (4.0 + x_21)) > ((12.0 + x_23) > ((4.0 + x_25) > (15.0 + x_27)? (4.0 + x_25) : (15.0 + x_27))? (12.0 + x_23) : ((4.0 + x_25) > (15.0 + x_27)? (4.0 + x_25) : (15.0 + x_27)))? ((2.0 + x_16) > (4.0 + x_21)? (2.0 + x_16) : (4.0 + x_21)) : ((12.0 + x_23) > ((4.0 + x_25) > (15.0 + x_27)? (4.0 + x_25) : (15.0 + x_27))? (12.0 + x_23) : ((4.0 + x_25) > (15.0 + x_27)? (4.0 + x_25) : (15.0 + x_27)))) > (((16.0 + x_29) > (11.0 + x_33)? (16.0 + x_29) : (11.0 + x_33)) > ((16.0 + x_37) > ((5.0 + x_38) > (20.0 + x_39)? (5.0 + x_38) : (20.0 + x_39))? (16.0 + x_37) : ((5.0 + x_38) > (20.0 + x_39)? (5.0 + x_38) : (20.0 + x_39)))? ((16.0 + x_29) > (11.0 + x_33)? (16.0 + x_29) : (11.0 + x_33)) : ((16.0 + x_37) > ((5.0 + x_38) > (20.0 + x_39)? (5.0 + x_38) : (20.0 + x_39))? (16.0 + x_37) : ((5.0 + x_38) > (20.0 + x_39)? (5.0 + x_38) : (20.0 + x_39))))? (((2.0 + x_16) > (4.0 + x_21)? (2.0 + x_16) : (4.0 + x_21)) > ((12.0 + x_23) > ((4.0 + x_25) > (15.0 + x_27)? (4.0 + x_25) : (15.0 + x_27))? (12.0 + x_23) : ((4.0 + x_25) > (15.0 + x_27)? (4.0 + x_25) : (15.0 + x_27)))? ((2.0 + x_16) > (4.0 + x_21)? (2.0 + x_16) : (4.0 + x_21)) : ((12.0 + x_23) > ((4.0 + x_25) > (15.0 + x_27)? (4.0 + x_25) : (15.0 + x_27))? (12.0 + x_23) : ((4.0 + x_25) > (15.0 + x_27)? (4.0 + x_25) : (15.0 + x_27)))) : (((16.0 + x_29) > (11.0 + x_33)? (16.0 + x_29) : (11.0 + x_33)) > ((16.0 + x_37) > ((5.0 + x_38) > (20.0 + x_39)? (5.0 + x_38) : (20.0 + x_39))? (16.0 + x_37) : ((5.0 + x_38) > (20.0 + x_39)? (5.0 + x_38) : (20.0 + x_39)))? ((16.0 + x_29) > (11.0 + x_33)? (16.0 + x_29) : (11.0 + x_33)) : ((16.0 + x_37) > ((5.0 + x_38) > (20.0 + x_39)? (5.0 + x_38) : (20.0 + x_39))? (16.0 + x_37) : ((5.0 + x_38) > (20.0 + x_39)? (5.0 + x_38) : (20.0 + x_39)))))? ((((1.0 + x_0) > (6.0 + x_2)? (1.0 + x_0) : (6.0 + x_2)) > ((19.0 + x_4) > ((10.0 + x_8) > (13.0 + x_9)? (10.0 + x_8) : (13.0 + x_9))? (19.0 + x_4) : ((10.0 + x_8) > (13.0 + x_9)? (10.0 + x_8) : (13.0 + x_9)))? ((1.0 + x_0) > (6.0 + x_2)? (1.0 + x_0) : (6.0 + x_2)) : ((19.0 + x_4) > ((10.0 + x_8) > (13.0 + x_9)? (10.0 + x_8) : (13.0 + x_9))? (19.0 + x_4) : ((10.0 + x_8) > (13.0 + x_9)? (10.0 + x_8) : (13.0 + x_9)))) > (((6.0 + x_10) > (10.0 + x_11)? (6.0 + x_10) : (10.0 + x_11)) > ((13.0 + x_12) > ((2.0 + x_13) > (11.0 + x_15)? (2.0 + x_13) : (11.0 + x_15))? (13.0 + x_12) : ((2.0 + x_13) > (11.0 + x_15)? (2.0 + x_13) : (11.0 + x_15)))? ((6.0 + x_10) > (10.0 + x_11)? (6.0 + x_10) : (10.0 + x_11)) : ((13.0 + x_12) > ((2.0 + x_13) > (11.0 + x_15)? (2.0 + x_13) : (11.0 + x_15))? (13.0 + x_12) : ((2.0 + x_13) > (11.0 + x_15)? (2.0 + x_13) : (11.0 + x_15))))? (((1.0 + x_0) > (6.0 + x_2)? (1.0 + x_0) : (6.0 + x_2)) > ((19.0 + x_4) > ((10.0 + x_8) > (13.0 + x_9)? (10.0 + x_8) : (13.0 + x_9))? (19.0 + x_4) : ((10.0 + x_8) > (13.0 + x_9)? (10.0 + x_8) : (13.0 + x_9)))? ((1.0 + x_0) > (6.0 + x_2)? (1.0 + x_0) : (6.0 + x_2)) : ((19.0 + x_4) > ((10.0 + x_8) > (13.0 + x_9)? (10.0 + x_8) : (13.0 + x_9))? (19.0 + x_4) : ((10.0 + x_8) > (13.0 + x_9)? (10.0 + x_8) : (13.0 + x_9)))) : (((6.0 + x_10) > (10.0 + x_11)? (6.0 + x_10) : (10.0 + x_11)) > ((13.0 + x_12) > ((2.0 + x_13) > (11.0 + x_15)? (2.0 + x_13) : (11.0 + x_15))? (13.0 + x_12) : ((2.0 + x_13) > (11.0 + x_15)? (2.0 + x_13) : (11.0 + x_15)))? ((6.0 + x_10) > (10.0 + x_11)? (6.0 + x_10) : (10.0 + x_11)) : ((13.0 + x_12) > ((2.0 + x_13) > (11.0 + x_15)? (2.0 + x_13) : (11.0 + x_15))? (13.0 + x_12) : ((2.0 + x_13) > (11.0 + x_15)? (2.0 + x_13) : (11.0 + x_15))))) : ((((2.0 + x_16) > (4.0 + x_21)? (2.0 + x_16) : (4.0 + x_21)) > ((12.0 + x_23) > ((4.0 + x_25) > (15.0 + x_27)? (4.0 + x_25) : (15.0 + x_27))? (12.0 + x_23) : ((4.0 + x_25) > (15.0 + x_27)? (4.0 + x_25) : (15.0 + x_27)))? ((2.0 + x_16) > (4.0 + x_21)? (2.0 + x_16) : (4.0 + x_21)) : ((12.0 + x_23) > ((4.0 + x_25) > (15.0 + x_27)? (4.0 + x_25) : (15.0 + x_27))? (12.0 + x_23) : ((4.0 + x_25) > (15.0 + x_27)? (4.0 + x_25) : (15.0 + x_27)))) > (((16.0 + x_29) > (11.0 + x_33)? (16.0 + x_29) : (11.0 + x_33)) > ((16.0 + x_37) > ((5.0 + x_38) > (20.0 + x_39)? (5.0 + x_38) : (20.0 + x_39))? (16.0 + x_37) : ((5.0 + x_38) > (20.0 + x_39)? (5.0 + x_38) : (20.0 + x_39)))? ((16.0 + x_29) > (11.0 + x_33)? (16.0 + x_29) : (11.0 + x_33)) : ((16.0 + x_37) > ((5.0 + x_38) > (20.0 + x_39)? (5.0 + x_38) : (20.0 + x_39))? (16.0 + x_37) : ((5.0 + x_38) > (20.0 + x_39)? (5.0 + x_38) : (20.0 + x_39))))? (((2.0 + x_16) > (4.0 + x_21)? (2.0 + x_16) : (4.0 + x_21)) > ((12.0 + x_23) > ((4.0 + x_25) > (15.0 + x_27)? (4.0 + x_25) : (15.0 + x_27))? (12.0 + x_23) : ((4.0 + x_25) > (15.0 + x_27)? (4.0 + x_25) : (15.0 + x_27)))? ((2.0 + x_16) > (4.0 + x_21)? (2.0 + x_16) : (4.0 + x_21)) : ((12.0 + x_23) > ((4.0 + x_25) > (15.0 + x_27)? (4.0 + x_25) : (15.0 + x_27))? (12.0 + x_23) : ((4.0 + x_25) > (15.0 + x_27)? (4.0 + x_25) : (15.0 + x_27)))) : (((16.0 + x_29) > (11.0 + x_33)? (16.0 + x_29) : (11.0 + x_33)) > ((16.0 + x_37) > ((5.0 + x_38) > (20.0 + x_39)? (5.0 + x_38) : (20.0 + x_39))? (16.0 + x_37) : ((5.0 + x_38) > (20.0 + x_39)? (5.0 + x_38) : (20.0 + x_39)))? ((16.0 + x_29) > (11.0 + x_33)? (16.0 + x_29) : (11.0 + x_33)) : ((16.0 + x_37) > ((5.0 + x_38) > (20.0 + x_39)? (5.0 + x_38) : (20.0 + x_39))? (16.0 + x_37) : ((5.0 + x_38) > (20.0 + x_39)? (5.0 + x_38) : (20.0 + x_39))))));
x_0 = x_0_;
x_1 = x_1_;
x_2 = x_2_;
x_3 = x_3_;
x_4 = x_4_;
x_5 = x_5_;
x_6 = x_6_;
x_7 = x_7_;
x_8 = x_8_;
x_9 = x_9_;
x_10 = x_10_;
x_11 = x_11_;
x_12 = x_12_;
x_13 = x_13_;
x_14 = x_14_;
x_15 = x_15_;
x_16 = x_16_;
x_17 = x_17_;
x_18 = x_18_;
x_19 = x_19_;
x_20 = x_20_;
x_21 = x_21_;
x_22 = x_22_;
x_23 = x_23_;
x_24 = x_24_;
x_25 = x_25_;
x_26 = x_26_;
x_27 = x_27_;
x_28 = x_28_;
x_29 = x_29_;
x_30 = x_30_;
x_31 = x_31_;
x_32 = x_32_;
x_33 = x_33_;
x_34 = x_34_;
x_35 = x_35_;
x_36 = x_36_;
x_37 = x_37_;
x_38 = x_38_;
x_39 = x_39_;
}
return 0;
}
|
the_stack_data/1190989.c | int leq_float(const void *a, const void *b)
{
return *((float*)a)<=*((float*)b);
}
int leq_int(const void *a, const void *b)
{
return *((int*)a)<=*((int*)b);
}
int geq_int(const void *a, const void *b)
{
return *((int*)a)>=*((int*)b);
} |
the_stack_data/129858.c | int main(){
int a, b, soma;
a = 5;
printf("%d\n", a);
b = 10;
printf("%d\n", b);
soma = a+b;
printf("A soma é: %d", soma);
}
|
the_stack_data/48423.c | /* f2c.h -- Standard Fortran to C header file */
/** barf [ba:rf] 2. "He suggested using FORTRAN, and everybody barfed."
- From The Shogakukan DICTIONARY OF NEW ENGLISH (Second edition) */
#ifndef F2C_INCLUDE
#define F2C_INCLUDE
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <complex.h>
#ifdef complex
#undef complex
#endif
#ifdef I
#undef I
#endif
#if defined(_WIN64)
typedef long long BLASLONG;
typedef unsigned long long BLASULONG;
#else
typedef long BLASLONG;
typedef unsigned long BLASULONG;
#endif
#ifdef LAPACK_ILP64
typedef BLASLONG blasint;
#if defined(_WIN64)
#define blasabs(x) llabs(x)
#else
#define blasabs(x) labs(x)
#endif
#else
typedef int blasint;
#define blasabs(x) abs(x)
#endif
typedef blasint integer;
typedef unsigned int uinteger;
typedef char *address;
typedef short int shortint;
typedef float real;
typedef double doublereal;
typedef struct { real r, i; } complex;
typedef struct { doublereal r, i; } doublecomplex;
static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
#define pCf(z) (*_pCf(z))
#define pCd(z) (*_pCd(z))
typedef int logical;
typedef short int shortlogical;
typedef char logical1;
typedef char integer1;
#define TRUE_ (1)
#define FALSE_ (0)
/* Extern is for use with -E */
#ifndef Extern
#define Extern extern
#endif
/* I/O stuff */
typedef int flag;
typedef int ftnlen;
typedef int ftnint;
/*external read, write*/
typedef struct
{ flag cierr;
ftnint ciunit;
flag ciend;
char *cifmt;
ftnint cirec;
} cilist;
/*internal read, write*/
typedef struct
{ flag icierr;
char *iciunit;
flag iciend;
char *icifmt;
ftnint icirlen;
ftnint icirnum;
} icilist;
/*open*/
typedef struct
{ flag oerr;
ftnint ounit;
char *ofnm;
ftnlen ofnmlen;
char *osta;
char *oacc;
char *ofm;
ftnint orl;
char *oblnk;
} olist;
/*close*/
typedef struct
{ flag cerr;
ftnint cunit;
char *csta;
} cllist;
/*rewind, backspace, endfile*/
typedef struct
{ flag aerr;
ftnint aunit;
} alist;
/* inquire */
typedef struct
{ flag inerr;
ftnint inunit;
char *infile;
ftnlen infilen;
ftnint *inex; /*parameters in standard's order*/
ftnint *inopen;
ftnint *innum;
ftnint *innamed;
char *inname;
ftnlen innamlen;
char *inacc;
ftnlen inacclen;
char *inseq;
ftnlen inseqlen;
char *indir;
ftnlen indirlen;
char *infmt;
ftnlen infmtlen;
char *inform;
ftnint informlen;
char *inunf;
ftnlen inunflen;
ftnint *inrecl;
ftnint *innrec;
char *inblank;
ftnlen inblanklen;
} inlist;
#define VOID void
union Multitype { /* for multiple entry points */
integer1 g;
shortint h;
integer i;
/* longint j; */
real r;
doublereal d;
complex c;
doublecomplex z;
};
typedef union Multitype Multitype;
struct Vardesc { /* for Namelist */
char *name;
char *addr;
ftnlen *dims;
int type;
};
typedef struct Vardesc Vardesc;
struct Namelist {
char *name;
Vardesc **vars;
int nvars;
};
typedef struct Namelist Namelist;
#define abs(x) ((x) >= 0 ? (x) : -(x))
#define dabs(x) (fabs(x))
#define f2cmin(a,b) ((a) <= (b) ? (a) : (b))
#define f2cmax(a,b) ((a) >= (b) ? (a) : (b))
#define dmin(a,b) (f2cmin(a,b))
#define dmax(a,b) (f2cmax(a,b))
#define bit_test(a,b) ((a) >> (b) & 1)
#define bit_clear(a,b) ((a) & ~((uinteger)1 << (b)))
#define bit_set(a,b) ((a) | ((uinteger)1 << (b)))
#define abort_() { sig_die("Fortran abort routine called", 1); }
#define c_abs(z) (cabsf(Cf(z)))
#define c_cos(R,Z) { pCf(R)=ccos(Cf(Z)); }
#define c_div(c, a, b) {pCf(c) = Cf(a)/Cf(b);}
#define z_div(c, a, b) {pCd(c) = Cd(a)/Cd(b);}
#define c_exp(R, Z) {pCf(R) = cexpf(Cf(Z));}
#define c_log(R, Z) {pCf(R) = clogf(Cf(Z));}
#define c_sin(R, Z) {pCf(R) = csinf(Cf(Z));}
//#define c_sqrt(R, Z) {*(R) = csqrtf(Cf(Z));}
#define c_sqrt(R, Z) {pCf(R) = csqrtf(Cf(Z));}
#define d_abs(x) (fabs(*(x)))
#define d_acos(x) (acos(*(x)))
#define d_asin(x) (asin(*(x)))
#define d_atan(x) (atan(*(x)))
#define d_atn2(x, y) (atan2(*(x),*(y)))
#define d_cnjg(R, Z) { pCd(R) = conj(Cd(Z)); }
#define r_cnjg(R, Z) { pCf(R) = conj(Cf(Z)); }
#define d_cos(x) (cos(*(x)))
#define d_cosh(x) (cosh(*(x)))
#define d_dim(__a, __b) ( *(__a) > *(__b) ? *(__a) - *(__b) : 0.0 )
#define d_exp(x) (exp(*(x)))
#define d_imag(z) (cimag(Cd(z)))
#define r_imag(z) (cimag(Cf(z)))
#define d_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define r_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define d_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define r_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define d_log(x) (log(*(x)))
#define d_mod(x, y) (fmod(*(x), *(y)))
#define u_nint(__x) ((__x)>=0 ? floor((__x) + .5) : -floor(.5 - (__x)))
#define d_nint(x) u_nint(*(x))
#define u_sign(__a,__b) ((__b) >= 0 ? ((__a) >= 0 ? (__a) : -(__a)) : -((__a) >= 0 ? (__a) : -(__a)))
#define d_sign(a,b) u_sign(*(a),*(b))
#define r_sign(a,b) u_sign(*(a),*(b))
#define d_sin(x) (sin(*(x)))
#define d_sinh(x) (sinh(*(x)))
#define d_sqrt(x) (sqrt(*(x)))
#define d_tan(x) (tan(*(x)))
#define d_tanh(x) (tanh(*(x)))
#define i_abs(x) abs(*(x))
#define i_dnnt(x) ((integer)u_nint(*(x)))
#define i_len(s, n) (n)
#define i_nint(x) ((integer)u_nint(*(x)))
#define i_sign(a,b) ((integer)u_sign((integer)*(a),(integer)*(b)))
#define pow_dd(ap, bp) ( pow(*(ap), *(bp)))
#define pow_si(B,E) spow_ui(*(B),*(E))
#define pow_ri(B,E) spow_ui(*(B),*(E))
#define pow_di(B,E) dpow_ui(*(B),*(E))
#define pow_zi(p, a, b) {pCd(p) = zpow_ui(Cd(a), *(b));}
#define pow_ci(p, a, b) {pCf(p) = cpow_ui(Cf(a), *(b));}
#define pow_zz(R,A,B) {pCd(R) = cpow(Cd(A),*(B));}
#define s_cat(lpp, rpp, rnp, np, llp) { ftnlen i, nc, ll; char *f__rp, *lp; ll = (llp); lp = (lpp); for(i=0; i < (int)*(np); ++i) { nc = ll; if((rnp)[i] < nc) nc = (rnp)[i]; ll -= nc; f__rp = (rpp)[i]; while(--nc >= 0) *lp++ = *(f__rp)++; } while(--ll >= 0) *lp++ = ' '; }
#define s_cmp(a,b,c,d) ((integer)strncmp((a),(b),f2cmin((c),(d))))
#define s_copy(A,B,C,D) { int __i,__m; for (__i=0, __m=f2cmin((C),(D)); __i<__m && (B)[__i] != 0; ++__i) (A)[__i] = (B)[__i]; }
#define sig_die(s, kill) { exit(1); }
#define s_stop(s, n) {exit(0);}
static char junk[] = "\n@(#)LIBF77 VERSION 19990503\n";
#define z_abs(z) (cabs(Cd(z)))
#define z_exp(R, Z) {pCd(R) = cexp(Cd(Z));}
#define z_sqrt(R, Z) {pCd(R) = csqrt(Cd(Z));}
#define myexit_() break;
#define mycycle() continue;
#define myceiling(w) {ceil(w)}
#define myhuge(w) {HUGE_VAL}
//#define mymaxloc_(w,s,e,n) {if (sizeof(*(w)) == sizeof(double)) dmaxloc_((w),*(s),*(e),n); else dmaxloc_((w),*(s),*(e),n);}
#define mymaxloc(w,s,e,n) {dmaxloc_(w,*(s),*(e),n)}
/* procedure parameter types for -A and -C++ */
#define F2C_proc_par_types 1
#ifdef __cplusplus
typedef logical (*L_fp)(...);
#else
typedef logical (*L_fp)();
#endif
static float spow_ui(float x, integer n) {
float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static double dpow_ui(double x, integer n) {
double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static _Complex float cpow_ui(_Complex float x, integer n) {
_Complex float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static _Complex double zpow_ui(_Complex double x, integer n) {
_Complex double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static integer pow_ii(integer x, integer n) {
integer pow; unsigned long int u;
if (n <= 0) {
if (n == 0 || x == 1) pow = 1;
else if (x != -1) pow = x == 0 ? 1/x : 0;
else n = -n;
}
if ((n > 0) || !(n == 0 || x == 1 || x != -1)) {
u = n;
for(pow = 1; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static integer dmaxloc_(double *w, integer s, integer e, integer *n)
{
double m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static integer smaxloc_(float *w, integer s, integer e, integer *n)
{
float m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static inline void cdotc_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i])) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i*incx])) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
static inline void zdotc_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i])) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i*incx])) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
static inline void cdotu_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i]) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i*incx]) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
static inline void zdotu_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i]) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i*incx]) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
#endif
/* -- translated by f2c (version 20000121).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
/* Table of constant values */
static integer c__1 = 1;
/* > \brief \b CLARFX applies an elementary reflector to a general rectangular matrix, with loop unrolling whe
n the reflector has order ≤ 10. */
/* =========== DOCUMENTATION =========== */
/* Online html documentation available at */
/* http://www.netlib.org/lapack/explore-html/ */
/* > \htmlonly */
/* > Download CLARFX + dependencies */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/clarfx.
f"> */
/* > [TGZ]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/clarfx.
f"> */
/* > [ZIP]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/clarfx.
f"> */
/* > [TXT]</a> */
/* > \endhtmlonly */
/* Definition: */
/* =========== */
/* SUBROUTINE CLARFX( SIDE, M, N, V, TAU, C, LDC, WORK ) */
/* CHARACTER SIDE */
/* INTEGER LDC, M, N */
/* COMPLEX TAU */
/* COMPLEX C( LDC, * ), V( * ), WORK( * ) */
/* > \par Purpose: */
/* ============= */
/* > */
/* > \verbatim */
/* > */
/* > CLARFX applies a complex elementary reflector H to a complex m by n */
/* > matrix C, from either the left or the right. H is represented in the */
/* > form */
/* > */
/* > H = I - tau * v * v**H */
/* > */
/* > where tau is a complex scalar and v is a complex vector. */
/* > */
/* > If tau = 0, then H is taken to be the unit matrix */
/* > */
/* > This version uses inline code if H has order < 11. */
/* > \endverbatim */
/* Arguments: */
/* ========== */
/* > \param[in] SIDE */
/* > \verbatim */
/* > SIDE is CHARACTER*1 */
/* > = 'L': form H * C */
/* > = 'R': form C * H */
/* > \endverbatim */
/* > */
/* > \param[in] M */
/* > \verbatim */
/* > M is INTEGER */
/* > The number of rows of the matrix C. */
/* > \endverbatim */
/* > */
/* > \param[in] N */
/* > \verbatim */
/* > N is INTEGER */
/* > The number of columns of the matrix C. */
/* > \endverbatim */
/* > */
/* > \param[in] V */
/* > \verbatim */
/* > V is COMPLEX array, dimension (M) if SIDE = 'L' */
/* > or (N) if SIDE = 'R' */
/* > The vector v in the representation of H. */
/* > \endverbatim */
/* > */
/* > \param[in] TAU */
/* > \verbatim */
/* > TAU is COMPLEX */
/* > The value tau in the representation of H. */
/* > \endverbatim */
/* > */
/* > \param[in,out] C */
/* > \verbatim */
/* > C is COMPLEX array, dimension (LDC,N) */
/* > On entry, the m by n matrix C. */
/* > On exit, C is overwritten by the matrix H * C if SIDE = 'L', */
/* > or C * H if SIDE = 'R'. */
/* > \endverbatim */
/* > */
/* > \param[in] LDC */
/* > \verbatim */
/* > LDC is INTEGER */
/* > The leading dimension of the array C. LDC >= f2cmax(1,M). */
/* > \endverbatim */
/* > */
/* > \param[out] WORK */
/* > \verbatim */
/* > WORK is COMPLEX array, dimension (N) if SIDE = 'L' */
/* > or (M) if SIDE = 'R' */
/* > WORK is not referenced if H has order < 11. */
/* > \endverbatim */
/* Authors: */
/* ======== */
/* > \author Univ. of Tennessee */
/* > \author Univ. of California Berkeley */
/* > \author Univ. of Colorado Denver */
/* > \author NAG Ltd. */
/* > \date December 2016 */
/* > \ingroup complexOTHERauxiliary */
/* ===================================================================== */
/* Subroutine */ int clarfx_(char *side, integer *m, integer *n, complex *v,
complex *tau, complex *c__, integer *ldc, complex *work)
{
/* System generated locals */
integer c_dim1, c_offset, i__1, i__2, i__3, i__4, i__5, i__6, i__7, i__8,
i__9, i__10, i__11;
complex q__1, q__2, q__3, q__4, q__5, q__6, q__7, q__8, q__9, q__10,
q__11, q__12, q__13, q__14, q__15, q__16, q__17, q__18, q__19;
/* Local variables */
integer j;
extern /* Subroutine */ int clarf_(char *, integer *, integer *, complex *
, integer *, complex *, complex *, integer *, complex *);
extern logical lsame_(char *, char *);
complex t1, t2, t3, t4, t5, t6, t7, t8, t9, v1, v2, v3, v4, v5, v6, v7,
v8, v9, t10, v10, sum;
/* -- LAPACK auxiliary routine (version 3.7.0) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* December 2016 */
/* ===================================================================== */
/* Parameter adjustments */
--v;
c_dim1 = *ldc;
c_offset = 1 + c_dim1 * 1;
c__ -= c_offset;
--work;
/* Function Body */
if (tau->r == 0.f && tau->i == 0.f) {
return 0;
}
if (lsame_(side, "L")) {
/* Form H * C, where H has order m. */
switch (*m) {
case 1: goto L10;
case 2: goto L30;
case 3: goto L50;
case 4: goto L70;
case 5: goto L90;
case 6: goto L110;
case 7: goto L130;
case 8: goto L150;
case 9: goto L170;
case 10: goto L190;
}
/* Code for general M */
clarf_(side, m, n, &v[1], &c__1, tau, &c__[c_offset], ldc, &work[1]);
goto L410;
L10:
/* Special code for 1 x 1 Householder */
q__3.r = tau->r * v[1].r - tau->i * v[1].i, q__3.i = tau->r * v[1].i
+ tau->i * v[1].r;
r_cnjg(&q__4, &v[1]);
q__2.r = q__3.r * q__4.r - q__3.i * q__4.i, q__2.i = q__3.r * q__4.i
+ q__3.i * q__4.r;
q__1.r = 1.f - q__2.r, q__1.i = 0.f - q__2.i;
t1.r = q__1.r, t1.i = q__1.i;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = j * c_dim1 + 1;
i__3 = j * c_dim1 + 1;
q__1.r = t1.r * c__[i__3].r - t1.i * c__[i__3].i, q__1.i = t1.r *
c__[i__3].i + t1.i * c__[i__3].r;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L20: */
}
goto L410;
L30:
/* Special code for 2 x 2 Householder */
r_cnjg(&q__1, &v[1]);
v1.r = q__1.r, v1.i = q__1.i;
r_cnjg(&q__2, &v1);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t1.r = q__1.r, t1.i = q__1.i;
r_cnjg(&q__1, &v[2]);
v2.r = q__1.r, v2.i = q__1.i;
r_cnjg(&q__2, &v2);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t2.r = q__1.r, t2.i = q__1.i;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = j * c_dim1 + 1;
q__2.r = v1.r * c__[i__2].r - v1.i * c__[i__2].i, q__2.i = v1.r *
c__[i__2].i + v1.i * c__[i__2].r;
i__3 = j * c_dim1 + 2;
q__3.r = v2.r * c__[i__3].r - v2.i * c__[i__3].i, q__3.i = v2.r *
c__[i__3].i + v2.i * c__[i__3].r;
q__1.r = q__2.r + q__3.r, q__1.i = q__2.i + q__3.i;
sum.r = q__1.r, sum.i = q__1.i;
i__2 = j * c_dim1 + 1;
i__3 = j * c_dim1 + 1;
q__2.r = sum.r * t1.r - sum.i * t1.i, q__2.i = sum.r * t1.i +
sum.i * t1.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 2;
i__3 = j * c_dim1 + 2;
q__2.r = sum.r * t2.r - sum.i * t2.i, q__2.i = sum.r * t2.i +
sum.i * t2.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L40: */
}
goto L410;
L50:
/* Special code for 3 x 3 Householder */
r_cnjg(&q__1, &v[1]);
v1.r = q__1.r, v1.i = q__1.i;
r_cnjg(&q__2, &v1);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t1.r = q__1.r, t1.i = q__1.i;
r_cnjg(&q__1, &v[2]);
v2.r = q__1.r, v2.i = q__1.i;
r_cnjg(&q__2, &v2);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t2.r = q__1.r, t2.i = q__1.i;
r_cnjg(&q__1, &v[3]);
v3.r = q__1.r, v3.i = q__1.i;
r_cnjg(&q__2, &v3);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t3.r = q__1.r, t3.i = q__1.i;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = j * c_dim1 + 1;
q__3.r = v1.r * c__[i__2].r - v1.i * c__[i__2].i, q__3.i = v1.r *
c__[i__2].i + v1.i * c__[i__2].r;
i__3 = j * c_dim1 + 2;
q__4.r = v2.r * c__[i__3].r - v2.i * c__[i__3].i, q__4.i = v2.r *
c__[i__3].i + v2.i * c__[i__3].r;
q__2.r = q__3.r + q__4.r, q__2.i = q__3.i + q__4.i;
i__4 = j * c_dim1 + 3;
q__5.r = v3.r * c__[i__4].r - v3.i * c__[i__4].i, q__5.i = v3.r *
c__[i__4].i + v3.i * c__[i__4].r;
q__1.r = q__2.r + q__5.r, q__1.i = q__2.i + q__5.i;
sum.r = q__1.r, sum.i = q__1.i;
i__2 = j * c_dim1 + 1;
i__3 = j * c_dim1 + 1;
q__2.r = sum.r * t1.r - sum.i * t1.i, q__2.i = sum.r * t1.i +
sum.i * t1.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 2;
i__3 = j * c_dim1 + 2;
q__2.r = sum.r * t2.r - sum.i * t2.i, q__2.i = sum.r * t2.i +
sum.i * t2.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 3;
i__3 = j * c_dim1 + 3;
q__2.r = sum.r * t3.r - sum.i * t3.i, q__2.i = sum.r * t3.i +
sum.i * t3.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L60: */
}
goto L410;
L70:
/* Special code for 4 x 4 Householder */
r_cnjg(&q__1, &v[1]);
v1.r = q__1.r, v1.i = q__1.i;
r_cnjg(&q__2, &v1);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t1.r = q__1.r, t1.i = q__1.i;
r_cnjg(&q__1, &v[2]);
v2.r = q__1.r, v2.i = q__1.i;
r_cnjg(&q__2, &v2);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t2.r = q__1.r, t2.i = q__1.i;
r_cnjg(&q__1, &v[3]);
v3.r = q__1.r, v3.i = q__1.i;
r_cnjg(&q__2, &v3);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t3.r = q__1.r, t3.i = q__1.i;
r_cnjg(&q__1, &v[4]);
v4.r = q__1.r, v4.i = q__1.i;
r_cnjg(&q__2, &v4);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t4.r = q__1.r, t4.i = q__1.i;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = j * c_dim1 + 1;
q__4.r = v1.r * c__[i__2].r - v1.i * c__[i__2].i, q__4.i = v1.r *
c__[i__2].i + v1.i * c__[i__2].r;
i__3 = j * c_dim1 + 2;
q__5.r = v2.r * c__[i__3].r - v2.i * c__[i__3].i, q__5.i = v2.r *
c__[i__3].i + v2.i * c__[i__3].r;
q__3.r = q__4.r + q__5.r, q__3.i = q__4.i + q__5.i;
i__4 = j * c_dim1 + 3;
q__6.r = v3.r * c__[i__4].r - v3.i * c__[i__4].i, q__6.i = v3.r *
c__[i__4].i + v3.i * c__[i__4].r;
q__2.r = q__3.r + q__6.r, q__2.i = q__3.i + q__6.i;
i__5 = j * c_dim1 + 4;
q__7.r = v4.r * c__[i__5].r - v4.i * c__[i__5].i, q__7.i = v4.r *
c__[i__5].i + v4.i * c__[i__5].r;
q__1.r = q__2.r + q__7.r, q__1.i = q__2.i + q__7.i;
sum.r = q__1.r, sum.i = q__1.i;
i__2 = j * c_dim1 + 1;
i__3 = j * c_dim1 + 1;
q__2.r = sum.r * t1.r - sum.i * t1.i, q__2.i = sum.r * t1.i +
sum.i * t1.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 2;
i__3 = j * c_dim1 + 2;
q__2.r = sum.r * t2.r - sum.i * t2.i, q__2.i = sum.r * t2.i +
sum.i * t2.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 3;
i__3 = j * c_dim1 + 3;
q__2.r = sum.r * t3.r - sum.i * t3.i, q__2.i = sum.r * t3.i +
sum.i * t3.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 4;
i__3 = j * c_dim1 + 4;
q__2.r = sum.r * t4.r - sum.i * t4.i, q__2.i = sum.r * t4.i +
sum.i * t4.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L80: */
}
goto L410;
L90:
/* Special code for 5 x 5 Householder */
r_cnjg(&q__1, &v[1]);
v1.r = q__1.r, v1.i = q__1.i;
r_cnjg(&q__2, &v1);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t1.r = q__1.r, t1.i = q__1.i;
r_cnjg(&q__1, &v[2]);
v2.r = q__1.r, v2.i = q__1.i;
r_cnjg(&q__2, &v2);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t2.r = q__1.r, t2.i = q__1.i;
r_cnjg(&q__1, &v[3]);
v3.r = q__1.r, v3.i = q__1.i;
r_cnjg(&q__2, &v3);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t3.r = q__1.r, t3.i = q__1.i;
r_cnjg(&q__1, &v[4]);
v4.r = q__1.r, v4.i = q__1.i;
r_cnjg(&q__2, &v4);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t4.r = q__1.r, t4.i = q__1.i;
r_cnjg(&q__1, &v[5]);
v5.r = q__1.r, v5.i = q__1.i;
r_cnjg(&q__2, &v5);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t5.r = q__1.r, t5.i = q__1.i;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = j * c_dim1 + 1;
q__5.r = v1.r * c__[i__2].r - v1.i * c__[i__2].i, q__5.i = v1.r *
c__[i__2].i + v1.i * c__[i__2].r;
i__3 = j * c_dim1 + 2;
q__6.r = v2.r * c__[i__3].r - v2.i * c__[i__3].i, q__6.i = v2.r *
c__[i__3].i + v2.i * c__[i__3].r;
q__4.r = q__5.r + q__6.r, q__4.i = q__5.i + q__6.i;
i__4 = j * c_dim1 + 3;
q__7.r = v3.r * c__[i__4].r - v3.i * c__[i__4].i, q__7.i = v3.r *
c__[i__4].i + v3.i * c__[i__4].r;
q__3.r = q__4.r + q__7.r, q__3.i = q__4.i + q__7.i;
i__5 = j * c_dim1 + 4;
q__8.r = v4.r * c__[i__5].r - v4.i * c__[i__5].i, q__8.i = v4.r *
c__[i__5].i + v4.i * c__[i__5].r;
q__2.r = q__3.r + q__8.r, q__2.i = q__3.i + q__8.i;
i__6 = j * c_dim1 + 5;
q__9.r = v5.r * c__[i__6].r - v5.i * c__[i__6].i, q__9.i = v5.r *
c__[i__6].i + v5.i * c__[i__6].r;
q__1.r = q__2.r + q__9.r, q__1.i = q__2.i + q__9.i;
sum.r = q__1.r, sum.i = q__1.i;
i__2 = j * c_dim1 + 1;
i__3 = j * c_dim1 + 1;
q__2.r = sum.r * t1.r - sum.i * t1.i, q__2.i = sum.r * t1.i +
sum.i * t1.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 2;
i__3 = j * c_dim1 + 2;
q__2.r = sum.r * t2.r - sum.i * t2.i, q__2.i = sum.r * t2.i +
sum.i * t2.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 3;
i__3 = j * c_dim1 + 3;
q__2.r = sum.r * t3.r - sum.i * t3.i, q__2.i = sum.r * t3.i +
sum.i * t3.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 4;
i__3 = j * c_dim1 + 4;
q__2.r = sum.r * t4.r - sum.i * t4.i, q__2.i = sum.r * t4.i +
sum.i * t4.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 5;
i__3 = j * c_dim1 + 5;
q__2.r = sum.r * t5.r - sum.i * t5.i, q__2.i = sum.r * t5.i +
sum.i * t5.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L100: */
}
goto L410;
L110:
/* Special code for 6 x 6 Householder */
r_cnjg(&q__1, &v[1]);
v1.r = q__1.r, v1.i = q__1.i;
r_cnjg(&q__2, &v1);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t1.r = q__1.r, t1.i = q__1.i;
r_cnjg(&q__1, &v[2]);
v2.r = q__1.r, v2.i = q__1.i;
r_cnjg(&q__2, &v2);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t2.r = q__1.r, t2.i = q__1.i;
r_cnjg(&q__1, &v[3]);
v3.r = q__1.r, v3.i = q__1.i;
r_cnjg(&q__2, &v3);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t3.r = q__1.r, t3.i = q__1.i;
r_cnjg(&q__1, &v[4]);
v4.r = q__1.r, v4.i = q__1.i;
r_cnjg(&q__2, &v4);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t4.r = q__1.r, t4.i = q__1.i;
r_cnjg(&q__1, &v[5]);
v5.r = q__1.r, v5.i = q__1.i;
r_cnjg(&q__2, &v5);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t5.r = q__1.r, t5.i = q__1.i;
r_cnjg(&q__1, &v[6]);
v6.r = q__1.r, v6.i = q__1.i;
r_cnjg(&q__2, &v6);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t6.r = q__1.r, t6.i = q__1.i;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = j * c_dim1 + 1;
q__6.r = v1.r * c__[i__2].r - v1.i * c__[i__2].i, q__6.i = v1.r *
c__[i__2].i + v1.i * c__[i__2].r;
i__3 = j * c_dim1 + 2;
q__7.r = v2.r * c__[i__3].r - v2.i * c__[i__3].i, q__7.i = v2.r *
c__[i__3].i + v2.i * c__[i__3].r;
q__5.r = q__6.r + q__7.r, q__5.i = q__6.i + q__7.i;
i__4 = j * c_dim1 + 3;
q__8.r = v3.r * c__[i__4].r - v3.i * c__[i__4].i, q__8.i = v3.r *
c__[i__4].i + v3.i * c__[i__4].r;
q__4.r = q__5.r + q__8.r, q__4.i = q__5.i + q__8.i;
i__5 = j * c_dim1 + 4;
q__9.r = v4.r * c__[i__5].r - v4.i * c__[i__5].i, q__9.i = v4.r *
c__[i__5].i + v4.i * c__[i__5].r;
q__3.r = q__4.r + q__9.r, q__3.i = q__4.i + q__9.i;
i__6 = j * c_dim1 + 5;
q__10.r = v5.r * c__[i__6].r - v5.i * c__[i__6].i, q__10.i = v5.r
* c__[i__6].i + v5.i * c__[i__6].r;
q__2.r = q__3.r + q__10.r, q__2.i = q__3.i + q__10.i;
i__7 = j * c_dim1 + 6;
q__11.r = v6.r * c__[i__7].r - v6.i * c__[i__7].i, q__11.i = v6.r
* c__[i__7].i + v6.i * c__[i__7].r;
q__1.r = q__2.r + q__11.r, q__1.i = q__2.i + q__11.i;
sum.r = q__1.r, sum.i = q__1.i;
i__2 = j * c_dim1 + 1;
i__3 = j * c_dim1 + 1;
q__2.r = sum.r * t1.r - sum.i * t1.i, q__2.i = sum.r * t1.i +
sum.i * t1.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 2;
i__3 = j * c_dim1 + 2;
q__2.r = sum.r * t2.r - sum.i * t2.i, q__2.i = sum.r * t2.i +
sum.i * t2.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 3;
i__3 = j * c_dim1 + 3;
q__2.r = sum.r * t3.r - sum.i * t3.i, q__2.i = sum.r * t3.i +
sum.i * t3.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 4;
i__3 = j * c_dim1 + 4;
q__2.r = sum.r * t4.r - sum.i * t4.i, q__2.i = sum.r * t4.i +
sum.i * t4.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 5;
i__3 = j * c_dim1 + 5;
q__2.r = sum.r * t5.r - sum.i * t5.i, q__2.i = sum.r * t5.i +
sum.i * t5.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 6;
i__3 = j * c_dim1 + 6;
q__2.r = sum.r * t6.r - sum.i * t6.i, q__2.i = sum.r * t6.i +
sum.i * t6.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L120: */
}
goto L410;
L130:
/* Special code for 7 x 7 Householder */
r_cnjg(&q__1, &v[1]);
v1.r = q__1.r, v1.i = q__1.i;
r_cnjg(&q__2, &v1);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t1.r = q__1.r, t1.i = q__1.i;
r_cnjg(&q__1, &v[2]);
v2.r = q__1.r, v2.i = q__1.i;
r_cnjg(&q__2, &v2);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t2.r = q__1.r, t2.i = q__1.i;
r_cnjg(&q__1, &v[3]);
v3.r = q__1.r, v3.i = q__1.i;
r_cnjg(&q__2, &v3);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t3.r = q__1.r, t3.i = q__1.i;
r_cnjg(&q__1, &v[4]);
v4.r = q__1.r, v4.i = q__1.i;
r_cnjg(&q__2, &v4);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t4.r = q__1.r, t4.i = q__1.i;
r_cnjg(&q__1, &v[5]);
v5.r = q__1.r, v5.i = q__1.i;
r_cnjg(&q__2, &v5);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t5.r = q__1.r, t5.i = q__1.i;
r_cnjg(&q__1, &v[6]);
v6.r = q__1.r, v6.i = q__1.i;
r_cnjg(&q__2, &v6);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t6.r = q__1.r, t6.i = q__1.i;
r_cnjg(&q__1, &v[7]);
v7.r = q__1.r, v7.i = q__1.i;
r_cnjg(&q__2, &v7);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t7.r = q__1.r, t7.i = q__1.i;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = j * c_dim1 + 1;
q__7.r = v1.r * c__[i__2].r - v1.i * c__[i__2].i, q__7.i = v1.r *
c__[i__2].i + v1.i * c__[i__2].r;
i__3 = j * c_dim1 + 2;
q__8.r = v2.r * c__[i__3].r - v2.i * c__[i__3].i, q__8.i = v2.r *
c__[i__3].i + v2.i * c__[i__3].r;
q__6.r = q__7.r + q__8.r, q__6.i = q__7.i + q__8.i;
i__4 = j * c_dim1 + 3;
q__9.r = v3.r * c__[i__4].r - v3.i * c__[i__4].i, q__9.i = v3.r *
c__[i__4].i + v3.i * c__[i__4].r;
q__5.r = q__6.r + q__9.r, q__5.i = q__6.i + q__9.i;
i__5 = j * c_dim1 + 4;
q__10.r = v4.r * c__[i__5].r - v4.i * c__[i__5].i, q__10.i = v4.r
* c__[i__5].i + v4.i * c__[i__5].r;
q__4.r = q__5.r + q__10.r, q__4.i = q__5.i + q__10.i;
i__6 = j * c_dim1 + 5;
q__11.r = v5.r * c__[i__6].r - v5.i * c__[i__6].i, q__11.i = v5.r
* c__[i__6].i + v5.i * c__[i__6].r;
q__3.r = q__4.r + q__11.r, q__3.i = q__4.i + q__11.i;
i__7 = j * c_dim1 + 6;
q__12.r = v6.r * c__[i__7].r - v6.i * c__[i__7].i, q__12.i = v6.r
* c__[i__7].i + v6.i * c__[i__7].r;
q__2.r = q__3.r + q__12.r, q__2.i = q__3.i + q__12.i;
i__8 = j * c_dim1 + 7;
q__13.r = v7.r * c__[i__8].r - v7.i * c__[i__8].i, q__13.i = v7.r
* c__[i__8].i + v7.i * c__[i__8].r;
q__1.r = q__2.r + q__13.r, q__1.i = q__2.i + q__13.i;
sum.r = q__1.r, sum.i = q__1.i;
i__2 = j * c_dim1 + 1;
i__3 = j * c_dim1 + 1;
q__2.r = sum.r * t1.r - sum.i * t1.i, q__2.i = sum.r * t1.i +
sum.i * t1.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 2;
i__3 = j * c_dim1 + 2;
q__2.r = sum.r * t2.r - sum.i * t2.i, q__2.i = sum.r * t2.i +
sum.i * t2.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 3;
i__3 = j * c_dim1 + 3;
q__2.r = sum.r * t3.r - sum.i * t3.i, q__2.i = sum.r * t3.i +
sum.i * t3.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 4;
i__3 = j * c_dim1 + 4;
q__2.r = sum.r * t4.r - sum.i * t4.i, q__2.i = sum.r * t4.i +
sum.i * t4.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 5;
i__3 = j * c_dim1 + 5;
q__2.r = sum.r * t5.r - sum.i * t5.i, q__2.i = sum.r * t5.i +
sum.i * t5.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 6;
i__3 = j * c_dim1 + 6;
q__2.r = sum.r * t6.r - sum.i * t6.i, q__2.i = sum.r * t6.i +
sum.i * t6.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 7;
i__3 = j * c_dim1 + 7;
q__2.r = sum.r * t7.r - sum.i * t7.i, q__2.i = sum.r * t7.i +
sum.i * t7.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L140: */
}
goto L410;
L150:
/* Special code for 8 x 8 Householder */
r_cnjg(&q__1, &v[1]);
v1.r = q__1.r, v1.i = q__1.i;
r_cnjg(&q__2, &v1);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t1.r = q__1.r, t1.i = q__1.i;
r_cnjg(&q__1, &v[2]);
v2.r = q__1.r, v2.i = q__1.i;
r_cnjg(&q__2, &v2);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t2.r = q__1.r, t2.i = q__1.i;
r_cnjg(&q__1, &v[3]);
v3.r = q__1.r, v3.i = q__1.i;
r_cnjg(&q__2, &v3);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t3.r = q__1.r, t3.i = q__1.i;
r_cnjg(&q__1, &v[4]);
v4.r = q__1.r, v4.i = q__1.i;
r_cnjg(&q__2, &v4);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t4.r = q__1.r, t4.i = q__1.i;
r_cnjg(&q__1, &v[5]);
v5.r = q__1.r, v5.i = q__1.i;
r_cnjg(&q__2, &v5);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t5.r = q__1.r, t5.i = q__1.i;
r_cnjg(&q__1, &v[6]);
v6.r = q__1.r, v6.i = q__1.i;
r_cnjg(&q__2, &v6);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t6.r = q__1.r, t6.i = q__1.i;
r_cnjg(&q__1, &v[7]);
v7.r = q__1.r, v7.i = q__1.i;
r_cnjg(&q__2, &v7);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t7.r = q__1.r, t7.i = q__1.i;
r_cnjg(&q__1, &v[8]);
v8.r = q__1.r, v8.i = q__1.i;
r_cnjg(&q__2, &v8);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t8.r = q__1.r, t8.i = q__1.i;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = j * c_dim1 + 1;
q__8.r = v1.r * c__[i__2].r - v1.i * c__[i__2].i, q__8.i = v1.r *
c__[i__2].i + v1.i * c__[i__2].r;
i__3 = j * c_dim1 + 2;
q__9.r = v2.r * c__[i__3].r - v2.i * c__[i__3].i, q__9.i = v2.r *
c__[i__3].i + v2.i * c__[i__3].r;
q__7.r = q__8.r + q__9.r, q__7.i = q__8.i + q__9.i;
i__4 = j * c_dim1 + 3;
q__10.r = v3.r * c__[i__4].r - v3.i * c__[i__4].i, q__10.i = v3.r
* c__[i__4].i + v3.i * c__[i__4].r;
q__6.r = q__7.r + q__10.r, q__6.i = q__7.i + q__10.i;
i__5 = j * c_dim1 + 4;
q__11.r = v4.r * c__[i__5].r - v4.i * c__[i__5].i, q__11.i = v4.r
* c__[i__5].i + v4.i * c__[i__5].r;
q__5.r = q__6.r + q__11.r, q__5.i = q__6.i + q__11.i;
i__6 = j * c_dim1 + 5;
q__12.r = v5.r * c__[i__6].r - v5.i * c__[i__6].i, q__12.i = v5.r
* c__[i__6].i + v5.i * c__[i__6].r;
q__4.r = q__5.r + q__12.r, q__4.i = q__5.i + q__12.i;
i__7 = j * c_dim1 + 6;
q__13.r = v6.r * c__[i__7].r - v6.i * c__[i__7].i, q__13.i = v6.r
* c__[i__7].i + v6.i * c__[i__7].r;
q__3.r = q__4.r + q__13.r, q__3.i = q__4.i + q__13.i;
i__8 = j * c_dim1 + 7;
q__14.r = v7.r * c__[i__8].r - v7.i * c__[i__8].i, q__14.i = v7.r
* c__[i__8].i + v7.i * c__[i__8].r;
q__2.r = q__3.r + q__14.r, q__2.i = q__3.i + q__14.i;
i__9 = j * c_dim1 + 8;
q__15.r = v8.r * c__[i__9].r - v8.i * c__[i__9].i, q__15.i = v8.r
* c__[i__9].i + v8.i * c__[i__9].r;
q__1.r = q__2.r + q__15.r, q__1.i = q__2.i + q__15.i;
sum.r = q__1.r, sum.i = q__1.i;
i__2 = j * c_dim1 + 1;
i__3 = j * c_dim1 + 1;
q__2.r = sum.r * t1.r - sum.i * t1.i, q__2.i = sum.r * t1.i +
sum.i * t1.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 2;
i__3 = j * c_dim1 + 2;
q__2.r = sum.r * t2.r - sum.i * t2.i, q__2.i = sum.r * t2.i +
sum.i * t2.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 3;
i__3 = j * c_dim1 + 3;
q__2.r = sum.r * t3.r - sum.i * t3.i, q__2.i = sum.r * t3.i +
sum.i * t3.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 4;
i__3 = j * c_dim1 + 4;
q__2.r = sum.r * t4.r - sum.i * t4.i, q__2.i = sum.r * t4.i +
sum.i * t4.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 5;
i__3 = j * c_dim1 + 5;
q__2.r = sum.r * t5.r - sum.i * t5.i, q__2.i = sum.r * t5.i +
sum.i * t5.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 6;
i__3 = j * c_dim1 + 6;
q__2.r = sum.r * t6.r - sum.i * t6.i, q__2.i = sum.r * t6.i +
sum.i * t6.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 7;
i__3 = j * c_dim1 + 7;
q__2.r = sum.r * t7.r - sum.i * t7.i, q__2.i = sum.r * t7.i +
sum.i * t7.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 8;
i__3 = j * c_dim1 + 8;
q__2.r = sum.r * t8.r - sum.i * t8.i, q__2.i = sum.r * t8.i +
sum.i * t8.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L160: */
}
goto L410;
L170:
/* Special code for 9 x 9 Householder */
r_cnjg(&q__1, &v[1]);
v1.r = q__1.r, v1.i = q__1.i;
r_cnjg(&q__2, &v1);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t1.r = q__1.r, t1.i = q__1.i;
r_cnjg(&q__1, &v[2]);
v2.r = q__1.r, v2.i = q__1.i;
r_cnjg(&q__2, &v2);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t2.r = q__1.r, t2.i = q__1.i;
r_cnjg(&q__1, &v[3]);
v3.r = q__1.r, v3.i = q__1.i;
r_cnjg(&q__2, &v3);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t3.r = q__1.r, t3.i = q__1.i;
r_cnjg(&q__1, &v[4]);
v4.r = q__1.r, v4.i = q__1.i;
r_cnjg(&q__2, &v4);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t4.r = q__1.r, t4.i = q__1.i;
r_cnjg(&q__1, &v[5]);
v5.r = q__1.r, v5.i = q__1.i;
r_cnjg(&q__2, &v5);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t5.r = q__1.r, t5.i = q__1.i;
r_cnjg(&q__1, &v[6]);
v6.r = q__1.r, v6.i = q__1.i;
r_cnjg(&q__2, &v6);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t6.r = q__1.r, t6.i = q__1.i;
r_cnjg(&q__1, &v[7]);
v7.r = q__1.r, v7.i = q__1.i;
r_cnjg(&q__2, &v7);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t7.r = q__1.r, t7.i = q__1.i;
r_cnjg(&q__1, &v[8]);
v8.r = q__1.r, v8.i = q__1.i;
r_cnjg(&q__2, &v8);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t8.r = q__1.r, t8.i = q__1.i;
r_cnjg(&q__1, &v[9]);
v9.r = q__1.r, v9.i = q__1.i;
r_cnjg(&q__2, &v9);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t9.r = q__1.r, t9.i = q__1.i;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = j * c_dim1 + 1;
q__9.r = v1.r * c__[i__2].r - v1.i * c__[i__2].i, q__9.i = v1.r *
c__[i__2].i + v1.i * c__[i__2].r;
i__3 = j * c_dim1 + 2;
q__10.r = v2.r * c__[i__3].r - v2.i * c__[i__3].i, q__10.i = v2.r
* c__[i__3].i + v2.i * c__[i__3].r;
q__8.r = q__9.r + q__10.r, q__8.i = q__9.i + q__10.i;
i__4 = j * c_dim1 + 3;
q__11.r = v3.r * c__[i__4].r - v3.i * c__[i__4].i, q__11.i = v3.r
* c__[i__4].i + v3.i * c__[i__4].r;
q__7.r = q__8.r + q__11.r, q__7.i = q__8.i + q__11.i;
i__5 = j * c_dim1 + 4;
q__12.r = v4.r * c__[i__5].r - v4.i * c__[i__5].i, q__12.i = v4.r
* c__[i__5].i + v4.i * c__[i__5].r;
q__6.r = q__7.r + q__12.r, q__6.i = q__7.i + q__12.i;
i__6 = j * c_dim1 + 5;
q__13.r = v5.r * c__[i__6].r - v5.i * c__[i__6].i, q__13.i = v5.r
* c__[i__6].i + v5.i * c__[i__6].r;
q__5.r = q__6.r + q__13.r, q__5.i = q__6.i + q__13.i;
i__7 = j * c_dim1 + 6;
q__14.r = v6.r * c__[i__7].r - v6.i * c__[i__7].i, q__14.i = v6.r
* c__[i__7].i + v6.i * c__[i__7].r;
q__4.r = q__5.r + q__14.r, q__4.i = q__5.i + q__14.i;
i__8 = j * c_dim1 + 7;
q__15.r = v7.r * c__[i__8].r - v7.i * c__[i__8].i, q__15.i = v7.r
* c__[i__8].i + v7.i * c__[i__8].r;
q__3.r = q__4.r + q__15.r, q__3.i = q__4.i + q__15.i;
i__9 = j * c_dim1 + 8;
q__16.r = v8.r * c__[i__9].r - v8.i * c__[i__9].i, q__16.i = v8.r
* c__[i__9].i + v8.i * c__[i__9].r;
q__2.r = q__3.r + q__16.r, q__2.i = q__3.i + q__16.i;
i__10 = j * c_dim1 + 9;
q__17.r = v9.r * c__[i__10].r - v9.i * c__[i__10].i, q__17.i =
v9.r * c__[i__10].i + v9.i * c__[i__10].r;
q__1.r = q__2.r + q__17.r, q__1.i = q__2.i + q__17.i;
sum.r = q__1.r, sum.i = q__1.i;
i__2 = j * c_dim1 + 1;
i__3 = j * c_dim1 + 1;
q__2.r = sum.r * t1.r - sum.i * t1.i, q__2.i = sum.r * t1.i +
sum.i * t1.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 2;
i__3 = j * c_dim1 + 2;
q__2.r = sum.r * t2.r - sum.i * t2.i, q__2.i = sum.r * t2.i +
sum.i * t2.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 3;
i__3 = j * c_dim1 + 3;
q__2.r = sum.r * t3.r - sum.i * t3.i, q__2.i = sum.r * t3.i +
sum.i * t3.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 4;
i__3 = j * c_dim1 + 4;
q__2.r = sum.r * t4.r - sum.i * t4.i, q__2.i = sum.r * t4.i +
sum.i * t4.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 5;
i__3 = j * c_dim1 + 5;
q__2.r = sum.r * t5.r - sum.i * t5.i, q__2.i = sum.r * t5.i +
sum.i * t5.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 6;
i__3 = j * c_dim1 + 6;
q__2.r = sum.r * t6.r - sum.i * t6.i, q__2.i = sum.r * t6.i +
sum.i * t6.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 7;
i__3 = j * c_dim1 + 7;
q__2.r = sum.r * t7.r - sum.i * t7.i, q__2.i = sum.r * t7.i +
sum.i * t7.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 8;
i__3 = j * c_dim1 + 8;
q__2.r = sum.r * t8.r - sum.i * t8.i, q__2.i = sum.r * t8.i +
sum.i * t8.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 9;
i__3 = j * c_dim1 + 9;
q__2.r = sum.r * t9.r - sum.i * t9.i, q__2.i = sum.r * t9.i +
sum.i * t9.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L180: */
}
goto L410;
L190:
/* Special code for 10 x 10 Householder */
r_cnjg(&q__1, &v[1]);
v1.r = q__1.r, v1.i = q__1.i;
r_cnjg(&q__2, &v1);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t1.r = q__1.r, t1.i = q__1.i;
r_cnjg(&q__1, &v[2]);
v2.r = q__1.r, v2.i = q__1.i;
r_cnjg(&q__2, &v2);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t2.r = q__1.r, t2.i = q__1.i;
r_cnjg(&q__1, &v[3]);
v3.r = q__1.r, v3.i = q__1.i;
r_cnjg(&q__2, &v3);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t3.r = q__1.r, t3.i = q__1.i;
r_cnjg(&q__1, &v[4]);
v4.r = q__1.r, v4.i = q__1.i;
r_cnjg(&q__2, &v4);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t4.r = q__1.r, t4.i = q__1.i;
r_cnjg(&q__1, &v[5]);
v5.r = q__1.r, v5.i = q__1.i;
r_cnjg(&q__2, &v5);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t5.r = q__1.r, t5.i = q__1.i;
r_cnjg(&q__1, &v[6]);
v6.r = q__1.r, v6.i = q__1.i;
r_cnjg(&q__2, &v6);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t6.r = q__1.r, t6.i = q__1.i;
r_cnjg(&q__1, &v[7]);
v7.r = q__1.r, v7.i = q__1.i;
r_cnjg(&q__2, &v7);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t7.r = q__1.r, t7.i = q__1.i;
r_cnjg(&q__1, &v[8]);
v8.r = q__1.r, v8.i = q__1.i;
r_cnjg(&q__2, &v8);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t8.r = q__1.r, t8.i = q__1.i;
r_cnjg(&q__1, &v[9]);
v9.r = q__1.r, v9.i = q__1.i;
r_cnjg(&q__2, &v9);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t9.r = q__1.r, t9.i = q__1.i;
r_cnjg(&q__1, &v[10]);
v10.r = q__1.r, v10.i = q__1.i;
r_cnjg(&q__2, &v10);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t10.r = q__1.r, t10.i = q__1.i;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = j * c_dim1 + 1;
q__10.r = v1.r * c__[i__2].r - v1.i * c__[i__2].i, q__10.i = v1.r
* c__[i__2].i + v1.i * c__[i__2].r;
i__3 = j * c_dim1 + 2;
q__11.r = v2.r * c__[i__3].r - v2.i * c__[i__3].i, q__11.i = v2.r
* c__[i__3].i + v2.i * c__[i__3].r;
q__9.r = q__10.r + q__11.r, q__9.i = q__10.i + q__11.i;
i__4 = j * c_dim1 + 3;
q__12.r = v3.r * c__[i__4].r - v3.i * c__[i__4].i, q__12.i = v3.r
* c__[i__4].i + v3.i * c__[i__4].r;
q__8.r = q__9.r + q__12.r, q__8.i = q__9.i + q__12.i;
i__5 = j * c_dim1 + 4;
q__13.r = v4.r * c__[i__5].r - v4.i * c__[i__5].i, q__13.i = v4.r
* c__[i__5].i + v4.i * c__[i__5].r;
q__7.r = q__8.r + q__13.r, q__7.i = q__8.i + q__13.i;
i__6 = j * c_dim1 + 5;
q__14.r = v5.r * c__[i__6].r - v5.i * c__[i__6].i, q__14.i = v5.r
* c__[i__6].i + v5.i * c__[i__6].r;
q__6.r = q__7.r + q__14.r, q__6.i = q__7.i + q__14.i;
i__7 = j * c_dim1 + 6;
q__15.r = v6.r * c__[i__7].r - v6.i * c__[i__7].i, q__15.i = v6.r
* c__[i__7].i + v6.i * c__[i__7].r;
q__5.r = q__6.r + q__15.r, q__5.i = q__6.i + q__15.i;
i__8 = j * c_dim1 + 7;
q__16.r = v7.r * c__[i__8].r - v7.i * c__[i__8].i, q__16.i = v7.r
* c__[i__8].i + v7.i * c__[i__8].r;
q__4.r = q__5.r + q__16.r, q__4.i = q__5.i + q__16.i;
i__9 = j * c_dim1 + 8;
q__17.r = v8.r * c__[i__9].r - v8.i * c__[i__9].i, q__17.i = v8.r
* c__[i__9].i + v8.i * c__[i__9].r;
q__3.r = q__4.r + q__17.r, q__3.i = q__4.i + q__17.i;
i__10 = j * c_dim1 + 9;
q__18.r = v9.r * c__[i__10].r - v9.i * c__[i__10].i, q__18.i =
v9.r * c__[i__10].i + v9.i * c__[i__10].r;
q__2.r = q__3.r + q__18.r, q__2.i = q__3.i + q__18.i;
i__11 = j * c_dim1 + 10;
q__19.r = v10.r * c__[i__11].r - v10.i * c__[i__11].i, q__19.i =
v10.r * c__[i__11].i + v10.i * c__[i__11].r;
q__1.r = q__2.r + q__19.r, q__1.i = q__2.i + q__19.i;
sum.r = q__1.r, sum.i = q__1.i;
i__2 = j * c_dim1 + 1;
i__3 = j * c_dim1 + 1;
q__2.r = sum.r * t1.r - sum.i * t1.i, q__2.i = sum.r * t1.i +
sum.i * t1.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 2;
i__3 = j * c_dim1 + 2;
q__2.r = sum.r * t2.r - sum.i * t2.i, q__2.i = sum.r * t2.i +
sum.i * t2.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 3;
i__3 = j * c_dim1 + 3;
q__2.r = sum.r * t3.r - sum.i * t3.i, q__2.i = sum.r * t3.i +
sum.i * t3.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 4;
i__3 = j * c_dim1 + 4;
q__2.r = sum.r * t4.r - sum.i * t4.i, q__2.i = sum.r * t4.i +
sum.i * t4.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 5;
i__3 = j * c_dim1 + 5;
q__2.r = sum.r * t5.r - sum.i * t5.i, q__2.i = sum.r * t5.i +
sum.i * t5.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 6;
i__3 = j * c_dim1 + 6;
q__2.r = sum.r * t6.r - sum.i * t6.i, q__2.i = sum.r * t6.i +
sum.i * t6.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 7;
i__3 = j * c_dim1 + 7;
q__2.r = sum.r * t7.r - sum.i * t7.i, q__2.i = sum.r * t7.i +
sum.i * t7.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 8;
i__3 = j * c_dim1 + 8;
q__2.r = sum.r * t8.r - sum.i * t8.i, q__2.i = sum.r * t8.i +
sum.i * t8.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 9;
i__3 = j * c_dim1 + 9;
q__2.r = sum.r * t9.r - sum.i * t9.i, q__2.i = sum.r * t9.i +
sum.i * t9.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j * c_dim1 + 10;
i__3 = j * c_dim1 + 10;
q__2.r = sum.r * t10.r - sum.i * t10.i, q__2.i = sum.r * t10.i +
sum.i * t10.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L200: */
}
goto L410;
} else {
/* Form C * H, where H has order n. */
switch (*n) {
case 1: goto L210;
case 2: goto L230;
case 3: goto L250;
case 4: goto L270;
case 5: goto L290;
case 6: goto L310;
case 7: goto L330;
case 8: goto L350;
case 9: goto L370;
case 10: goto L390;
}
/* Code for general N */
clarf_(side, m, n, &v[1], &c__1, tau, &c__[c_offset], ldc, &work[1]);
goto L410;
L210:
/* Special code for 1 x 1 Householder */
q__3.r = tau->r * v[1].r - tau->i * v[1].i, q__3.i = tau->r * v[1].i
+ tau->i * v[1].r;
r_cnjg(&q__4, &v[1]);
q__2.r = q__3.r * q__4.r - q__3.i * q__4.i, q__2.i = q__3.r * q__4.i
+ q__3.i * q__4.r;
q__1.r = 1.f - q__2.r, q__1.i = 0.f - q__2.i;
t1.r = q__1.r, t1.i = q__1.i;
i__1 = *m;
for (j = 1; j <= i__1; ++j) {
i__2 = j + c_dim1;
i__3 = j + c_dim1;
q__1.r = t1.r * c__[i__3].r - t1.i * c__[i__3].i, q__1.i = t1.r *
c__[i__3].i + t1.i * c__[i__3].r;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L220: */
}
goto L410;
L230:
/* Special code for 2 x 2 Householder */
v1.r = v[1].r, v1.i = v[1].i;
r_cnjg(&q__2, &v1);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t1.r = q__1.r, t1.i = q__1.i;
v2.r = v[2].r, v2.i = v[2].i;
r_cnjg(&q__2, &v2);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t2.r = q__1.r, t2.i = q__1.i;
i__1 = *m;
for (j = 1; j <= i__1; ++j) {
i__2 = j + c_dim1;
q__2.r = v1.r * c__[i__2].r - v1.i * c__[i__2].i, q__2.i = v1.r *
c__[i__2].i + v1.i * c__[i__2].r;
i__3 = j + (c_dim1 << 1);
q__3.r = v2.r * c__[i__3].r - v2.i * c__[i__3].i, q__3.i = v2.r *
c__[i__3].i + v2.i * c__[i__3].r;
q__1.r = q__2.r + q__3.r, q__1.i = q__2.i + q__3.i;
sum.r = q__1.r, sum.i = q__1.i;
i__2 = j + c_dim1;
i__3 = j + c_dim1;
q__2.r = sum.r * t1.r - sum.i * t1.i, q__2.i = sum.r * t1.i +
sum.i * t1.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + (c_dim1 << 1);
i__3 = j + (c_dim1 << 1);
q__2.r = sum.r * t2.r - sum.i * t2.i, q__2.i = sum.r * t2.i +
sum.i * t2.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L240: */
}
goto L410;
L250:
/* Special code for 3 x 3 Householder */
v1.r = v[1].r, v1.i = v[1].i;
r_cnjg(&q__2, &v1);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t1.r = q__1.r, t1.i = q__1.i;
v2.r = v[2].r, v2.i = v[2].i;
r_cnjg(&q__2, &v2);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t2.r = q__1.r, t2.i = q__1.i;
v3.r = v[3].r, v3.i = v[3].i;
r_cnjg(&q__2, &v3);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t3.r = q__1.r, t3.i = q__1.i;
i__1 = *m;
for (j = 1; j <= i__1; ++j) {
i__2 = j + c_dim1;
q__3.r = v1.r * c__[i__2].r - v1.i * c__[i__2].i, q__3.i = v1.r *
c__[i__2].i + v1.i * c__[i__2].r;
i__3 = j + (c_dim1 << 1);
q__4.r = v2.r * c__[i__3].r - v2.i * c__[i__3].i, q__4.i = v2.r *
c__[i__3].i + v2.i * c__[i__3].r;
q__2.r = q__3.r + q__4.r, q__2.i = q__3.i + q__4.i;
i__4 = j + c_dim1 * 3;
q__5.r = v3.r * c__[i__4].r - v3.i * c__[i__4].i, q__5.i = v3.r *
c__[i__4].i + v3.i * c__[i__4].r;
q__1.r = q__2.r + q__5.r, q__1.i = q__2.i + q__5.i;
sum.r = q__1.r, sum.i = q__1.i;
i__2 = j + c_dim1;
i__3 = j + c_dim1;
q__2.r = sum.r * t1.r - sum.i * t1.i, q__2.i = sum.r * t1.i +
sum.i * t1.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + (c_dim1 << 1);
i__3 = j + (c_dim1 << 1);
q__2.r = sum.r * t2.r - sum.i * t2.i, q__2.i = sum.r * t2.i +
sum.i * t2.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 3;
i__3 = j + c_dim1 * 3;
q__2.r = sum.r * t3.r - sum.i * t3.i, q__2.i = sum.r * t3.i +
sum.i * t3.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L260: */
}
goto L410;
L270:
/* Special code for 4 x 4 Householder */
v1.r = v[1].r, v1.i = v[1].i;
r_cnjg(&q__2, &v1);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t1.r = q__1.r, t1.i = q__1.i;
v2.r = v[2].r, v2.i = v[2].i;
r_cnjg(&q__2, &v2);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t2.r = q__1.r, t2.i = q__1.i;
v3.r = v[3].r, v3.i = v[3].i;
r_cnjg(&q__2, &v3);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t3.r = q__1.r, t3.i = q__1.i;
v4.r = v[4].r, v4.i = v[4].i;
r_cnjg(&q__2, &v4);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t4.r = q__1.r, t4.i = q__1.i;
i__1 = *m;
for (j = 1; j <= i__1; ++j) {
i__2 = j + c_dim1;
q__4.r = v1.r * c__[i__2].r - v1.i * c__[i__2].i, q__4.i = v1.r *
c__[i__2].i + v1.i * c__[i__2].r;
i__3 = j + (c_dim1 << 1);
q__5.r = v2.r * c__[i__3].r - v2.i * c__[i__3].i, q__5.i = v2.r *
c__[i__3].i + v2.i * c__[i__3].r;
q__3.r = q__4.r + q__5.r, q__3.i = q__4.i + q__5.i;
i__4 = j + c_dim1 * 3;
q__6.r = v3.r * c__[i__4].r - v3.i * c__[i__4].i, q__6.i = v3.r *
c__[i__4].i + v3.i * c__[i__4].r;
q__2.r = q__3.r + q__6.r, q__2.i = q__3.i + q__6.i;
i__5 = j + (c_dim1 << 2);
q__7.r = v4.r * c__[i__5].r - v4.i * c__[i__5].i, q__7.i = v4.r *
c__[i__5].i + v4.i * c__[i__5].r;
q__1.r = q__2.r + q__7.r, q__1.i = q__2.i + q__7.i;
sum.r = q__1.r, sum.i = q__1.i;
i__2 = j + c_dim1;
i__3 = j + c_dim1;
q__2.r = sum.r * t1.r - sum.i * t1.i, q__2.i = sum.r * t1.i +
sum.i * t1.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + (c_dim1 << 1);
i__3 = j + (c_dim1 << 1);
q__2.r = sum.r * t2.r - sum.i * t2.i, q__2.i = sum.r * t2.i +
sum.i * t2.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 3;
i__3 = j + c_dim1 * 3;
q__2.r = sum.r * t3.r - sum.i * t3.i, q__2.i = sum.r * t3.i +
sum.i * t3.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + (c_dim1 << 2);
i__3 = j + (c_dim1 << 2);
q__2.r = sum.r * t4.r - sum.i * t4.i, q__2.i = sum.r * t4.i +
sum.i * t4.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L280: */
}
goto L410;
L290:
/* Special code for 5 x 5 Householder */
v1.r = v[1].r, v1.i = v[1].i;
r_cnjg(&q__2, &v1);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t1.r = q__1.r, t1.i = q__1.i;
v2.r = v[2].r, v2.i = v[2].i;
r_cnjg(&q__2, &v2);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t2.r = q__1.r, t2.i = q__1.i;
v3.r = v[3].r, v3.i = v[3].i;
r_cnjg(&q__2, &v3);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t3.r = q__1.r, t3.i = q__1.i;
v4.r = v[4].r, v4.i = v[4].i;
r_cnjg(&q__2, &v4);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t4.r = q__1.r, t4.i = q__1.i;
v5.r = v[5].r, v5.i = v[5].i;
r_cnjg(&q__2, &v5);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t5.r = q__1.r, t5.i = q__1.i;
i__1 = *m;
for (j = 1; j <= i__1; ++j) {
i__2 = j + c_dim1;
q__5.r = v1.r * c__[i__2].r - v1.i * c__[i__2].i, q__5.i = v1.r *
c__[i__2].i + v1.i * c__[i__2].r;
i__3 = j + (c_dim1 << 1);
q__6.r = v2.r * c__[i__3].r - v2.i * c__[i__3].i, q__6.i = v2.r *
c__[i__3].i + v2.i * c__[i__3].r;
q__4.r = q__5.r + q__6.r, q__4.i = q__5.i + q__6.i;
i__4 = j + c_dim1 * 3;
q__7.r = v3.r * c__[i__4].r - v3.i * c__[i__4].i, q__7.i = v3.r *
c__[i__4].i + v3.i * c__[i__4].r;
q__3.r = q__4.r + q__7.r, q__3.i = q__4.i + q__7.i;
i__5 = j + (c_dim1 << 2);
q__8.r = v4.r * c__[i__5].r - v4.i * c__[i__5].i, q__8.i = v4.r *
c__[i__5].i + v4.i * c__[i__5].r;
q__2.r = q__3.r + q__8.r, q__2.i = q__3.i + q__8.i;
i__6 = j + c_dim1 * 5;
q__9.r = v5.r * c__[i__6].r - v5.i * c__[i__6].i, q__9.i = v5.r *
c__[i__6].i + v5.i * c__[i__6].r;
q__1.r = q__2.r + q__9.r, q__1.i = q__2.i + q__9.i;
sum.r = q__1.r, sum.i = q__1.i;
i__2 = j + c_dim1;
i__3 = j + c_dim1;
q__2.r = sum.r * t1.r - sum.i * t1.i, q__2.i = sum.r * t1.i +
sum.i * t1.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + (c_dim1 << 1);
i__3 = j + (c_dim1 << 1);
q__2.r = sum.r * t2.r - sum.i * t2.i, q__2.i = sum.r * t2.i +
sum.i * t2.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 3;
i__3 = j + c_dim1 * 3;
q__2.r = sum.r * t3.r - sum.i * t3.i, q__2.i = sum.r * t3.i +
sum.i * t3.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + (c_dim1 << 2);
i__3 = j + (c_dim1 << 2);
q__2.r = sum.r * t4.r - sum.i * t4.i, q__2.i = sum.r * t4.i +
sum.i * t4.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 5;
i__3 = j + c_dim1 * 5;
q__2.r = sum.r * t5.r - sum.i * t5.i, q__2.i = sum.r * t5.i +
sum.i * t5.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L300: */
}
goto L410;
L310:
/* Special code for 6 x 6 Householder */
v1.r = v[1].r, v1.i = v[1].i;
r_cnjg(&q__2, &v1);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t1.r = q__1.r, t1.i = q__1.i;
v2.r = v[2].r, v2.i = v[2].i;
r_cnjg(&q__2, &v2);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t2.r = q__1.r, t2.i = q__1.i;
v3.r = v[3].r, v3.i = v[3].i;
r_cnjg(&q__2, &v3);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t3.r = q__1.r, t3.i = q__1.i;
v4.r = v[4].r, v4.i = v[4].i;
r_cnjg(&q__2, &v4);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t4.r = q__1.r, t4.i = q__1.i;
v5.r = v[5].r, v5.i = v[5].i;
r_cnjg(&q__2, &v5);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t5.r = q__1.r, t5.i = q__1.i;
v6.r = v[6].r, v6.i = v[6].i;
r_cnjg(&q__2, &v6);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t6.r = q__1.r, t6.i = q__1.i;
i__1 = *m;
for (j = 1; j <= i__1; ++j) {
i__2 = j + c_dim1;
q__6.r = v1.r * c__[i__2].r - v1.i * c__[i__2].i, q__6.i = v1.r *
c__[i__2].i + v1.i * c__[i__2].r;
i__3 = j + (c_dim1 << 1);
q__7.r = v2.r * c__[i__3].r - v2.i * c__[i__3].i, q__7.i = v2.r *
c__[i__3].i + v2.i * c__[i__3].r;
q__5.r = q__6.r + q__7.r, q__5.i = q__6.i + q__7.i;
i__4 = j + c_dim1 * 3;
q__8.r = v3.r * c__[i__4].r - v3.i * c__[i__4].i, q__8.i = v3.r *
c__[i__4].i + v3.i * c__[i__4].r;
q__4.r = q__5.r + q__8.r, q__4.i = q__5.i + q__8.i;
i__5 = j + (c_dim1 << 2);
q__9.r = v4.r * c__[i__5].r - v4.i * c__[i__5].i, q__9.i = v4.r *
c__[i__5].i + v4.i * c__[i__5].r;
q__3.r = q__4.r + q__9.r, q__3.i = q__4.i + q__9.i;
i__6 = j + c_dim1 * 5;
q__10.r = v5.r * c__[i__6].r - v5.i * c__[i__6].i, q__10.i = v5.r
* c__[i__6].i + v5.i * c__[i__6].r;
q__2.r = q__3.r + q__10.r, q__2.i = q__3.i + q__10.i;
i__7 = j + c_dim1 * 6;
q__11.r = v6.r * c__[i__7].r - v6.i * c__[i__7].i, q__11.i = v6.r
* c__[i__7].i + v6.i * c__[i__7].r;
q__1.r = q__2.r + q__11.r, q__1.i = q__2.i + q__11.i;
sum.r = q__1.r, sum.i = q__1.i;
i__2 = j + c_dim1;
i__3 = j + c_dim1;
q__2.r = sum.r * t1.r - sum.i * t1.i, q__2.i = sum.r * t1.i +
sum.i * t1.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + (c_dim1 << 1);
i__3 = j + (c_dim1 << 1);
q__2.r = sum.r * t2.r - sum.i * t2.i, q__2.i = sum.r * t2.i +
sum.i * t2.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 3;
i__3 = j + c_dim1 * 3;
q__2.r = sum.r * t3.r - sum.i * t3.i, q__2.i = sum.r * t3.i +
sum.i * t3.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + (c_dim1 << 2);
i__3 = j + (c_dim1 << 2);
q__2.r = sum.r * t4.r - sum.i * t4.i, q__2.i = sum.r * t4.i +
sum.i * t4.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 5;
i__3 = j + c_dim1 * 5;
q__2.r = sum.r * t5.r - sum.i * t5.i, q__2.i = sum.r * t5.i +
sum.i * t5.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 6;
i__3 = j + c_dim1 * 6;
q__2.r = sum.r * t6.r - sum.i * t6.i, q__2.i = sum.r * t6.i +
sum.i * t6.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L320: */
}
goto L410;
L330:
/* Special code for 7 x 7 Householder */
v1.r = v[1].r, v1.i = v[1].i;
r_cnjg(&q__2, &v1);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t1.r = q__1.r, t1.i = q__1.i;
v2.r = v[2].r, v2.i = v[2].i;
r_cnjg(&q__2, &v2);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t2.r = q__1.r, t2.i = q__1.i;
v3.r = v[3].r, v3.i = v[3].i;
r_cnjg(&q__2, &v3);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t3.r = q__1.r, t3.i = q__1.i;
v4.r = v[4].r, v4.i = v[4].i;
r_cnjg(&q__2, &v4);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t4.r = q__1.r, t4.i = q__1.i;
v5.r = v[5].r, v5.i = v[5].i;
r_cnjg(&q__2, &v5);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t5.r = q__1.r, t5.i = q__1.i;
v6.r = v[6].r, v6.i = v[6].i;
r_cnjg(&q__2, &v6);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t6.r = q__1.r, t6.i = q__1.i;
v7.r = v[7].r, v7.i = v[7].i;
r_cnjg(&q__2, &v7);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t7.r = q__1.r, t7.i = q__1.i;
i__1 = *m;
for (j = 1; j <= i__1; ++j) {
i__2 = j + c_dim1;
q__7.r = v1.r * c__[i__2].r - v1.i * c__[i__2].i, q__7.i = v1.r *
c__[i__2].i + v1.i * c__[i__2].r;
i__3 = j + (c_dim1 << 1);
q__8.r = v2.r * c__[i__3].r - v2.i * c__[i__3].i, q__8.i = v2.r *
c__[i__3].i + v2.i * c__[i__3].r;
q__6.r = q__7.r + q__8.r, q__6.i = q__7.i + q__8.i;
i__4 = j + c_dim1 * 3;
q__9.r = v3.r * c__[i__4].r - v3.i * c__[i__4].i, q__9.i = v3.r *
c__[i__4].i + v3.i * c__[i__4].r;
q__5.r = q__6.r + q__9.r, q__5.i = q__6.i + q__9.i;
i__5 = j + (c_dim1 << 2);
q__10.r = v4.r * c__[i__5].r - v4.i * c__[i__5].i, q__10.i = v4.r
* c__[i__5].i + v4.i * c__[i__5].r;
q__4.r = q__5.r + q__10.r, q__4.i = q__5.i + q__10.i;
i__6 = j + c_dim1 * 5;
q__11.r = v5.r * c__[i__6].r - v5.i * c__[i__6].i, q__11.i = v5.r
* c__[i__6].i + v5.i * c__[i__6].r;
q__3.r = q__4.r + q__11.r, q__3.i = q__4.i + q__11.i;
i__7 = j + c_dim1 * 6;
q__12.r = v6.r * c__[i__7].r - v6.i * c__[i__7].i, q__12.i = v6.r
* c__[i__7].i + v6.i * c__[i__7].r;
q__2.r = q__3.r + q__12.r, q__2.i = q__3.i + q__12.i;
i__8 = j + c_dim1 * 7;
q__13.r = v7.r * c__[i__8].r - v7.i * c__[i__8].i, q__13.i = v7.r
* c__[i__8].i + v7.i * c__[i__8].r;
q__1.r = q__2.r + q__13.r, q__1.i = q__2.i + q__13.i;
sum.r = q__1.r, sum.i = q__1.i;
i__2 = j + c_dim1;
i__3 = j + c_dim1;
q__2.r = sum.r * t1.r - sum.i * t1.i, q__2.i = sum.r * t1.i +
sum.i * t1.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + (c_dim1 << 1);
i__3 = j + (c_dim1 << 1);
q__2.r = sum.r * t2.r - sum.i * t2.i, q__2.i = sum.r * t2.i +
sum.i * t2.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 3;
i__3 = j + c_dim1 * 3;
q__2.r = sum.r * t3.r - sum.i * t3.i, q__2.i = sum.r * t3.i +
sum.i * t3.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + (c_dim1 << 2);
i__3 = j + (c_dim1 << 2);
q__2.r = sum.r * t4.r - sum.i * t4.i, q__2.i = sum.r * t4.i +
sum.i * t4.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 5;
i__3 = j + c_dim1 * 5;
q__2.r = sum.r * t5.r - sum.i * t5.i, q__2.i = sum.r * t5.i +
sum.i * t5.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 6;
i__3 = j + c_dim1 * 6;
q__2.r = sum.r * t6.r - sum.i * t6.i, q__2.i = sum.r * t6.i +
sum.i * t6.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 7;
i__3 = j + c_dim1 * 7;
q__2.r = sum.r * t7.r - sum.i * t7.i, q__2.i = sum.r * t7.i +
sum.i * t7.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L340: */
}
goto L410;
L350:
/* Special code for 8 x 8 Householder */
v1.r = v[1].r, v1.i = v[1].i;
r_cnjg(&q__2, &v1);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t1.r = q__1.r, t1.i = q__1.i;
v2.r = v[2].r, v2.i = v[2].i;
r_cnjg(&q__2, &v2);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t2.r = q__1.r, t2.i = q__1.i;
v3.r = v[3].r, v3.i = v[3].i;
r_cnjg(&q__2, &v3);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t3.r = q__1.r, t3.i = q__1.i;
v4.r = v[4].r, v4.i = v[4].i;
r_cnjg(&q__2, &v4);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t4.r = q__1.r, t4.i = q__1.i;
v5.r = v[5].r, v5.i = v[5].i;
r_cnjg(&q__2, &v5);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t5.r = q__1.r, t5.i = q__1.i;
v6.r = v[6].r, v6.i = v[6].i;
r_cnjg(&q__2, &v6);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t6.r = q__1.r, t6.i = q__1.i;
v7.r = v[7].r, v7.i = v[7].i;
r_cnjg(&q__2, &v7);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t7.r = q__1.r, t7.i = q__1.i;
v8.r = v[8].r, v8.i = v[8].i;
r_cnjg(&q__2, &v8);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t8.r = q__1.r, t8.i = q__1.i;
i__1 = *m;
for (j = 1; j <= i__1; ++j) {
i__2 = j + c_dim1;
q__8.r = v1.r * c__[i__2].r - v1.i * c__[i__2].i, q__8.i = v1.r *
c__[i__2].i + v1.i * c__[i__2].r;
i__3 = j + (c_dim1 << 1);
q__9.r = v2.r * c__[i__3].r - v2.i * c__[i__3].i, q__9.i = v2.r *
c__[i__3].i + v2.i * c__[i__3].r;
q__7.r = q__8.r + q__9.r, q__7.i = q__8.i + q__9.i;
i__4 = j + c_dim1 * 3;
q__10.r = v3.r * c__[i__4].r - v3.i * c__[i__4].i, q__10.i = v3.r
* c__[i__4].i + v3.i * c__[i__4].r;
q__6.r = q__7.r + q__10.r, q__6.i = q__7.i + q__10.i;
i__5 = j + (c_dim1 << 2);
q__11.r = v4.r * c__[i__5].r - v4.i * c__[i__5].i, q__11.i = v4.r
* c__[i__5].i + v4.i * c__[i__5].r;
q__5.r = q__6.r + q__11.r, q__5.i = q__6.i + q__11.i;
i__6 = j + c_dim1 * 5;
q__12.r = v5.r * c__[i__6].r - v5.i * c__[i__6].i, q__12.i = v5.r
* c__[i__6].i + v5.i * c__[i__6].r;
q__4.r = q__5.r + q__12.r, q__4.i = q__5.i + q__12.i;
i__7 = j + c_dim1 * 6;
q__13.r = v6.r * c__[i__7].r - v6.i * c__[i__7].i, q__13.i = v6.r
* c__[i__7].i + v6.i * c__[i__7].r;
q__3.r = q__4.r + q__13.r, q__3.i = q__4.i + q__13.i;
i__8 = j + c_dim1 * 7;
q__14.r = v7.r * c__[i__8].r - v7.i * c__[i__8].i, q__14.i = v7.r
* c__[i__8].i + v7.i * c__[i__8].r;
q__2.r = q__3.r + q__14.r, q__2.i = q__3.i + q__14.i;
i__9 = j + (c_dim1 << 3);
q__15.r = v8.r * c__[i__9].r - v8.i * c__[i__9].i, q__15.i = v8.r
* c__[i__9].i + v8.i * c__[i__9].r;
q__1.r = q__2.r + q__15.r, q__1.i = q__2.i + q__15.i;
sum.r = q__1.r, sum.i = q__1.i;
i__2 = j + c_dim1;
i__3 = j + c_dim1;
q__2.r = sum.r * t1.r - sum.i * t1.i, q__2.i = sum.r * t1.i +
sum.i * t1.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + (c_dim1 << 1);
i__3 = j + (c_dim1 << 1);
q__2.r = sum.r * t2.r - sum.i * t2.i, q__2.i = sum.r * t2.i +
sum.i * t2.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 3;
i__3 = j + c_dim1 * 3;
q__2.r = sum.r * t3.r - sum.i * t3.i, q__2.i = sum.r * t3.i +
sum.i * t3.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + (c_dim1 << 2);
i__3 = j + (c_dim1 << 2);
q__2.r = sum.r * t4.r - sum.i * t4.i, q__2.i = sum.r * t4.i +
sum.i * t4.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 5;
i__3 = j + c_dim1 * 5;
q__2.r = sum.r * t5.r - sum.i * t5.i, q__2.i = sum.r * t5.i +
sum.i * t5.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 6;
i__3 = j + c_dim1 * 6;
q__2.r = sum.r * t6.r - sum.i * t6.i, q__2.i = sum.r * t6.i +
sum.i * t6.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 7;
i__3 = j + c_dim1 * 7;
q__2.r = sum.r * t7.r - sum.i * t7.i, q__2.i = sum.r * t7.i +
sum.i * t7.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + (c_dim1 << 3);
i__3 = j + (c_dim1 << 3);
q__2.r = sum.r * t8.r - sum.i * t8.i, q__2.i = sum.r * t8.i +
sum.i * t8.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L360: */
}
goto L410;
L370:
/* Special code for 9 x 9 Householder */
v1.r = v[1].r, v1.i = v[1].i;
r_cnjg(&q__2, &v1);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t1.r = q__1.r, t1.i = q__1.i;
v2.r = v[2].r, v2.i = v[2].i;
r_cnjg(&q__2, &v2);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t2.r = q__1.r, t2.i = q__1.i;
v3.r = v[3].r, v3.i = v[3].i;
r_cnjg(&q__2, &v3);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t3.r = q__1.r, t3.i = q__1.i;
v4.r = v[4].r, v4.i = v[4].i;
r_cnjg(&q__2, &v4);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t4.r = q__1.r, t4.i = q__1.i;
v5.r = v[5].r, v5.i = v[5].i;
r_cnjg(&q__2, &v5);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t5.r = q__1.r, t5.i = q__1.i;
v6.r = v[6].r, v6.i = v[6].i;
r_cnjg(&q__2, &v6);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t6.r = q__1.r, t6.i = q__1.i;
v7.r = v[7].r, v7.i = v[7].i;
r_cnjg(&q__2, &v7);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t7.r = q__1.r, t7.i = q__1.i;
v8.r = v[8].r, v8.i = v[8].i;
r_cnjg(&q__2, &v8);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t8.r = q__1.r, t8.i = q__1.i;
v9.r = v[9].r, v9.i = v[9].i;
r_cnjg(&q__2, &v9);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t9.r = q__1.r, t9.i = q__1.i;
i__1 = *m;
for (j = 1; j <= i__1; ++j) {
i__2 = j + c_dim1;
q__9.r = v1.r * c__[i__2].r - v1.i * c__[i__2].i, q__9.i = v1.r *
c__[i__2].i + v1.i * c__[i__2].r;
i__3 = j + (c_dim1 << 1);
q__10.r = v2.r * c__[i__3].r - v2.i * c__[i__3].i, q__10.i = v2.r
* c__[i__3].i + v2.i * c__[i__3].r;
q__8.r = q__9.r + q__10.r, q__8.i = q__9.i + q__10.i;
i__4 = j + c_dim1 * 3;
q__11.r = v3.r * c__[i__4].r - v3.i * c__[i__4].i, q__11.i = v3.r
* c__[i__4].i + v3.i * c__[i__4].r;
q__7.r = q__8.r + q__11.r, q__7.i = q__8.i + q__11.i;
i__5 = j + (c_dim1 << 2);
q__12.r = v4.r * c__[i__5].r - v4.i * c__[i__5].i, q__12.i = v4.r
* c__[i__5].i + v4.i * c__[i__5].r;
q__6.r = q__7.r + q__12.r, q__6.i = q__7.i + q__12.i;
i__6 = j + c_dim1 * 5;
q__13.r = v5.r * c__[i__6].r - v5.i * c__[i__6].i, q__13.i = v5.r
* c__[i__6].i + v5.i * c__[i__6].r;
q__5.r = q__6.r + q__13.r, q__5.i = q__6.i + q__13.i;
i__7 = j + c_dim1 * 6;
q__14.r = v6.r * c__[i__7].r - v6.i * c__[i__7].i, q__14.i = v6.r
* c__[i__7].i + v6.i * c__[i__7].r;
q__4.r = q__5.r + q__14.r, q__4.i = q__5.i + q__14.i;
i__8 = j + c_dim1 * 7;
q__15.r = v7.r * c__[i__8].r - v7.i * c__[i__8].i, q__15.i = v7.r
* c__[i__8].i + v7.i * c__[i__8].r;
q__3.r = q__4.r + q__15.r, q__3.i = q__4.i + q__15.i;
i__9 = j + (c_dim1 << 3);
q__16.r = v8.r * c__[i__9].r - v8.i * c__[i__9].i, q__16.i = v8.r
* c__[i__9].i + v8.i * c__[i__9].r;
q__2.r = q__3.r + q__16.r, q__2.i = q__3.i + q__16.i;
i__10 = j + c_dim1 * 9;
q__17.r = v9.r * c__[i__10].r - v9.i * c__[i__10].i, q__17.i =
v9.r * c__[i__10].i + v9.i * c__[i__10].r;
q__1.r = q__2.r + q__17.r, q__1.i = q__2.i + q__17.i;
sum.r = q__1.r, sum.i = q__1.i;
i__2 = j + c_dim1;
i__3 = j + c_dim1;
q__2.r = sum.r * t1.r - sum.i * t1.i, q__2.i = sum.r * t1.i +
sum.i * t1.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + (c_dim1 << 1);
i__3 = j + (c_dim1 << 1);
q__2.r = sum.r * t2.r - sum.i * t2.i, q__2.i = sum.r * t2.i +
sum.i * t2.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 3;
i__3 = j + c_dim1 * 3;
q__2.r = sum.r * t3.r - sum.i * t3.i, q__2.i = sum.r * t3.i +
sum.i * t3.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + (c_dim1 << 2);
i__3 = j + (c_dim1 << 2);
q__2.r = sum.r * t4.r - sum.i * t4.i, q__2.i = sum.r * t4.i +
sum.i * t4.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 5;
i__3 = j + c_dim1 * 5;
q__2.r = sum.r * t5.r - sum.i * t5.i, q__2.i = sum.r * t5.i +
sum.i * t5.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 6;
i__3 = j + c_dim1 * 6;
q__2.r = sum.r * t6.r - sum.i * t6.i, q__2.i = sum.r * t6.i +
sum.i * t6.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 7;
i__3 = j + c_dim1 * 7;
q__2.r = sum.r * t7.r - sum.i * t7.i, q__2.i = sum.r * t7.i +
sum.i * t7.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + (c_dim1 << 3);
i__3 = j + (c_dim1 << 3);
q__2.r = sum.r * t8.r - sum.i * t8.i, q__2.i = sum.r * t8.i +
sum.i * t8.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 9;
i__3 = j + c_dim1 * 9;
q__2.r = sum.r * t9.r - sum.i * t9.i, q__2.i = sum.r * t9.i +
sum.i * t9.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L380: */
}
goto L410;
L390:
/* Special code for 10 x 10 Householder */
v1.r = v[1].r, v1.i = v[1].i;
r_cnjg(&q__2, &v1);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t1.r = q__1.r, t1.i = q__1.i;
v2.r = v[2].r, v2.i = v[2].i;
r_cnjg(&q__2, &v2);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t2.r = q__1.r, t2.i = q__1.i;
v3.r = v[3].r, v3.i = v[3].i;
r_cnjg(&q__2, &v3);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t3.r = q__1.r, t3.i = q__1.i;
v4.r = v[4].r, v4.i = v[4].i;
r_cnjg(&q__2, &v4);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t4.r = q__1.r, t4.i = q__1.i;
v5.r = v[5].r, v5.i = v[5].i;
r_cnjg(&q__2, &v5);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t5.r = q__1.r, t5.i = q__1.i;
v6.r = v[6].r, v6.i = v[6].i;
r_cnjg(&q__2, &v6);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t6.r = q__1.r, t6.i = q__1.i;
v7.r = v[7].r, v7.i = v[7].i;
r_cnjg(&q__2, &v7);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t7.r = q__1.r, t7.i = q__1.i;
v8.r = v[8].r, v8.i = v[8].i;
r_cnjg(&q__2, &v8);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t8.r = q__1.r, t8.i = q__1.i;
v9.r = v[9].r, v9.i = v[9].i;
r_cnjg(&q__2, &v9);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t9.r = q__1.r, t9.i = q__1.i;
v10.r = v[10].r, v10.i = v[10].i;
r_cnjg(&q__2, &v10);
q__1.r = tau->r * q__2.r - tau->i * q__2.i, q__1.i = tau->r * q__2.i
+ tau->i * q__2.r;
t10.r = q__1.r, t10.i = q__1.i;
i__1 = *m;
for (j = 1; j <= i__1; ++j) {
i__2 = j + c_dim1;
q__10.r = v1.r * c__[i__2].r - v1.i * c__[i__2].i, q__10.i = v1.r
* c__[i__2].i + v1.i * c__[i__2].r;
i__3 = j + (c_dim1 << 1);
q__11.r = v2.r * c__[i__3].r - v2.i * c__[i__3].i, q__11.i = v2.r
* c__[i__3].i + v2.i * c__[i__3].r;
q__9.r = q__10.r + q__11.r, q__9.i = q__10.i + q__11.i;
i__4 = j + c_dim1 * 3;
q__12.r = v3.r * c__[i__4].r - v3.i * c__[i__4].i, q__12.i = v3.r
* c__[i__4].i + v3.i * c__[i__4].r;
q__8.r = q__9.r + q__12.r, q__8.i = q__9.i + q__12.i;
i__5 = j + (c_dim1 << 2);
q__13.r = v4.r * c__[i__5].r - v4.i * c__[i__5].i, q__13.i = v4.r
* c__[i__5].i + v4.i * c__[i__5].r;
q__7.r = q__8.r + q__13.r, q__7.i = q__8.i + q__13.i;
i__6 = j + c_dim1 * 5;
q__14.r = v5.r * c__[i__6].r - v5.i * c__[i__6].i, q__14.i = v5.r
* c__[i__6].i + v5.i * c__[i__6].r;
q__6.r = q__7.r + q__14.r, q__6.i = q__7.i + q__14.i;
i__7 = j + c_dim1 * 6;
q__15.r = v6.r * c__[i__7].r - v6.i * c__[i__7].i, q__15.i = v6.r
* c__[i__7].i + v6.i * c__[i__7].r;
q__5.r = q__6.r + q__15.r, q__5.i = q__6.i + q__15.i;
i__8 = j + c_dim1 * 7;
q__16.r = v7.r * c__[i__8].r - v7.i * c__[i__8].i, q__16.i = v7.r
* c__[i__8].i + v7.i * c__[i__8].r;
q__4.r = q__5.r + q__16.r, q__4.i = q__5.i + q__16.i;
i__9 = j + (c_dim1 << 3);
q__17.r = v8.r * c__[i__9].r - v8.i * c__[i__9].i, q__17.i = v8.r
* c__[i__9].i + v8.i * c__[i__9].r;
q__3.r = q__4.r + q__17.r, q__3.i = q__4.i + q__17.i;
i__10 = j + c_dim1 * 9;
q__18.r = v9.r * c__[i__10].r - v9.i * c__[i__10].i, q__18.i =
v9.r * c__[i__10].i + v9.i * c__[i__10].r;
q__2.r = q__3.r + q__18.r, q__2.i = q__3.i + q__18.i;
i__11 = j + c_dim1 * 10;
q__19.r = v10.r * c__[i__11].r - v10.i * c__[i__11].i, q__19.i =
v10.r * c__[i__11].i + v10.i * c__[i__11].r;
q__1.r = q__2.r + q__19.r, q__1.i = q__2.i + q__19.i;
sum.r = q__1.r, sum.i = q__1.i;
i__2 = j + c_dim1;
i__3 = j + c_dim1;
q__2.r = sum.r * t1.r - sum.i * t1.i, q__2.i = sum.r * t1.i +
sum.i * t1.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + (c_dim1 << 1);
i__3 = j + (c_dim1 << 1);
q__2.r = sum.r * t2.r - sum.i * t2.i, q__2.i = sum.r * t2.i +
sum.i * t2.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 3;
i__3 = j + c_dim1 * 3;
q__2.r = sum.r * t3.r - sum.i * t3.i, q__2.i = sum.r * t3.i +
sum.i * t3.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + (c_dim1 << 2);
i__3 = j + (c_dim1 << 2);
q__2.r = sum.r * t4.r - sum.i * t4.i, q__2.i = sum.r * t4.i +
sum.i * t4.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 5;
i__3 = j + c_dim1 * 5;
q__2.r = sum.r * t5.r - sum.i * t5.i, q__2.i = sum.r * t5.i +
sum.i * t5.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 6;
i__3 = j + c_dim1 * 6;
q__2.r = sum.r * t6.r - sum.i * t6.i, q__2.i = sum.r * t6.i +
sum.i * t6.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 7;
i__3 = j + c_dim1 * 7;
q__2.r = sum.r * t7.r - sum.i * t7.i, q__2.i = sum.r * t7.i +
sum.i * t7.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + (c_dim1 << 3);
i__3 = j + (c_dim1 << 3);
q__2.r = sum.r * t8.r - sum.i * t8.i, q__2.i = sum.r * t8.i +
sum.i * t8.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 9;
i__3 = j + c_dim1 * 9;
q__2.r = sum.r * t9.r - sum.i * t9.i, q__2.i = sum.r * t9.i +
sum.i * t9.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
i__2 = j + c_dim1 * 10;
i__3 = j + c_dim1 * 10;
q__2.r = sum.r * t10.r - sum.i * t10.i, q__2.i = sum.r * t10.i +
sum.i * t10.r;
q__1.r = c__[i__3].r - q__2.r, q__1.i = c__[i__3].i - q__2.i;
c__[i__2].r = q__1.r, c__[i__2].i = q__1.i;
/* L400: */
}
goto L410;
}
L410:
return 0;
/* End of CLARFX */
} /* clarfx_ */
|
the_stack_data/140192.c | #include <stdlib.h>
int main()
{
char *something;
// there should not be any overflow in there
something=getenv("HOME");
}
|
the_stack_data/7950914.c | #include <stdio.h>
#include <stdlib.h>
#include <time.h>
void insertionSort(int *, int);
int checkOrder(int *, int);
int main(int argc, const char * argv[]) {
if (argc < 2) {
printf("Usage: %s <N>\n", argv[0]);
puts("Program generates N random integers then sorts them.\n");
return 1;
}
int nNumbers = atoi(argv[1]);
if (nNumbers < 1 || nNumbers > 999) {
puts("Please choose a value greater than 0 and less than 1000.");
return 0;
}
srand(time(NULL));
int * array = (int *)(malloc(sizeof(int)*nNumbers));
if (array != NULL) {
int i = 0;
printf("The unsorted array is: ");
for (i = 0; i < nNumbers; ++i) {
array[i] = rand() % 2333;
printf("%d ", array[i]);
}
}
else {
puts("No memory allocated for array.\n");
return 0;
}
printf("\n");
insertionSort(array, nNumbers);
int isInorder = checkOrder(array, nNumbers);
printf("The array is %s order after sorting.\n", (isInorder ? "in" : "not in"));
free(array);
}
int checkOrder(int *array, int n) {
int i = 0;
int noError = 1; // set noError to True
printf("The sorted array is: ");
for (i = 0; i < n-1; ++i) {
if (array[i] > array[i+1]) {
noError = 0; // array element out of order, set noError to False
}
printf("%d ",array[i]);
}
printf("%d\n",array[n-1]);
return noError;
}
|
the_stack_data/22013763.c | #ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <ctype.h>
#include <string.h>
int strncasecmp(const char *s1, const char *s2, size_t len)
{
unsigned char us1;
unsigned char us2;
size_t index;
if (len <= 0)
{
return 0;
}
us1 = tolower(*s1);
us2 = tolower(*s2);
index = 0;
while (index < len && us1 != '\0' && us1 == us2)
{
index++;
us1 = tolower(s1[index]);
us2 = tolower(s2[index]);
}
if (index == len)
{
return 0;
}
return us1 - us2;
}
|
the_stack_data/1119505.c | /* munchconfig.c
A very, very (very!) simple program to process a config_h.sh file on
non-unix systems.
usage:
munchconfig config.sh config_h.sh [-f file] [foo=bar [baz=xyzzy [...]]] >config.h
which is to say, it takes as its first parameter a config.sh (or
equivalent), as its second a config_h.sh (or equivalent), an optional file
containing tag=value pairs (one on each line), and an optional list of
tag=value pairs on the command line.
It spits the processed config.h out to STDOUT.
*/
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
/* The failure code to exit with */
#ifndef EXIT_FAILURE
#ifdef VMS
#define EXIT_FAILURE 0
#else
#define EXIT_FAILURE -1
#endif
#endif
/* The biggest line we can read in from a file */
#define LINEBUFFERSIZE 1024
#define NUMTILDESUBS 30
#define NUMCONFIGSUBS 1000
#define TOKENBUFFERSIZE 80
typedef struct {
char Tag[TOKENBUFFERSIZE];
char Value[512];
} Translate;
void tilde_sub(char [], Translate [], int);
int
main(int argc, char *argv[])
{
int c, i;
char *ifile = NULL;
char WorkString[LINEBUFFERSIZE];
FILE *ConfigSH, *Config_H, *Extra_Subs;
char LineBuffer[LINEBUFFERSIZE], *TempValue, *StartTilde, *EndTilde;
char SecondaryLineBuffer[LINEBUFFERSIZE], OutBuf[LINEBUFFERSIZE];
char TokenBuffer[TOKENBUFFERSIZE];
int LineBufferLength, TempLength, DummyVariable, LineBufferLoop;
int TokenBufferLoop, ConfigSubLoop, GotIt, OutBufPos;
Translate TildeSub[NUMTILDESUBS]; /* Holds the tilde (~FOO~) */
/* substitutions */
Translate ConfigSub[NUMCONFIGSUBS]; /* Holds the substitutions from */
/* config.sh */
int TildeSubCount = 0, ConfigSubCount = 0; /* # of tilde substitutions */
/* and config substitutions, */
/* respectively */
if (argc < 3) {
printf("Usage: munchconfig config.sh config_h.sh [-f file] [foo=bar [baz=xyzzy [...]]]\n");
exit(EXIT_FAILURE);
}
optind = 3; /* skip config.sh and config_h.sh */
while ((c = getopt(argc, argv, "f:")) != -1) {
switch (c) {
case 'f':
ifile = optarg;
break;
case ':':
fprintf(stderr, "Option -%c requires an operand\n", optopt);
break;
case '?':
fprintf(stderr,"Unrecognised option: -%c\n", optopt);
}
}
/* First, open the input files */
if (NULL == (ConfigSH = fopen(argv[1], "r"))) {
printf("Error %i trying to open config.sh file %s\n", errno, argv[1]);
exit(EXIT_FAILURE);
}
if (NULL == (Config_H = fopen(argv[2], "r"))) {
printf("Error %i trying to open config_h.sh file %s\n", errno, argv[2]);
exit(EXIT_FAILURE);
}
if (ifile != NULL && NULL == (Extra_Subs = fopen(ifile, "r"))) {
printf("Error %i trying to open extra substitutions file %s\n", errno, ifile);
exit(EXIT_FAILURE);
}
/* Any tag/value pairs on the command line? */
if (argc > optind) {
for (i=optind; i < argc && argv[i]; i++) {
/* Local copy */
strcpy(WorkString, argv[i]);
/* Stick a NULL over the = */
TempValue = strchr(WorkString, '=');
*TempValue++ = '\0';
/* Copy the tag and value into the holding array */
strcpy(TildeSub[TildeSubCount].Tag, WorkString);
strcpy(TildeSub[TildeSubCount].Value, TempValue);
TildeSubCount++;
}
}
/* Now read in the tag/value pairs from the extra substitutions file, if any */
while(ifile && fgets(LineBuffer, LINEBUFFERSIZE - 1, Extra_Subs)) {
/* Force a trailing null, just in case */
LineBuffer[LINEBUFFERSIZE - 1] = '\0';
LineBufferLength = strlen(LineBuffer);
/* Chop trailing control characters */
while((LineBufferLength > 0) && (LineBuffer[LineBufferLength-1] < ' ')) {
LineBuffer[LineBufferLength - 1] = '\0';
LineBufferLength--;
}
/* If it's empty, then try again */
if (!*LineBuffer)
continue;
/* Local copy */
strcpy(WorkString, LineBuffer);
/* Stick a NULL over the = */
TempValue = strchr(WorkString, '=');
*TempValue++ = '\0';
/* Copy the tag and value into the holding array */
strcpy(TildeSub[TildeSubCount].Tag, WorkString);
strcpy(TildeSub[TildeSubCount].Value, TempValue);
TildeSubCount++;
}
/* Now read in the config.sh file. */
while(fgets(LineBuffer, LINEBUFFERSIZE - 1, ConfigSH)) {
/* Force a trailing null, just in case */
LineBuffer[LINEBUFFERSIZE - 1] = '\0';
LineBufferLength = strlen(LineBuffer);
/* Chop trailing control characters */
while((LineBufferLength > 0) && (LineBuffer[LineBufferLength-1] < ' ')) {
LineBuffer[LineBufferLength - 1] = '\0';
LineBufferLength--;
}
/* If it's empty, then try again */
if (!*LineBuffer)
continue;
/* If the line begins with a '#' or ' ', skip */
if ((LineBuffer[0] == ' ') || (LineBuffer[0] == '#'))
continue;
/* We've got something. Guess we need to actually handle it */
/* Do the tilde substitution */
tilde_sub(LineBuffer, TildeSub, TildeSubCount);
/* Stick a NULL over the = */
TempValue = strchr(LineBuffer, '=');
*TempValue++ = '\0';
/* And another over the leading ', which better be there */
*TempValue++ = '\0';
/* Check to see if there's a trailing ' or ". If not, add a newline to
the buffer and grab another line. */
TempLength = strlen(TempValue);
while ((TempValue[TempLength-1] != '\'') &&
(TempValue[TempLength-1] != '"')) {
fgets(SecondaryLineBuffer, LINEBUFFERSIZE - 1, ConfigSH);
/* Force a trailing null, just in case */
SecondaryLineBuffer[LINEBUFFERSIZE - 1] = '\0';
/* Go substitute */
tilde_sub(SecondaryLineBuffer, TildeSub, TildeSubCount);
/* Tack a nweline on the end of our primary buffer */
strcat(TempValue, "\n");
/* Concat the new line we just read */
strcat(TempValue, SecondaryLineBuffer);
/* Refigure the length */
TempLength = strlen(TempValue);
/* Chop trailing control characters */
while((TempLength > 0) && (TempValue[TempLength-1] < ' ')) {
TempValue[TempLength - 1] = '\0';
TempLength--;
}
}
/* And finally one over the trailing ' */
TempValue[TempLength-1] = '\0';
/* Is there even anything left? */
if(*TempValue) {
/* Copy the tag over */
strcpy(ConfigSub[ConfigSubCount].Tag, LineBuffer);
/* Copy the value over */
strcpy(ConfigSub[ConfigSubCount].Value, TempValue);
/* Up the count */
ConfigSubCount++;
}
}
/* Okay, we've read in all the substitutions from our config.sh */
/* equivalent. Read in the config_h.sh equiv and start the substitution */
/* First, eat all the lines until we get to one with !GROK!THIS! in it */
while(!strstr(fgets(LineBuffer, LINEBUFFERSIZE, Config_H),
"!GROK!THIS!")) {
/* Dummy statement to shut up any compiler that'll whine about an empty */
/* loop */
DummyVariable++;
}
/* Right, we've read all the lines through the first one with !GROK!THIS! */
/* in it. That gets us through the beginning stuff. Now start in earnest */
/* with our translations, which run until we get to another !GROK!THIS! */
while(!strstr(fgets(LineBuffer, LINEBUFFERSIZE, Config_H),
"!GROK!THIS!")) {
/* Force a trailing null, just in case */
LineBuffer[LINEBUFFERSIZE - 1] = '\0';
/* Tilde Substitute */
tilde_sub(LineBuffer, TildeSub, TildeSubCount);
LineBufferLength = strlen(LineBuffer);
/* Chop trailing control characters */
while((LineBufferLength > 0) && (LineBuffer[LineBufferLength-1] < ' ')) {
LineBuffer[LineBufferLength - 1] = '\0';
LineBufferLength--;
}
OutBufPos = 0;
/* Right. Go looking for $s. */
for(LineBufferLoop = 0; LineBufferLoop < LineBufferLength;
LineBufferLoop++) {
/* Did we find one? */
if ('$' != LineBuffer[LineBufferLoop]) {
/* Nope, spit out the value */
OutBuf[OutBufPos++] = LineBuffer[LineBufferLoop];
} else {
/* Yes, we did. Is it escaped? */
if ((LineBufferLoop > 0) && ('\\' == LineBuffer[LineBufferLoop -
1])) {
/* Yup. Spit it out */
OutBuf[OutBufPos++] = LineBuffer[LineBufferLoop];
} else {
/* Nope. Go grab us a token */
TokenBufferLoop = 0;
/* Advance to the next character in the input stream */
LineBufferLoop++;
while((LineBufferLoop < LineBufferLength) &&
((isalnum(LineBuffer[LineBufferLoop]) || ('_' ==
LineBuffer[LineBufferLoop])))) {
TokenBuffer[TokenBufferLoop] = LineBuffer[LineBufferLoop];
LineBufferLoop++;
TokenBufferLoop++;
}
/* Trailing null on the token buffer */
TokenBuffer[TokenBufferLoop] = '\0';
/* Back the line buffer pointer up one */
LineBufferLoop--;
/* Right, we're done grabbing a token. Check to make sure we got */
/* something */
if (TokenBufferLoop) {
/* Well, we do. Run through all the tokens we've got in the */
/* ConfigSub array and see if any match */
GotIt = 0;
for(ConfigSubLoop = 0; ConfigSubLoop < ConfigSubCount;
ConfigSubLoop++) {
if (!strcmp(TokenBuffer, ConfigSub[ConfigSubLoop].Tag)) {
char *cp = ConfigSub[ConfigSubLoop].Value;
GotIt = 1;
while (*cp) OutBuf[OutBufPos++] = *(cp++);
break;
}
}
/* Did we find something? If not, spit out what was in our */
/* buffer */
if (!GotIt) {
char *cp = TokenBuffer;
OutBuf[OutBufPos++] = '$';
while (*cp) OutBuf[OutBufPos++] = *(cp++);
}
} else {
/* Just a bare $. Spit it out */
OutBuf[OutBufPos++] = '$';
}
}
}
}
/* If we've created an #undef line, make sure we don't output anything
* after the "#undef FOO" besides comments. We could do this as we
* go by recognizing the #undef as it goes by, and thus avoid another
* use of a fixed-length buffer, but this is simpler.
*/
if (!strncmp(OutBuf,"#undef",6)) {
char *cp = OutBuf;
int i, incomment = 0;
LineBufferLoop = 0;
OutBuf[OutBufPos] = '\0';
for (i = 0; i <= 1; i++) {
while (!isspace(*cp)) LineBuffer[LineBufferLoop++] = *(cp++);
while ( isspace(*cp)) LineBuffer[LineBufferLoop++] = *(cp++);
}
while (*cp) {
while (isspace(*cp)) LineBuffer[LineBufferLoop++] = *(cp++);
if (!incomment && *cp == '/' && *(cp+1) == '*') incomment = 1;
while (*cp && !isspace(*cp)) {
if (incomment) LineBuffer[LineBufferLoop++] = *cp;
cp++;
}
if (incomment && *cp == '*' && *(cp+1) == '/') incomment = 0;
}
LineBuffer[LineBufferLoop] = '\0';
puts(LineBuffer);
}
else {
OutBuf[OutBufPos] = '\0';
puts(OutBuf);
}
}
/* Close the files */
fclose(ConfigSH);
fclose(Config_H);
if (ifile) fclose(Extra_Subs);
}
void
tilde_sub(char LineBuffer[], Translate TildeSub[], int TildeSubCount)
{
char TempBuffer[LINEBUFFERSIZE], TempTilde[TOKENBUFFERSIZE];
int TildeLoop, InTilde, CopiedBufferLength, TildeBufferLength, k, GotIt;
int TempLength;
InTilde = 0;
CopiedBufferLength = 0;
TildeBufferLength = 0;
TempLength = strlen(LineBuffer);
/* Grovel over our input looking for ~foo~ constructs */
for(TildeLoop = 0; TildeLoop < TempLength; TildeLoop++) {
/* Are we in a tilde? */
if (InTilde) {
/* Yup. Is the current character a tilde? */
if (LineBuffer[TildeLoop] == '~') {
/* Yup. That means we're ready to do a substitution */
InTilde = 0;
GotIt = 0;
/* Trailing null */
TempTilde[TildeBufferLength] = '\0';
for( k=0; k < TildeSubCount; k++) {
if (!strcmp(TildeSub[k].Tag, TempTilde)) {
GotIt = 1;
/* Tack on the trailing null to the main buffer */
TempBuffer[CopiedBufferLength] = '\0';
/* Copy the tilde substitution over */
strcat(TempBuffer, TildeSub[k].Value);
CopiedBufferLength = strlen(TempBuffer);
}
}
/* Did we find anything? */
if (GotIt == 0) {
/* Guess not. Copy the whole thing out verbatim */
TempBuffer[CopiedBufferLength] = '\0';
TempBuffer[CopiedBufferLength++] = '~';
TempBuffer[CopiedBufferLength] = '\0';
strcat(TempBuffer, TempTilde);
strcat(TempBuffer, "~");
CopiedBufferLength = strlen(TempBuffer);
}
} else {
/* 'Kay, not a tilde. Is it a word character? */
if (isalnum(LineBuffer[TildeLoop]) ||
(LineBuffer[TildeLoop] == '-')) {
TempTilde[TildeBufferLength++] = LineBuffer[TildeLoop];
} else {
/* No, it's not a tilde character. For shame! We've got a */
/* bogus token. Copy a ~ into the output buffer, then append */
/* whatever we've got in our token buffer */
TempBuffer[CopiedBufferLength++] = '~';
TempBuffer[CopiedBufferLength] = '\0';
TempTilde[TildeBufferLength] = '\0';
strcat(TempBuffer, TempTilde);
CopiedBufferLength += TildeBufferLength;
InTilde = 0;
}
}
} else {
/* We're not in a tilde. Do we want to be? */
if (LineBuffer[TildeLoop] == '~') {
/* Guess so */
InTilde = 1;
TildeBufferLength = 0;
} else {
/* Nope. Copy the character to the output buffer */
TempBuffer[CopiedBufferLength++] = LineBuffer[TildeLoop];
}
}
}
/* Out of the loop. First, double-check to see if there was anything */
/* pending. */
if (InTilde) {
/* bogus token. Copy a ~ into the output buffer, then append */
/* whatever we've got in our token buffer */
TempBuffer[CopiedBufferLength++] = '~';
TempBuffer[CopiedBufferLength] = '\0';
TempTilde[TildeBufferLength] = '\0';
strcat(TempBuffer, TempTilde);
CopiedBufferLength += TildeBufferLength;
} else {
/* Nope, nothing pensing. Tack on a \0 */
TempBuffer[CopiedBufferLength] = '\0';
}
/* Okay, we're done. Copy the temp buffer back into the line buffer */
strcpy(LineBuffer, TempBuffer);
}
|
the_stack_data/234518807.c | #include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
int main()
{
if(fork()==0)
{
printf("1");
}
else
{
wait(NULL);
printf("2");
printf("3");
}
return 0;
}
|
the_stack_data/199156.c | void foo() {
int I;
for (I = 0; I < 10; --I);
}
|
the_stack_data/136914.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_iscntrl.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: oel-ayad <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/11/12 18:10:19 by oel-ayad #+# #+# */
/* Updated: 2018/11/13 18:13:12 by oel-ayad ### ########.fr */
/* */
/* ************************************************************************** */
int ft_iscntrl(char c)
{
if ((c >= 0 && c <= 31) || c == 127)
return (1);
return (0);
}
|
the_stack_data/70229.c | #include <stdio.h>
int x,i,y;
int n[] = {0,1};
void op(opt) {
if (opt==0) {
n[0] = n[0]+y ; //soma
}
else if (opt==1) {
n[1] = n[1]*y ; //Produto
}}
int main (){
printf(" defina o tamanho do vetor: ");
scanf("%i",&x);
int v[x];
for ( i = 0; i < x; i++) {
printf("digite os valores \n");
scanf("%d", &y);
op(0,y,n);
op(1,y,n);
v[i] = y;
}
for ( i = 0; i < x; i++) {
printf("[%d]", v[i] );
}
printf("\n soma %d \n", n[0] );
printf(" produto %d \n", n[1] );
}
|
the_stack_data/18888220.c | /*
* Mach Operating System
* Copyright (c) 1991,1990 Carnegie Mellon University
* All Rights Reserved.
*
* Permission to use, copy, modify and distribute this software and its
* documentation is hereby granted, provided that both the copyright
* notice and this permission notice appear in all copies of the
* software, derivative works or modified versions, and any portions
* thereof, and that both notices appear in supporting documentation.
*
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
*
* Carnegie Mellon requests users of this software to return to
*
* Software Distribution Coordinator or [email protected]
* School of Computer Science
* Carnegie Mellon University
* Pittsburgh PA 15213-3890
*
* any improvements or extensions that they make and grant Carnegie the
* rights to redistribute these changes.
*/
/*
* HISTORY
* $Log: Ovfork.c,v $
* Revision 2.2 92/01/16 00:00:54 rpd
* Moved from user collection to mk collection.
*
* Revision 2.2 91/03/26 17:46:29 mrt
* First checkin
*
*/
/*
* Just calls fork, as the vfork kernel call no longer
* does anything different from fork. The fork program calls
* mach_init for the child.
*/
int vfork()
{
return(fork());
}
|
the_stack_data/36075919.c | /*
* ---------------------------------------
* Copyright (c) Sebastian Günther 2021 |
* |
* [email protected] |
* |
* SPDX-License-Identifier: BSD-3-Clause |
* ---------------------------------------
*/
#include <stdio.h>
typedef char STRING[];
int main(int argc, char* argv[]) {
STRING s = {'I', '`', 'm', ' ', 0x21, '\0'};
printf("STRING is %s\n", s);
printf("\nGoodbye!\n");
} |
the_stack_data/176707111.c | /*
Matrix Vector multiplication without deallocating the matrix "b" after the kernel finishes.
*/
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#define C 512
int *a;
int *b;
int *c;
int init(){
for(int i=0; i<C; i++){
for(int j=0; j<C; j++){
b[j+i*C]=1;
}
a[i]=1;
c[i]=0;
}
return 0;
}
int Mult(){
#pragma acc enter data copyin(a[0:C],b[0:C*C]) create(c[0:C])
{
#pragma acc parallel loop gang
for(int i=0; i<C; i++){
#pragma acc loop worker
for(int j=0; j<C; j++){
c[i]+=b[j+i*C]*a[j];
}
}
}
#pragma acc exit data copyout(c[0:C]) delete(a[0:C])
return 0;
}
int check(){
bool test = false;
for(int i=0; i<C; i++){
if(c[i]!=C){
test = true;
}
}
printf("Memory Access Issue visible: %s\n",test ? "true" : "false");
return 0;
}
int main(){
a = malloc(C*sizeof(int));
b = malloc(C*C*sizeof(int));
c = malloc(C*sizeof(int));
init();
Mult();
check();
free(a);
free(b);
free(c);
return 0;
} |
the_stack_data/436149.c | #include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
int main() {
/* Enter your code here. Read input from STDIN. Print output to STDOUT */
unsigned int n;
scanf("%u",&n);
unsigned int a[n],sum=0;
for (int i=0; i<n; i++) {
scanf("%u",&a[i]);
sum+=a[i];
}
printf("%u",sum);
return 0;
}
|
the_stack_data/215767398.c | #include <stdio.h>
int main()
{
int c;
/*
"!=" have highest priority than "=",
so in upgrade.c we have to add additional
brackets. In other way c variable would have
only 0 or 1 value
*/
c = getchar() != EOF;
printf("%d\n", c);
return 0;
} |
the_stack_data/176706299.c | /*
A C-program for MT19937, with initialization improved 2002/2/10.
Coded by Takuji Nishimura and Makoto Matsumoto.
This is a faster version by taking Shawn Cokus's optimization,
Matthe Bellew's simplification, Isaku Wada's real version.
Before using, initialize the state by using init_genrand(seed)
or init_by_array(init_key, key_length).
Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The names of its contributors may not be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Any feedback is very welcome.
http://www.math.keio.ac.jp/matumoto/emt.html
email: [email protected]
*/
#include <stdio.h>
/* Period parameters */
#define N 624
#define M 397
#define MATRIX_A 0x9908b0dfUL /* constant vector a */
#define UMASK 0x80000000UL /* most significant w-r bits */
#define LMASK 0x7fffffffUL /* least significant r bits */
#define MIXBITS(u,v) ( ((u) & UMASK) | ((v) & LMASK) )
#define TWIST(u,v) ((MIXBITS(u,v) >> 1) ^ ((v)&1UL ? MATRIX_A : 0UL))
static unsigned long state[N]; /* the array for the state vector */
static int left = 1;
static int initf = 0;
static unsigned long *next;
/* initializes state[N] with a seed */
void init_genrand(unsigned long s)
{
int j;
state[0]= s & 0xffffffffUL;
for (j=1; j<N; j++) {
state[j] = (1812433253UL * (state[j-1] ^ (state[j-1] >> 30)) + j);
/* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
/* In the previous versions, MSBs of the seed affect */
/* only MSBs of the array state[]. */
/* 2002/01/09 modified by Makoto Matsumoto */
state[j] &= 0xffffffffUL; /* for >32 bit machines */
}
left = 1; initf = 1;
}
/* initialize by an array with array-length */
/* init_key is the array for initializing keys */
/* key_length is its length */
void init_by_array(init_key, key_length)
unsigned long init_key[], key_length;
{
int i, j, k;
init_genrand(19650218UL);
i=1; j=0;
k = (N>key_length ? N : key_length);
for (; k; k--) {
state[i] = (state[i] ^ ((state[i-1] ^ (state[i-1] >> 30)) * 1664525UL))
+ init_key[j] + j; /* non linear */
state[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
i++; j++;
if (i>=N) { state[0] = state[N-1]; i=1; }
if (j>=key_length) j=0;
}
for (k=N-1; k; k--) {
state[i] = (state[i] ^ ((state[i-1] ^ (state[i-1] >> 30)) * 1566083941UL))
- i; /* non linear */
state[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
i++;
if (i>=N) { state[0] = state[N-1]; i=1; }
}
state[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */
left = 1; initf = 1;
}
static void next_state(void)
{
unsigned long *p=state;
int j;
/* if init_genrand() has not been called, */
/* a default initial seed is used */
if (initf==0) init_genrand(5489UL);
left = N;
next = state;
for (j=N-M+1; --j; p++)
*p = p[M] ^ TWIST(p[0], p[1]);
for (j=M; --j; p++)
*p = p[M-N] ^ TWIST(p[0], p[1]);
*p = p[M-N] ^ TWIST(p[0], state[0]);
}
/* generates a random number on [0,0xffffffff]-interval */
unsigned long genrand_int32(void)
{
unsigned long y;
if (--left == 0) next_state();
y = *next++;
/* Tempering */
y ^= (y >> 11);
y ^= (y << 7) & 0x9d2c5680UL;
y ^= (y << 15) & 0xefc60000UL;
y ^= (y >> 18);
return y;
}
/* generates a random number on [0,0x7fffffff]-interval */
long genrand_int31(void)
{
unsigned long y;
if (--left == 0) next_state();
y = *next++;
/* Tempering */
y ^= (y >> 11);
y ^= (y << 7) & 0x9d2c5680UL;
y ^= (y << 15) & 0xefc60000UL;
y ^= (y >> 18);
return (long)(y>>1);
}
/* generates a random number on [0,1]-real-interval */
double genrand_real1(void)
{
unsigned long y;
if (--left == 0) next_state();
y = *next++;
/* Tempering */
y ^= (y >> 11);
y ^= (y << 7) & 0x9d2c5680UL;
y ^= (y << 15) & 0xefc60000UL;
y ^= (y >> 18);
return (double)y * (1.0/4294967295.0);
/* divided by 2^32-1 */
}
/* generates a random number on [0,1)-real-interval */
double genrand_real2(void)
{
unsigned long y;
if (--left == 0) next_state();
y = *next++;
/* Tempering */
y ^= (y >> 11);
y ^= (y << 7) & 0x9d2c5680UL;
y ^= (y << 15) & 0xefc60000UL;
y ^= (y >> 18);
return (double)y * (1.0/4294967296.0);
/* divided by 2^32 */
}
/* generates a random number on (0,1)-real-interval */
double genrand_real3(void)
{
unsigned long y;
if (--left == 0) next_state();
y = *next++;
/* Tempering */
y ^= (y >> 11);
y ^= (y << 7) & 0x9d2c5680UL;
y ^= (y << 15) & 0xefc60000UL;
y ^= (y >> 18);
return ((double)y + 0.5) * (1.0/4294967296.0);
/* divided by 2^32 */
}
/* generates a random number on [0,1) with 53-bit resolution*/
double genrand_res53(void)
{
unsigned long a=genrand_int32()>>5, b=genrand_int32()>>6;
return(a*67108864.0+b)*(1.0/9007199254740992.0);
}
/* These real versions are due to Isaku Wada, 2002/01/09 added */
// int main(void)
// {
// int i;
// unsigned long init[4]={0x123, 0x234, 0x345, 0x456}, length=4;
// init_by_array(init, length);
// /* This is an example of initializing by an array. */
// /* You may use init_genrand(seed) with any 32bit integer */
// /* as a seed for a simpler initialization */
// printf("1000 outputs of genrand_int32()\n");
// for (i=0; i<1000; i++) {
// printf("%10lu ", genrand_int32());
// if (i%5==4) printf("\n");
// }
// printf("\n1000 outputs of genrand_real2()\n");
// for (i=0; i<1000; i++) {
// printf("%10.8f ", genrand_real2());
// if (i%5==4) printf("\n");
// }
//
// return 0;
// }
|
the_stack_data/20449353.c | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
/*
* File: main.c
* Author: lacal
*
* Created on Sobota, 2019, októbra 12, 17:02
*/
#include <stdio.h>
#include <stdlib.h>
/*
*
*/
int main(int argc, char** argv) {
for (int i = 1; i <= 255; i++) {
printf("ASCII value of character %c is %d \n",i,i);
if (i % 10 == 0) {
getchar();
}
}
return (EXIT_SUCCESS);
}
|
the_stack_data/206392529.c | /* { dg-do compile } */
/* { dg-options "-O1 -fdump-tree-alias1-vops" } */
/* LLVM LOCAL test not applicable */
/* { dg-require-fdump "" } */
/* Test to make sure that inline-asm causes a V_MAY_DEF. */
void link_error();
void f(char *a)
{
int *a1 = (int *)a;
if (*a == 0)
asm("":"=m"(*a1));
if (*a == 0)
link_error ();
}
/* There should a V_MAY_DEF for the inline-asm and one for the link_error. */
/* { dg-final { scan-tree-dump-times "V_MAY_DEF" 2 "alias1"} } */
/* { dg-final { cleanup-tree-dump "alias1" } } */
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.