diff --git a/common/arena_array.h b/common/arena_array.h index a1a2d8c5..2fd991a1 100644 --- a/common/arena_array.h +++ b/common/arena_array.h @@ -32,12 +32,38 @@ static void* aarray__reserve(void* ptr, size_t type_size, size_t min_size) { return ptr; } +static void* aarray__reserve2(void* ptr, size_t type_size, size_t min_size) { + AArray* header = ((AArray*)ptr) - 1; + + if (min_size >= header->capacity) { + size_t old = header->capacity; + header->capacity = min_size * 2; + + AArray* new_ptr = tb_arena_realloc(header->arena, header, sizeof(AArray) + (type_size * old), sizeof(AArray) + (type_size * header->capacity)); + if (!new_ptr) { + fprintf(stderr, "error: out of memory!"); + abort(); + } + + ptr = &new_ptr->data[0]; + header = new_ptr; + } + + // zero out the space up to the min_size + if (min_size > header->length) { + memset(&header->data[header->length * type_size], 0, (min_size - header->length) * type_size); + } + header->length = min_size + 1; + + return ptr; +} + #define ArenaArray(T) T* #define aarray_create(arena, T, cap) (T*) aarray__create(arena, sizeof(T), cap) #define aarray_length(arr) ((((AArray*) (arr)) - 1)->length) #define aarray_set_length(arr, len) ((((AArray*) (arr)) - 1)->length = (len)) #define aarray_clear(arr) ((((AArray*) (arr)) - 1)->length = 0) -#define aarray_insert(arr, i, ...) ((arr) = aarray__reserve(arr, sizeof(*(arr)), (i)), (arr)[i] = __VA_ARGS__) +#define aarray_insert(arr, i, ...) ((arr) = aarray__reserve2(arr, sizeof(*(arr)), (i)), (arr)[i] = __VA_ARGS__) #define aarray_push(arr, ...) ((arr) = aarray__reserve(arr, sizeof(*(arr)), aarray_length(arr)), (arr)[aarray_length(arr)++] = __VA_ARGS__) #define aarray_pop(arr) ((arr)[(((AArray*)(arr)) - 1)->length -= 1]) #define aarray_top(arr) ((arr)[(((AArray*)(arr)) - 1)->length - 1]) diff --git a/cuik_c/expr_fold.h b/cuik_c/expr_fold.h index 708a5055..a44238b2 100644 --- a/cuik_c/expr_fold.h +++ b/cuik_c/expr_fold.h @@ -2,12 +2,11 @@ #define GET_CONST_INT(e) (e.i) #define SET_CONST_INT(lhs, rhs) (lhs.tag = CUIK_CONST_INT, lhs.i = (rhs)) -static bool const_eval(Cuik_Parser* restrict parser, Cuik_Expr* e, Cuik_ConstVal* out_val); +static bool const_eval(Cuik_Parser* restrict parser, TokenStream* tokens, Cuik_Expr* e, Cuik_ConstVal* out_val); enum { CONST_ERROR = -2 }; -// -1 for error -static ptrdiff_t const_eval_subexpr(Cuik_Parser* restrict parser, Cuik_QualType* types, Subexpr* exprs, ptrdiff_t i, Cuik_ConstVal* res) { +static ptrdiff_t const_eval_subexpr(Cuik_Parser* restrict parser, TokenStream* tokens, Cuik_QualType* types, Subexpr* exprs, ptrdiff_t i, Cuik_ConstVal* res) { assert(i >= 0); Subexpr* s = &exprs[i]; @@ -31,11 +30,11 @@ static ptrdiff_t const_eval_subexpr(Cuik_Parser* restrict parser, Cuik_QualType* case EXPR_SIZEOF_T: { Cuik_Type* src = cuik_canonical_type(s->x_of_type.type); if (src->size == 0) { - type_layout2(parser, &parser->tokens, src); + type_layout2(parser, tokens, src); if (src->size == 0) { - diag_err(&parser->tokens, s->loc, "Could not resolve type"); - return -1; + diag_err(tokens, s->loc, "Could not resolve type"); + return CONST_ERROR; } } @@ -45,7 +44,7 @@ static ptrdiff_t const_eval_subexpr(Cuik_Parser* restrict parser, Cuik_QualType* case EXPR_ENUM: { if (s->enum_val.num->lexer_pos != 0) { - type_layout2(parser, &parser->tokens, cuik_canonical_type(s->enum_val.type)); + type_layout2(parser, tokens, cuik_canonical_type(s->enum_val.type)); } *res = (Cuik_ConstVal){ CUIK_CONST_INT, .i = s->enum_val.num->value }; @@ -54,7 +53,7 @@ static ptrdiff_t const_eval_subexpr(Cuik_Parser* restrict parser, Cuik_QualType* case EXPR_CAST: { Cuik_ConstVal src; - i = const_eval_subexpr(parser, types, exprs, i - 1, &src); + i = const_eval_subexpr(parser, tokens, types, exprs, i - 1, &src); if (i == CONST_ERROR) return i; assert(src.tag == CUIK_CONST_INT); @@ -65,75 +64,109 @@ static ptrdiff_t const_eval_subexpr(Cuik_Parser* restrict parser, Cuik_QualType* i -= 1; // find base (just skip arrow or dot) - Subexpr* base = &exprs[i]; - if (base->op == EXPR_DOT || base->op == EXPR_ARROW) { - base -= 1; - } + /* if (exprs[i].op == EXPR_DOT || exprs[i].op == EXPR_ARROW) { + i -= 1; + } */ Cuik_Type* t = NULL; - if (base->op == EXPR_CAST) { - t = cuik_canonical_type(base->cast.type); - base -= 1; - if (base->op == EXPR_INT) { - // (T*) 0 - *res = (Cuik_ConstVal){ CUIK_CONST_INT, .i = base->int_lit.lit }; - } else if (base->op == EXPR_SYMBOL) { - *res = (Cuik_ConstVal){ CUIK_CONST_ADDR, .s = { base - exprs, 0 } }; - } else { - diag_err(&parser->tokens, s->loc, "Cannot evaluate address as constant"); - return CONST_ERROR; - } + if (exprs[i].op == EXPR_CAST) { + t = cuik_canonical_type(exprs[i].cast.type); + i -= 1; } ptrdiff_t offset = 0; - Subexpr* s = &exprs[i]; - if (s->op == EXPR_ARROW) { - // &(a->b) A -> & - if (t == NULL) { - diag_err(&parser->tokens, s->loc, "Unknown type, cannot get member: %s", s->dot_arrow.name); - return CONST_ERROR; - } + while (exprs[i].op == EXPR_ARROW || exprs[i].op == EXPR_DOT_R || exprs[i].op == EXPR_SUBSCRIPT) { + Subexpr* s = &exprs[i]; + + if (exprs[i].op == EXPR_DOT_R) { + offset += exprs[i].dot_arrow.offset; + i -= 1; + } else if (exprs[i].op == EXPR_ARROW) { + // &(a->b) A -> & + if (t == NULL) { + diag_err(tokens, s->loc, "Unknown type, cannot get member: %s", s->dot_arrow.name); + return CONST_ERROR; + } - if (cuik_type_can_deref(t)) { - t = cuik_canonical_type(t->ptr_to); - } else { - diag_err(&parser->tokens, s->loc, "Expected pointer (or array) for arrow"); - return CONST_ERROR; - } + if (cuik_type_can_deref(t)) { + t = cuik_canonical_type(t->ptr_to); + } else { + diag_err(tokens, s->loc, "Expected pointer (or array) for arrow"); + return CONST_ERROR; + } - // force this expression's type to resolve - if (t->size == 0) { - type_layout2(parser, &parser->tokens, t); - } + // force this expression's type to resolve + if (t->size == 0) { + type_layout2(parser, tokens, t); + } + + uint32_t member_offset = 0; + Member* member = sema_traverse_members(t, s->dot_arrow.name, &member_offset); + if (member == NULL) { + diag_err(tokens, s->loc, "Unknown member: %s", s->dot_arrow.name); + return CONST_ERROR; + } + + offset += member_offset; + i -= 1; + } else if (exprs[i].op == EXPR_SUBSCRIPT) { + t = cuik_canonical_type(types[i]); + + if (t == NULL) { + diag_err(tokens, s->loc, "Unknown type, cannot get member: %s", s->dot_arrow.name); + return CONST_ERROR; + } + + // force this expression's type to resolve + if (t->size == 0) { + type_layout2(parser, tokens, t); + } + + Cuik_ConstVal idx; + i = const_eval_subexpr(parser, tokens, types, exprs, i - 1, &idx); + if (i == CONST_ERROR) return i; + + if (idx.tag != CUIK_CONST_INT) { + diag_err(tokens, s->loc, "Array index wasn't an integer"); + return CONST_ERROR; + } - uint32_t member_offset = 0; - Member* member = sema_traverse_members(t, s->dot_arrow.name, &member_offset); - if (member == NULL) { - diag_err(&parser->tokens, s->loc, "Unknown member: %s", s->dot_arrow.name); + offset += idx.i * t->size; + } else { + diag_err(tokens, s->loc, "TODO"); return CONST_ERROR; } + } - offset += member_offset; - i -= 1; + if (exprs[i].op == EXPR_INT) { + // (T*) 0 + *res = (Cuik_ConstVal){ CUIK_CONST_INT, .i = exprs[i].int_lit.lit }; + } else if (exprs[i].op == EXPR_SYMBOL) { + *res = (Cuik_ConstVal){ CUIK_CONST_ADDR, .s = { exprs[i].sym.stmt, 0 } }; + } else { + diag_err(tokens, s->loc, "Cannot evaluate address as constant"); + return CONST_ERROR; } if (res->tag == CUIK_CONST_ADDR) { res->s.offset += offset; - } else { - assert(res->tag == CUIK_CONST_INT); + } else if (res->tag == CUIK_CONST_INT) { res->i += offset; + } else { + diag_err(tokens, s->loc, "Cannot evaluate address as constant"); + return CONST_ERROR; } - return (base - exprs) - 1; + return i - 1; } case EXPR_SYMBOL: { Stmt* sym = s->sym.stmt; if (!cuik_type_implicit_ptr(cuik_canonical_type(sym->decl.type))) { - diag_err(&parser->tokens, s->loc, "Cannot evaluate address as constant"); + diag_err(tokens, s->loc, "Cannot evaluate address as constant"); return CONST_ERROR; } - *res = (Cuik_ConstVal){ CUIK_CONST_ADDR, .s = { i, 0 } }; + *res = (Cuik_ConstVal){ CUIK_CONST_ADDR, .s = { exprs[i].sym.stmt, 0 } }; return i - 1; } default: break; @@ -142,11 +175,11 @@ static ptrdiff_t const_eval_subexpr(Cuik_Parser* restrict parser, Cuik_QualType* // try unary operators if (s->op == EXPR_NOT || s->op == EXPR_NEGATE) { Cuik_ConstVal src; + Cuik_Type* ty = types ? cuik_canonical_type(types[i - 1]) : NULL; - i = const_eval_subexpr(parser, types, exprs, i - 1, &src); + i = const_eval_subexpr(parser, tokens, types, exprs, i - 1, &src); if (i == CONST_ERROR) return i; - Cuik_Type* ty = types ? cuik_canonical_type(types[i]) : NULL; if (ty && cuik_type_is_float(ty)) { assert(s->op == EXPR_NEGATE && "expected negate"); @@ -170,9 +203,9 @@ static ptrdiff_t const_eval_subexpr(Cuik_Parser* restrict parser, Cuik_QualType* if (s->op >= EXPR_PLUS && s->op <= EXPR_CMPLT) { Cuik_ConstVal rhs, lhs; - i = const_eval_subexpr(parser, types, exprs, i - 1, &rhs); + i = const_eval_subexpr(parser, tokens, types, exprs, i - 1, &rhs); if (i == CONST_ERROR) return i; - i = const_eval_subexpr(parser, types, exprs, i, &lhs); + i = const_eval_subexpr(parser, tokens, types, exprs, i, &lhs); if (i == CONST_ERROR) return i; Cuik_Type* ty = types ? cuik_canonical_type(types[i]) : NULL; @@ -229,17 +262,17 @@ static ptrdiff_t const_eval_subexpr(Cuik_Parser* restrict parser, Cuik_QualType* if (s->op == EXPR_TERNARY) { Cuik_ConstVal src; - i = const_eval_subexpr(parser, types, exprs, i - 1, &src); + i = const_eval_subexpr(parser, tokens, types, exprs, i - 1, &src); if (i == CONST_ERROR) return i; if (src.tag != CUIK_CONST_INT) { - diag_err(&parser->tokens, s->loc, "Ternary condition must be int"); + diag_err(tokens, s->loc, "Ternary condition must be int"); return CONST_ERROR; } Cuik_ConstVal v; - if (!const_eval(parser, src.i ? s->ternary.left : s->ternary.right, &v)) { - diag_err(&parser->tokens, s->loc, "Cannot fold ternary"); + if (!const_eval(parser, tokens, src.i ? s->ternary.left : s->ternary.right, &v)) { + diag_err(tokens, s->loc, "Cannot fold ternary"); return CONST_ERROR; } @@ -247,7 +280,7 @@ static ptrdiff_t const_eval_subexpr(Cuik_Parser* restrict parser, Cuik_QualType* return i; } - diag_err(parser ? &parser->tokens : NULL, s->loc, "could not parse subexpression '%s' as constant.", cuik_get_expr_name(s)); + diag_err(tokens, s->loc, "could not parse subexpression '%s' as constant.", cuik_get_expr_name(s)); return CONST_ERROR; } @@ -277,8 +310,7 @@ static bool const_eval_addr_single(Cuik_Parser* restrict parser, Cuik_Expr* e, S return false; } - Subexpr* s = &e->exprs[args[0].s.base]; - Stmt* sym = s->sym.stmt; + Stmt* sym = args[0].s.base; if (cuik_canonical_type(sym->decl.type)->size == 0) { type_layout2(parser, &parser->tokens, cuik_canonical_type(sym->decl.type)); @@ -308,8 +340,8 @@ static bool const_eval_addr_single(Cuik_Parser* restrict parser, Cuik_Expr* e, S } // does constant eval on integer values, if it ever fails it'll exit with false -static bool const_eval(Cuik_Parser* restrict parser, Cuik_Expr* e, Cuik_ConstVal* out_val) { - return const_eval_subexpr(parser, e->types, e->exprs, e->count - 1, out_val) != CONST_ERROR; +static bool const_eval(Cuik_Parser* restrict parser, TokenStream* tokens, Cuik_Expr* e, Cuik_ConstVal* out_val) { + return const_eval_subexpr(parser, tokens, e->types, e->exprs, e->count - 1, out_val) != CONST_ERROR; #if 0 size_t top = 0; diff --git a/cuik_c/expr_parser.h b/cuik_c/expr_parser.h index 701de0d4..f154003a 100644 --- a/cuik_c/expr_parser.h +++ b/cuik_c/expr_parser.h @@ -1096,7 +1096,7 @@ static intmax_t parse_const_expr(Cuik_Parser* parser, TokenStream* restrict s) { Cuik_Expr* e = complete_expr(parser); Cuik_ConstVal value; - if (!const_eval(parser, e, &value)) { + if (!const_eval(parser, &parser->tokens, e, &value)) { // the const_eval_int will handle errors return 0; } diff --git a/cuik_c/ir_gen.c b/cuik_c/ir_gen.c index b35a7c77..c1a85549 100644 --- a/cuik_c/ir_gen.c +++ b/cuik_c/ir_gen.c @@ -388,7 +388,9 @@ int count_max_tb_init_objects(InitNode* root_node) { int sum = root_node->kids_count; for (InitNode* k = root_node->kid; k != NULL; k = k->next) { sum += count_max_tb_init_objects(k); - if (k->expr && get_root_subexpr(k->expr)->op == EXPR_ADDR) sum += 1; + if (k->expr && get_root_subexpr(k->expr)->op == EXPR_CONST && get_root_subexpr(k->expr)->const_val.tag == CUIK_CONST_ADDR) { + sum += 1; + } } return sum; @@ -484,52 +486,47 @@ static void gen_global_initializer(TranslationUnit* tu, TB_Global* g, Cuik_Type* } // try to emit constant integer + constant addresses - Cuik_ConstVal value; - if (const_eval(NULL, e, &value)) { - uint64_t int_form = 0; - if (value.tag == CUIK_CONST_ADDR) { - Stmt* stmt = e->exprs[value.s.base].sym.stmt; - assert((stmt->op == STMT_GLOBAL_DECL || stmt->op == STMT_FUNC_DECL) && "could not resolve as constant initializer"); - - tb_global_add_symbol_reloc(tu->ir_mod, g, offset, stmt->backing.s); - int_form = value.s.offset; - } else if (value.tag == CUIK_CONST_INT) { - int_form = value.i; - } else if (value.tag == CUIK_CONST_FLOAT) { - Cuik_TypeKind kind = cuik_canonical_type(e->cast_types[e->count - 1])->kind; - if (kind == KIND_DOUBLE) { - typedef union { double f; uint64_t u; } F64U64; - int_form = (F64U64){ value.f }.u; - } else if (kind == KIND_FLOAT) { - typedef union { float f; uint32_t u; } F32U32; - int_form = (F32U32){ value.f }.u; - } else { - assert(0 && "TODO"); - } + assert(s->op == EXPR_CONST); + + Cuik_ConstVal value = s->const_val; + uint64_t int_form = 0; + if (value.tag == CUIK_CONST_ADDR) { + Stmt* stmt = value.s.base; + assert((stmt->op == STMT_GLOBAL_DECL || stmt->op == STMT_FUNC_DECL) && "could not resolve as constant initializer"); + + tb_global_add_symbol_reloc(tu->ir_mod, g, offset, stmt->backing.s); + int_form = value.s.offset; + } else if (value.tag == CUIK_CONST_INT) { + int_form = value.i; + } else if (value.tag == CUIK_CONST_FLOAT) { + Cuik_TypeKind kind = cuik_canonical_type(e->cast_types[e->count - 1])->kind; + if (kind == KIND_DOUBLE) { + typedef union { double f; uint64_t u; } F64U64; + int_form = (F64U64){ value.f }.u; + } else if (kind == KIND_FLOAT) { + typedef union { float f; uint32_t u; } F32U32; + int_form = (F32U32){ value.f }.u; } else { assert(0 && "TODO"); } + } else { + assert(0 && "TODO"); + } - if (int_form != 0) { - uint8_t* region = tb_global_add_region(tu->ir_mod, g, offset, type_size); - - if (TARGET_NEEDS_BYTESWAP(tu->target)) { - // reverse copy - uint8_t* src = (uint8_t*) &int_form; - size_t top = type_size - 1; + if (int_form != 0) { + uint8_t* region = tb_global_add_region(tu->ir_mod, g, offset, type_size); + if (TARGET_NEEDS_BYTESWAP(tu->target)) { + // reverse copy + uint8_t* src = (uint8_t*) &int_form; + size_t top = type_size - 1; - for (size_t i = 0; i < type_size; i++) { - region[i] = src[top - i]; - } - } else { - memcpy(region, &int_form, type->size); + for (size_t i = 0; i < type_size; i++) { + region[i] = src[top - i]; } + } else { + memcpy(region, &int_form, type->size); } - return; } - - fprintf(stderr, "internal compiler error: cannot compile global initializer as constant (%s).\n", tu->filepath); - abort(); } static void eval_global_initializer(TranslationUnit* tu, TB_Global* g, InitNode* n, int offset) { diff --git a/cuik_c/ir_gen2.c b/cuik_c/ir_gen2.c index 65acc824..7ac5424b 100644 --- a/cuik_c/ir_gen2.c +++ b/cuik_c/ir_gen2.c @@ -409,6 +409,10 @@ static ValDesc cg_subexpr(TranslationUnit* tu, TB_GraphBuilder* g, Subexpr* e, C assert(stmt->backing.s != NULL); return (ValDesc){ LVALUE, .n = tb_builder_symbol(g, stmt->backing.s) }; } else { + if (stmt->backing.n == NULL) { + stmt->backing.n = tb_builder_label_make2(g, tb_builder_label_get(g), true); + } + return (ValDesc){ LVALUE, .mem_var = stmt->decl.local_ordinal, .n = stmt->backing.n }; } } @@ -570,7 +574,7 @@ static ValDesc cg_subexpr(TranslationUnit* tu, TB_GraphBuilder* g, Subexpr* e, C default: TODO(); } } else { - bool is_signed = type->is_unsigned; + bool is_signed = !type->is_unsigned; if (type->kind == KIND_PTR) { is_signed = false; } switch (e->op) { @@ -816,6 +820,11 @@ static ValDesc cg_subexpr(TranslationUnit* tu, TB_GraphBuilder* g, Subexpr* e, C return (ValDesc){ RVALUE, .n = tb_builder_phi(g, 2, vals) }; } case EXPR_NOT: { + if (cuik_canonical_type(qt)->kind == KIND_BOOL) { + TB_Node* src = as_rval(tu, g, &args[0]); + return (ValDesc){ RVALUE, .n = tb_builder_cmp(g, TB_CMP_NE, src, tb_builder_uint(g, src->dt, 0)) }; + } + return (ValDesc){ RVALUE, .n = tb_builder_not(g, as_rval(tu, g, &args[0])) }; } case EXPR_NEGATE: { @@ -906,7 +915,7 @@ static ValDesc cg_subexpr(TranslationUnit* tu, TB_GraphBuilder* g, Subexpr* e, C TB_Node* dst = as_rval(tu, g, &args[1]); TB_Node* src = as_rval(tu, g, &args[2]); int order = get_memory_order_val(as_rval(tu, g, &args[3])); - src = tb_builder_unary(g, TB_NEG, src); + src = tb_builder_neg(g, src); return (ValDesc){ RVALUE, .n = tb_builder_atomic_rmw(g, 0, TB_ATOMIC_ADD, dst, src, order) }; } else { // TB_Node* val = tu->target->compile_builtin(tu, g, name, arg_count, args); @@ -1190,6 +1199,35 @@ static void cg_stmt(TranslationUnit* tu, TB_GraphBuilder* g, Stmt* restrict s) { break; } + case STMT_LABEL: { + if (s->backing.n == NULL) { + TB_Node* dst = tb_builder_label_make2(g, tb_builder_label_get(g), true); + s->backing.n = dst; + + emit_loc(tu, g, s->loc.start); + } + + // fallthru + if (tb_builder_label_get(g) != NULL) { + tb_builder_br(g, s->backing.n); + } + + // we wanna keep the OG symbol table around for jumping to the label + tb_builder_label_set(g, tb_builder_label_clone(g, s->backing.n)); + break; + } + + case STMT_GOTO: { + ValDesc v = cg_expr(tu, g, s->goto_.target); + if (v.kind == LVALUE) { + tb_builder_br(g, v.n); + } else { + // TODO(NeGate): Handle computed goto case + assert(0 && "todo: computed goto"); + } + break; + } + case STMT_COMPOUND: { Stmt** kids = s->compound.kids; size_t count = s->compound.kids_count; @@ -1366,7 +1404,6 @@ static void cg_stmt(TranslationUnit* tu, TB_GraphBuilder* g, Stmt* restrict s) { tb_builder_label_kill(g, paths[0]); } tb_builder_label_kill(g, loop); - tb_builder_label_complete(g, header); tb_builder_label_kill(g, header); tb_builder_label_set(g, exit); @@ -1417,8 +1454,9 @@ static void cg_stmt(TranslationUnit* tu, TB_GraphBuilder* g, Stmt* restrict s) { TB_Node* exit = tb_builder_label_make(g); TB_Node* header = tb_builder_loop(g); TB_Node* loop = tb_builder_label_clone(g, header); + TB_Node* next = tb_builder_label_make(g); - s->backing.loop[0] = loop; + s->backing.loop[0] = next; s->backing.loop[1] = exit; { @@ -1433,12 +1471,21 @@ static void cg_stmt(TranslationUnit* tu, TB_GraphBuilder* g, Stmt* restrict s) { // loop body tb_builder_label_set(g, paths[0]); cg_stmt(tu, g, s->for_.body); - if (s->for_.next) { - cg_expr(tu, g, s->for_.next); + // fallthru to next label + if (tb_builder_label_get(g) != NULL) { + tb_builder_br(g, next); + } + tb_builder_label_complete(g, next); + tb_builder_label_set(g, next); + if (tb_builder_label_get(g) != NULL) { + if (s->for_.next) { + cg_expr(tu, g, s->for_.next); + } } tb_builder_br(g, header); tb_builder_label_kill(g, paths[0]); } + tb_builder_label_kill(g, next); tb_builder_label_kill(g, loop); tb_builder_label_complete(g, header); tb_builder_label_kill(g, header); @@ -1659,7 +1706,7 @@ TB_Symbol* cuikcg_top_level(TranslationUnit* restrict tu, TB_Module* m, Stmt* re if (initial == NULL) { tb_global_set_storage(tu->ir_mod, section, (TB_Global*) s->backing.s, type->size, type->align, 0); return s->backing.s; - } else if (initial->op == EXPR_ADDR) { + } else if (initial->op == EXPR_CONST && initial->const_val.tag == CUIK_CONST_ADDR) { max_tb_objects = 2; } else if (initial->op == EXPR_INITIALIZER) { max_tb_objects = count_max_tb_init_objects(initial->init.root); diff --git a/cuik_c/sema.c b/cuik_c/sema.c index 21ec95bb..2a10693b 100644 --- a/cuik_c/sema.c +++ b/cuik_c/sema.c @@ -3,6 +3,7 @@ #include "targets/targets.h" thread_local Stmt* cuik__sema_function_stmt; +static thread_local bool inside_static_decl; void sema_stmt(TranslationUnit* tu, Stmt* restrict s); @@ -321,7 +322,7 @@ static InitSearchResult get_next_member_in_type(Cuik_Type* type, int target, int return (InitSearchResult){ 0 }; } -static int walk_initializer_layer(TranslationUnit* tu, Cuik_Type* parent, int base_offset, int bounds /* max slots to fill */, InitNode* node, int* cursor, int* max_cursor) { +static int walk_initializer_layer(TranslationUnit* tu, Cuik_Type* parent, int base_offset, int bounds /* max slots to fill */, InitNode* node, int* cursor, int* max_cursor, bool is_const_init) { //////////////////////////////// // manage any selectors //////////////////////////////// @@ -420,21 +421,19 @@ static int walk_initializer_layer(TranslationUnit* tu, Cuik_Type* parent, int ba // ^^^^^ // this would be the array if (type->kind == KIND_ARRAY) { - if (e != NULL) { - if (e->op == EXPR_STR || e->op == EXPR_WSTR) { - if (expr_type->kind == KIND_ARRAY && type->kind == KIND_ARRAY && - type_equal(cuik_canonical_type(expr_type->array.of), cuik_canonical_type(type->array.of))) { - // check if it fits properly - if (expr_type->array.count == type->array.count + 1) { - // we chop off the null terminator - e->str.end -= (e->op == EXPR_STR ? 1 : 2); - expr_type->array.count = type->array.count; - } else if (expr_type->array.count > type->array.count) { - diag_err(&tu->tokens, e->loc, "initializer-string too big for the initializer (%d elements out of %d)", expr_type->array.count, type->array.count); - } - } else { - diag_err(&tu->tokens, e->loc, "Could not use %sinitializer-string on array of %!T", (e->op == EXPR_WSTR) ? "wide " : "", cuik_canonical_type(type->array.of)); + if (e != NULL && (e->op == EXPR_STR || e->op == EXPR_WSTR)) { + if (expr_type->kind == KIND_ARRAY && type->kind == KIND_ARRAY && + type_equal(cuik_canonical_type(expr_type->array.of), cuik_canonical_type(type->array.of))) { + // check if it fits properly + if (expr_type->array.count == type->array.count + 1) { + // we chop off the null terminator + e->str.end -= (e->op == EXPR_STR ? 1 : 2); + expr_type->array.count = type->array.count; + } else if (expr_type->array.count > type->array.count) { + diag_err(&tu->tokens, e->loc, "initializer-string too big for the initializer (%d elements out of %d)", expr_type->array.count, type->array.count); } + } else { + diag_err(&tu->tokens, e->loc, "Could not use %sinitializer-string on array of %!T", (e->op == EXPR_WSTR) ? "wide " : "", cuik_canonical_type(type->array.of)); } } } else { @@ -449,17 +448,31 @@ static int walk_initializer_layer(TranslationUnit* tu, Cuik_Type* parent, int ba (e->op == EXPR_WSTR && cuik_canonical_type(node->type)->kind == KIND_SHORT)) { // { "hello" } can be used when the initializer is an array because reasons cast_type = node->type = expr_qtype; - } else if (!(e->op == EXPR_INT && e->int_lit.lit == 0)) { - // zero is allowed for everything, so don't do the normal checks in that case - // - // it throws it's own errors and we don't really need - // any complex recovery for it since it'll exit at the - // end of type checking so it's not like the error will - // spread well - implicit_conversion(tu, cuik_uncanonical_type(expr_type), node->type, e); - cast_type = node->type; } else { - cast_type = node->type; + if (!(e->op == EXPR_INT && e->int_lit.lit == 0)) { + // zero is allowed for everything, so don't do the normal checks in that case + // + // it throws it's own errors and we don't really need + // any complex recovery for it since it'll exit at the + // end of type checking so it's not like the error will + // spread well + implicit_conversion(tu, cuik_uncanonical_type(expr_type), node->type, e); + cast_type = node->type; + } else { + cast_type = node->type; + } + + if (is_const_init) { + Cuik_ConstVal val; + if (const_eval(NULL, &tu->tokens, expr, &val)) { + expr->exprs[0] = *e; + expr->exprs[0].op = EXPR_CONST; + expr->exprs[0].const_val = val; + expr->count = 1; + + e = &expr->exprs[0]; + } + } } expr->cast_types[expr->count - 1] = cast_type; @@ -476,7 +489,7 @@ static int walk_initializer_layer(TranslationUnit* tu, Cuik_Type* parent, int ba for (size_t i = 0; i < node_count; i++) { assert(n != NULL); - walk_initializer_layer(tu, type, pos, member_count, n, &kid_cursor, &kid_max_cursor); + walk_initializer_layer(tu, type, pos, member_count, n, &kid_cursor, &kid_max_cursor, is_const_init); n = n->next; } } else if (type->kind == KIND_ARRAY) { @@ -484,7 +497,7 @@ static int walk_initializer_layer(TranslationUnit* tu, Cuik_Type* parent, int ba for (int i = 0; i < node_count; i++) { assert(n != NULL); - walk_initializer_layer(tu, type, pos, array_count, n, &kid_cursor, &kid_max_cursor); + walk_initializer_layer(tu, type, pos, array_count, n, &kid_cursor, &kid_max_cursor, is_const_init); n = n->next; } } else { @@ -494,7 +507,7 @@ static int walk_initializer_layer(TranslationUnit* tu, Cuik_Type* parent, int ba } // scalars - walk_initializer_layer(tu, type, pos, 1, node, &kid_cursor, &kid_max_cursor); + walk_initializer_layer(tu, type, pos, 1, node, &kid_cursor, &kid_max_cursor, is_const_init); } } @@ -526,12 +539,12 @@ static size_t sema_infer_initializer_array_count(TranslationUnit* tu, InitNode* return max; } -static void walk_initializer_for_sema(TranslationUnit* tu, Cuik_Type* type, InitNode* root, int base_offset) { +static void walk_initializer_for_sema(TranslationUnit* tu, Cuik_Type* type, InitNode* root, int base_offset, bool is_const_init) { InitNode* n = root->kid; int cursor = 0, max_cursor = 0, bounds = compute_initializer_bounds(type); while (n != NULL) { - walk_initializer_layer(tu, type, 0, bounds, n, &cursor, &max_cursor); + walk_initializer_layer(tu, type, 0, bounds, n, &cursor, &max_cursor, is_const_init); n = n->next; } @@ -849,6 +862,7 @@ Cuik_QualType cuik__sema_subexpr(TranslationUnit* tu, Cuik_Expr* restrict _, Sub if (type->kind == KIND_ARRAY) { if (type->size == 0 && (sym->op == STMT_GLOBAL_DECL || sym->op == STMT_DECL)) { sym->flags |= STMT_FLAGS_IS_RESOLVING; + printf("AAA %s\n", sym->decl.name); // try to resolve the type since it's incomplete sema_stmt(tu, sym); @@ -951,7 +965,7 @@ Cuik_QualType cuik__sema_subexpr(TranslationUnit* tu, Cuik_Expr* restrict _, Sub } } - walk_initializer_for_sema(tu, t, e->init.root, 0); + walk_initializer_for_sema(tu, t, e->init.root, 0, inside_static_decl); return e->init.type; } @@ -1734,7 +1748,9 @@ static void sema_top_level(TranslationUnit* tu, Stmt* restrict s) { e->init.type = s->decl.type; } + inside_static_decl = s->op == STMT_GLOBAL_DECL || (s->op == STMT_DECL && s->decl.attrs.is_static); Cuik_Type* expr_type = cuik_canonical_type(cuik__sema_expr(tu, s->decl.initial)); + inside_static_decl = false; if (e->op == EXPR_INITIALIZER || e->op == EXPR_STR || e->op == EXPR_WSTR) { if (type->kind == KIND_ARRAY && expr_type->kind == KIND_ARRAY) { @@ -1766,6 +1782,20 @@ static void sema_top_level(TranslationUnit* tu, Stmt* restrict s) { diag_note(&tu->tokens, type->loc, "type declared here"); } } + + if (s->decl.initial) { + Subexpr* root = get_root_subexpr(s->decl.initial); + if (root->op != EXPR_INITIALIZER && root->op != EXPR_STR && root->op != EXPR_WSTR) { + Cuik_ConstVal val; + if (const_eval(NULL, &tu->tokens, s->decl.initial, &val)) { + Cuik_Expr* e = s->decl.initial; + e->exprs[0] = *root; + e->exprs[0].op = EXPR_CONST; + e->exprs[0].const_val = val; + e->count = 1; + } + } + } break; } default: diff --git a/freestanding/limits.h b/freestanding/limits.h index 7719eb87..894bf8d4 100644 --- a/freestanding/limits.h +++ b/freestanding/limits.h @@ -13,11 +13,11 @@ #define SCHAR_MAX +0x7f #if defined(__CHAR_UNSIGNED__) || defined(_CHAR_UNSIGNED) - #define CHAR_MIN UCHAR_MIN - #define CHAR_MAX UCHAR_MAX +#define CHAR_MIN UCHAR_MIN +#define CHAR_MAX UCHAR_MAX #else - #define CHAR_MIN SCHAR_MIN - #define CHAR_MAX SCHAR_MAX +#define CHAR_MIN SCHAR_MIN +#define CHAR_MAX SCHAR_MAX #endif #define USHRT_WIDTH 16 @@ -33,17 +33,17 @@ #define INT_MAX +0x7fffffff #if defined(_WIN64) - #define ULONG_WIDTH 32 - #define LONG_WIDTH 32 - #define ULONG_MAX +0xffffffff - #define LONG_MIN -0x80000000 - #define LONG_MAX +0x7fffffff +#define ULONG_WIDTH 32 +#define LONG_WIDTH 32 +#define ULONG_MAX +0xffffffff +#define LONG_MIN -0x80000000 +#define LONG_MAX +0x7fffffff #else - #define ULONG_WIDTH 64 - #define LONG_WIDTH 64 - #define ULONG_MAX 0xffffffffffffffffull - #define LONG_MIN -0x8000000000000000ll - #define LONG_MAX +0x7fffffffffffffffll +#define ULONG_WIDTH 64 +#define LONG_WIDTH 64 +#define ULONG_MAX 0xffffffffffffffffull +#define LONG_MIN -0x8000000000000000ll +#define LONG_MAX +0x7fffffffffffffffll #endif #define ULLONG_WIDTH 64 @@ -70,3 +70,20 @@ #define WCHAR_WIDTH USHORT_WIDTH #define WCHAR_MIN USHORT_WIDTH #define WCHAR_MAX USHORT_WIDTH + +#define _I8_MIN (-127 - 1) +#define _I8_MAX 127 +#define _UI8_MAX 0xff + +#define _I16_MIN (-32767 - 1) +#define _I16_MAX 32767 +#define _UI16_MAX 0xffff + +#define _I32_MIN (-2147483647 - 1) +#define _I32_MAX 2147483647 +#define _UI32_MAX 0xffffffffu + +#define _I64_MIN (-9223372036854775807ll - 1) +#define _I64_MAX 9223372036854775807ll +#define _UI64_MAX 0xffffffffffffffffull + diff --git a/include/cuik_ast.h b/include/cuik_ast.h index 959a996e..1ff7c353 100644 --- a/include/cuik_ast.h +++ b/include/cuik_ast.h @@ -46,7 +46,7 @@ typedef struct { // symbols refer to their creator + an offset struct { - uint32_t base; + Stmt* base; int32_t offset; } s; }; @@ -413,6 +413,7 @@ typedef enum ExprOp { EXPR_VA_ARG, EXPR_INITIALIZER, + EXPR_CONST, // used for the resolved form of an const initializer EXPR_CAST, EXPR_PARAM, // special case of EXPR_VAR @@ -634,6 +635,8 @@ struct Subexpr { ptrdiff_t next_symbol; } sym; + Cuik_ConstVal const_val; + // EXPR_PARAM int param_num; diff --git a/include/tb.h b/include/tb.h index 132d616e..e5e00e21 100644 --- a/include/tb.h +++ b/include/tb.h @@ -370,7 +370,6 @@ typedef enum TB_NodeTypeEnum { TB_POPCNT, // Unary operations - TB_NEG, TB_FNEG, // Integer arithmatic @@ -449,8 +448,9 @@ typedef enum TB_NodeTypeEnum { // each family of machine nodes gets 256 nodes // first machine op, we have some generic ops here: - TB_MACH_X86 = TB_ARCH_X86_64 * 0x100, - TB_MACH_MIPS = TB_ARCH_MIPS32 * 0x100, + TB_MACH_X86 = TB_ARCH_X86_64 * 0x100, + TB_MACH_A64 = TB_ARCH_AARCH64 * 0x100, + TB_MACH_MIPS = TB_ARCH_MIPS32 * 0x100, } TB_NodeTypeEnum; typedef uint16_t TB_NodeType; static_assert(sizeof(TB_NODE_TYPE_MAX) < 0x100, "this is the bound where machine nodes start"); @@ -1421,7 +1421,7 @@ TB_API void tb_builder_set_var(TB_GraphBuilder* g, int id, TB_Node* v); // control flow primitives: // makes a region we can jump to (generally for forward jumps) TB_API TB_Node* tb_builder_label_make(TB_GraphBuilder* g); -TB_API TB_Node* tb_builder_label_make2(TB_GraphBuilder* g, TB_Node* label); +TB_API TB_Node* tb_builder_label_make2(TB_GraphBuilder* g, TB_Node* label, bool has_backward_jumps); // once a label is complete you can no longer insert jumps to it, the phis // are placed and you can then insert code into the label's body. TB_API void tb_builder_label_complete(TB_GraphBuilder* g, TB_Node* label); diff --git a/meta/x64_gen.c b/meta/x64_gen.c new file mode 100644 index 00000000..b8cb0e6b --- /dev/null +++ b/meta/x64_gen.c @@ -0,0 +1,53 @@ +// Metaprogram for generating x64 crap +#include + +static FILE* fp; + +typedef struct { + const char* name; + const char* extra; +} NodeInfo; + +static int node_info_count; +static NodeInfo node_infos[256]; + +void new_type(const char* name, const char* extra) { + node_infos[node_info_count++] = (NodeInfo){ name, extra }; +} + +int main(void) { + fp = fopen("tb/x64/x64_gen.inc", "wb"); + + fprintf(fp, "// Hello, World!\n"); + new_type("int3", NULL); + // standard integer ops + new_type("add", "X86MemOp"); + new_type("or", "X86MemOp"); + new_type("and", "X86MemOp"); + new_type("sub", "X86MemOp"); + new_type("xor", "X86MemOp"); + new_type("cmp", "X86MemOp"); + new_type("mov", "X86MemOp"); + new_type("test", "X86MemOp"); + // standard ops with immediate + + fprintf(fp, "typedef enum X86NodeType {\n"); + for (int i = 0; i < node_info_count; i++) { + fprintf(fp, " x86_%s,\n", node_infos[i].name); + } + fprintf(fp, "}\n\n"); + + fprintf(fp, "static size_t extra_bytes(TB_Node* n) {\n"); + fprintf(fp, " switch (n->type) {\n"); + for (int i = 0; i < node_info_count; i++) { + if (node_infos[i].extra != NULL) { + fprintf(fp, " case x86_%s: return sizeof(%s);\n", node_infos[i].name, node_infos[i].extra); + } + } + fprintf(fp, " default: return 0;\n"); + fprintf(fp, " }\n"); + fprintf(fp, "}\n\n"); + + fclose(fp); + return 0; +} diff --git a/tb/aarch64/aarch64_target.c b/tb/aarch64/aarch64_target.c index 4662a28a..8992326a 100644 --- a/tb/aarch64/aarch64_target.c +++ b/tb/aarch64/aarch64_target.c @@ -1,3 +1,4 @@ +#ifdef TB_HAS_AARCH64 #include "../emitter.h" #include "../tb_internal.h" #include "aarch64_emitter.h" @@ -435,6 +436,7 @@ ICodeGen tb__aarch64_codegen = { .emit_call_patches = emit_call_patches, .compile_function = compile_function, }; +#endif #if 0 #ifdef TB_HAS_AARCH64 @@ -683,4 +685,4 @@ ICodeGen tb__aarch64_codegen = { #else ICodeGen tb__aarch64_codegen; #endif -#endif +#endif \ No newline at end of file diff --git a/tb/briggs_ra.c b/tb/briggs_ra.c index d4e4c34c..27b5a7b6 100644 --- a/tb/briggs_ra.c +++ b/tb/briggs_ra.c @@ -37,7 +37,6 @@ typedef struct { int num_classes; int* num_regs; - int* fixed; int max_spills; DynArray(int) spills; @@ -168,11 +167,6 @@ static int ifg_ws_pop(IFG_Worklist* ws) { return vreg_id; } -static bool briggs_is_fixed(Ctx* ctx, Briggs* ra, int id) { - int class = ctx->vregs[id].mask->class; - return id >= ra->fixed[class] && id < ra->fixed[class] + ctx->num_regs[class]; -} - static void briggs_print_vreg(Ctx* restrict ctx, Briggs* restrict ra, VReg* vreg) { float cost = get_spill_cost(ctx, vreg); printf("# V%-4"PRIdPTR" deg=%d cost=%.2f ", vreg - ctx->vregs, ifg_degree(ra, vreg - ctx->vregs), cost); @@ -203,6 +197,86 @@ static void briggs_dump_sched(Ctx* restrict ctx, Briggs* restrict ra) { } } +// inserts spills and reloads that happen across blocks +static TB_Node* spill_fancy_xbb(Ctx* ctx, Briggs* ra, TB_DataType dt, int i, TB_Node* phi, TB_Node** pred_defs, bool* is_spilled, int def_class) { + TB_Function* f = ctx->f; + RegMask* spill_rm = intern_regmask(ctx, 0, true, 0); + RegMask* reload_rm = ctx->normie_mask[def_class]; + + TB_Node* bb_node = ctx->cfg.blocks[i].start; + int pred_count = bb_node->type == TB_PROJ && bb_node->inputs[0]->type == TB_ROOT ? 0 : bb_node->input_count; + + bool same = true; + TB_Node* leader = NULL; + FOR_N(j, 0, pred_count) { + TB_Node* pred = cfg_get_pred(&ctx->cfg, bb_node, j); + TB_ASSERT(pred->input_count != 0 && pred->type != TB_DEAD); + + TB_BasicBlock* pred_bb = f->scheduled[pred->gvn]; + int pred_id = pred_bb - ctx->cfg.blocks; + + TB_Node* pred_def = pred_defs[j]; + if (pred_def == NULL) { + continue; + } + + // RELOAD FROM P TO B IF: + // it's in a register in B's entry but not in P's exit + if (!is_spilled[i] && is_spilled[pred_id]) { + #if TB_OPTDEBUG_REGALLOC + printf(" reloaded in BB%d!\n", pred_id); + #endif + + TB_Node* v = tb_alloc_node(f, TB_MACH_COPY, dt, 2, sizeof(TB_NodeMachCopy)); + set_input(f, v, pred_defs[j], 1); + TB_NODE_SET_EXTRA(v, TB_NodeMachCopy, .def = reload_rm, .use = spill_rm); + + tb__insert_before(ctx, f, v, pred_bb->end); + pred_defs[j] = v; + } + // SPILL FROM P TO B IF: + // it's spilled in B's entry but not in P's exit and is in a register during + // the end of P. + else if (is_spilled[i] && !is_spilled[pred_id]) { + #if TB_OPTDEBUG_REGALLOC + printf(" spilled in BB%d!\n", pred_id); + #endif + + TB_Node* v = tb_alloc_node(f, TB_MACH_COPY, dt, 2, sizeof(TB_NodeMachCopy)); + set_input(f, v, pred_defs[j], 1); + TB_NODE_SET_EXTRA(v, TB_NodeMachCopy, .def = spill_rm, .use = reload_rm); + + tb__insert_before(ctx, f, v, pred_bb->end); + pred_defs[j] = v; + } + + printf(" DEF[%zu] %%%u\n", j, pred_def ? pred_def->gvn : 0); + + // are they all the same edge? + if (leader != phi) { + if (leader == NULL) { leader = pred_defs[j]; } + else if (leader != pred_defs[j]) { same = false; } + } + } + + if (same) { + return leader ? leader : phi; + } + + // construct phi + if (phi == NULL) { + phi = tb_alloc_node(f, TB_PHI, dt, 1 + pred_count, 0); + set_input(f, phi, bb_node, 0); + tb__insert_after(ctx, f, phi, bb_node); + } + + FOR_N(j, 0, pred_count) { + set_input(f, phi, pred_defs[j], j+1); + } + + return phi; +} + // Matthias Braun and Sebastian Hack "Register Spilling and Live-Range Splitting for SSA-Form Programs" (2009) // https://pp.ipd.kit.edu/uploads/publikationen/braun09cc.pdf static void spill_fancy(Ctx* ctx, Briggs* ra, int vreg_id) { @@ -216,18 +290,10 @@ static void spill_fancy(Ctx* ctx, Briggs* ra, int vreg_id) { to_spill->mask = ctx->constraint(ctx, spilled_n, NULL); to_spill->spill_cost = NAN; - bool* W_entry = tb_arena_alloc(ra->arena, ctx->bb_count); - bool* W_exit = tb_arena_alloc(ra->arena, ctx->bb_count); - bool* S_entry = tb_arena_alloc(ra->arena, ctx->bb_count); - bool* S_exit = tb_arena_alloc(ra->arena, ctx->bb_count); - memset(W_entry, 0, ctx->bb_count); - memset(W_exit, 0, ctx->bb_count); - memset(S_entry, 0, ctx->bb_count); - memset(S_exit, 0, ctx->bb_count); - TB_OPTDEBUG(REGALLOC)(printf("\x1b[33m# V%zu: spill (%%%u)\x1b[0m\n", to_spill - ctx->vregs, spilled_n->gvn)); briggs_dump_sched(ctx, ra); + __debugbreak(); ArenaArray(int)* df = tb_arena_alloc(ra->arena, ctx->bb_count * sizeof(ArenaArray(int))); { @@ -272,25 +338,32 @@ static void spill_fancy(Ctx* ctx, Briggs* ra, int vreg_id) { RegMask* spill_rm = intern_regmask(ctx, 0, true, 0); RegMask* reload_rm = ctx->normie_mask[def_class]; + bool* is_spilled = tb_arena_alloc(ra->arena, ctx->bb_count * sizeof(bool)); TB_Node** defs = tb_arena_alloc(ra->arena, ctx->bb_count * sizeof(TB_Node*)); + TB_Node** phis = tb_arena_alloc(ra->arena, ctx->bb_count * sizeof(TB_Node*)); + + // everything starts as dead and unspilled FOR_N(i, 0, ctx->bb_count) { defs[i] = NULL; + phis[i] = NULL; + is_spilled[i] = false; } - ArenaArray(int) ws = aarray_create(ra->arena, int, ctx->bb_count); - // we wanna first process the BBs in order, loops will - // place themselves for a round two where they'll place - // potentially a few extra spills & reloads. - FOR_N(i, 0, ctx->bb_count) { aarray_push(ws, i); } - //////////////////////////////// - // Pass 1: global MIN algo - //////////////////////////////// - // we'll decide & construct spills and reloads but they won't be - // fully hooked together just yet - for (size_t ws_i = 0; ws_i < aarray_length(ws); ws_i++) { - int i = ws[ws_i]; + // loops will have incomplete phis we'll wanna return to once the loop is + // done, to do that we just push the loop tail onto this stack and pop it + // later. + ArenaArray(int) loop_stack = aarray_create(ra->arena, int, ctx->bb_count); + + FOR_N(i, 0, ctx->bb_count) { + TB_BasicBlock* bb = &ctx->cfg.blocks[i]; + if (phis[i] != NULL) { + TB_Node* k = identity_phi(f, phis[i]); + if (k != phis[i]) { subsume_node(f, phis[i], k); } + } + } + + FOR_N(i, 0, ctx->bb_count) { TB_BasicBlock* bb = &ctx->cfg.blocks[i]; - bool second_round = ws_i >= ctx->bb_count; #if 0 aarray_for(i, bb->items) { @@ -302,37 +375,38 @@ static void spill_fancy(Ctx* ctx, Briggs* ra, int vreg_id) { // how many preds consider the value to be registers int freq = 0; - bool pred_S = false; - - bool is_hrp = ra->block_pressures[def_class][i].max >= ctx->num_regs[def_class]; int loop_tail = -1; TB_Node* bb_node = bb->start; int pred_count = bb_node->type == TB_PROJ && bb_node->inputs[0]->type == TB_ROOT ? 0 : bb_node->input_count; + TB_Node** pred_defs = tb_arena_alloc(ra->arena, pred_count * sizeof(TB_Node*)); + + bool is_hrp = ra->block_pressures[def_class][i].max >= ctx->num_regs[def_class]; FOR_N(j, 0, pred_count) { TB_Node* pred = cfg_get_pred(&ctx->cfg, bb_node, j); TB_ASSERT(pred->input_count != 0 && pred->type != TB_DEAD); TB_BasicBlock* pred_bb = f->scheduled[pred->gvn]; int pred_id = pred_bb - ctx->cfg.blocks; + + pred_defs[j] = defs[pred_id]; if (pred_id >= i && loop_tail < pred_id) { loop_tail = pred_id; continue; } - if (W_exit[pred_id]) { - freq++; - } - pred_S |= S_exit[pred_id]; + freq += !is_spilled[pred_id]; } const char* rg = ra->block_pressures[1][i].max >= 16 ? "HRP" : "LRP"; - printf("BB %d (freq=%f, preds=%d, %s): ", i, bb->freq, pred_count, rg); + printf("BB %zu (freq=%f, preds=%d, %s): ", i, bb->freq, pred_count, rg); FOR_SUCC(it, bb->end) { TB_BasicBlock* succ_bb = nl_map_get_checked(ctx->cfg.node_to_block, it.succ); printf(" BB%-3zu", succ_bb - ctx->cfg.blocks); } printf("\n"); + TB_Node* phi = NULL; + // if we're a loop we wanna consider ourselves an HRP if *ANY* blocks are HRP // within the body. if (loop_tail >= 0) { @@ -341,239 +415,111 @@ static void spill_fancy(Ctx* ctx, Briggs* ra, int vreg_id) { } if (is_hrp) { - TB_OPTDEBUG(REGALLOC2)(printf(" we're an HRP loop!\n")); - W_entry[i] = false; + TB_OPTDEBUG(REGALLOC2)(printf(" we crossed an HRP loop!\n")); + is_spilled[i] = true; } - if (!second_round) { - // since loops haven't processed all their inputs - // we do a second pass which will - aarray_push(ws, i); - } + // all loops need phis because we don't know what we'll do in the body yet + phis[i] = tb_alloc_node(f, TB_PHI, spilled_n->dt, 1 + pred_count, 0); + set_input(f, phis[i], bb_node, 0); + tb__insert_after(ctx, f, phis[i], bb_node); + + // push both head & tail, we'll fill the phis later + aarray_push(loop_stack, i); + aarray_push(loop_stack, loop_tail); } else if (pred_count > 0) { // if none of our predecessors want it in a reg, we don't either... yet? if (freq == 0) { TB_OPTDEBUG(REGALLOC2)(printf(" our preds didn't put it in regs!\n")); - W_entry[i] = false; + is_spilled[i] = true; } // we can't fit the value in regs right now (i mean unless we already have :p) else if (is_hrp && freq != pred_count) { TB_OPTDEBUG(REGALLOC2)(printf(" we crossed the HRP on entry!\n")); - W_entry[i] = false; + is_spilled[i] = true; } else { - W_entry[i] = true; + is_spilled[i] = false; } } - // just carry through unless we cross an HRP or a use of the spilled node - W_exit[i] = W_entry[i]; - S_entry[i] = pred_S && W_entry[i]; + // we can resolve the phi now + if (loop_tail < 0) { + defs[i] = spill_fancy_xbb(ctx, ra, spilled_n->dt, i, phis[i], pred_defs, is_spilled, def_class); + } else { + defs[i] = phis[i]; + } + tb_arena_free(ra->arena, pred_defs, pred_count * sizeof(TB_Node*)); - printf(" \x1b[32mW_entry=%d, S_entry=%d, pred_S=%d\x1b[0m\n", W_entry[i], S_entry[i], pred_S); + int loop_stack_len = aarray_length(loop_stack); + if (loop_stack_len && loop_stack[loop_stack_len - 1] == i) { + int head = loop_stack[loop_stack_len - 2]; + aarray_set_length(loop_stack, loop_stack_len - 2); - // placement of spills and reloads between blocks can - // only happen once we've fully resolved the block. - if (loop_tail < 0 || second_round) { - FOR_N(j, 0, pred_count) { - TB_Node* pred = cfg_get_pred(&ctx->cfg, bb_node, j); + printf(" COMPLETED LOOP BB%d!\n", head); + + TB_Node* loop_node = ctx->cfg.blocks[head].start; + TB_ASSERT(cfg_is_region(loop_node)); + + int loop_pred_count = loop_node->input_count; + TB_Node** loop_pred_defs = tb_arena_alloc(ra->arena, loop_pred_count * sizeof(TB_Node*)); + FOR_N(j, 0, loop_pred_count) { + TB_Node* pred = cfg_get_pred(&ctx->cfg, loop_node, j); TB_ASSERT(pred->input_count != 0 && pred->type != TB_DEAD); TB_BasicBlock* pred_bb = f->scheduled[pred->gvn]; - int pred_id = pred_bb - ctx->cfg.blocks; - TB_Node* pred_def = defs[pred_id]; - // RELOAD FROM P TO B IF: - // it's in a register in B's entry but not in P's exit - if (W_entry[i] && !W_exit[pred_id]) { - // TB_Node* v = tb_alloc_node(f, TB_MACH_COPY, spilled_n->dt, 2, sizeof(TB_NodeMachCopy)); - // set_input(f, v, pred_def, 1); - // TB_NODE_SET_EXTRA(v, TB_NodeMachCopy, .def = reload_rm, .use = spill_rm); - - #if TB_OPTDEBUG_REGALLOC - // printf(" reloaded before entry! %%%u\n", v->gvn); - printf(" reloaded in BB%d!\n", pred_id); - #endif + loop_pred_defs[j] = defs[pred_bb - ctx->cfg.blocks]; + } - // TB_BasicBlock* pred_bb = &ctx->cfg.blocks[preds[j]]; - // tb__insert_before(ctx, f, v, pred_bb->end); - continue; - } - // SPILL FROM P TO B IF: - // it's spilled in B's entry but not in P's exit and is in a register during - // the end of P. - if (S_entry[i] && !S_exit[pred_id] && W_exit[pred_id]) { - #if TB_OPTDEBUG_REGALLOC - printf(" spilled in BB%d!\n", pred_id); - #endif - } + // insert fully resolved phis now + TB_Node* p = spill_fancy_xbb(ctx, ra, spilled_n->dt, head, phis[head], loop_pred_defs, is_spilled, def_class); + if (p != phis[head]) { + // tb__remove_node(ctx, ctx->f, phis[head]); + // subsume_node(f, phis[head], p); } + tb_arena_free(ra->arena, loop_pred_defs, loop_pred_count * sizeof(TB_Node*)); } + printf(" \x1b[32mdef=%%%u, is_spilled=%d, freq=%d\x1b[0m\n", defs[i] ? defs[i]->gvn : 0, is_spilled[i], freq); - // modified version of the MIN algorithm - // if we cross LRP->HRP then we spill, use we're needed then we reload + // if we cross LRP->HRP then we spill, use we're needed then we reload for (size_t j = 0; j < aarray_length(bb->items); j++) { TB_Node* n = bb->items[j]; // uses of the value when spilled cause a reload - FOR_N(k, 1, n->input_count) { - if (!W_exit[i] && n->inputs[k] == spilled_n) { - TB_Node* v = tb_alloc_node(f, TB_MACH_COPY, spilled_n->dt, 2, sizeof(TB_NodeMachCopy)); - set_input(f, v, defs[i], 1); - TB_NODE_SET_EXTRA(v, TB_NodeMachCopy, .def = reload_rm, .use = spill_rm); - defs[i] = v; + if (is_spilled[i]) { + FOR_N(k, 1, n->input_count) { + if (n->inputs[k] == spilled_n) { + TB_Node* v = tb_alloc_node(f, TB_MACH_COPY, spilled_n->dt, 2, sizeof(TB_NodeMachCopy)); + set_input(f, v, defs[i], 1); + TB_NODE_SET_EXTRA(v, TB_NodeMachCopy, .def = reload_rm, .use = spill_rm); + + tb__insert_before(ctx, f, v, n); + defs[i] = v; - W_exit[i] = true; - S_exit[i] = true; - TB_OPTDEBUG(REGALLOC2)(printf(" we need to reload now! %%%u\n", v->gvn)); - break; + is_spilled[i] = false; + TB_OPTDEBUG(REGALLOC2)(printf(" we need to reload now! %%%u\n", v->gvn)); + break; + } } } - if (W_exit[i]) { + // "limit" can only spill spilled_n + if (!is_spilled[i]) { // if we hit an HRP, we must spill before that point if we haven't already. if (is_hrp || ra->block_pressures[def_class][i].lo2hi == j) { TB_Node* v = tb_alloc_node(f, TB_MACH_COPY, spilled_n->dt, 2, sizeof(TB_NodeMachCopy)); set_input(f, v, defs[i], 1); TB_NODE_SET_EXTRA(v, TB_NodeMachCopy, .def = spill_rm, .use = reload_rm); + + tb__insert_before(ctx, f, v, n); defs[i] = v; TB_OPTDEBUG(REGALLOC2)(printf(" onto stack now! (we've crossed an HRP region)\n")); - S_exit[i] = false; - W_exit[i] = false; + is_spilled[i] = true; } } if (n == spilled_n) { TB_OPTDEBUG(REGALLOC2)(printf(" in register! (just defined)\n")); - defs[i] = n; - W_exit[i] = true; - } - } - - printf(" \x1b[33mW_exit=%d, S_exit=%d\x1b[0m\n", W_exit[i], S_exit[i]); - } - - __debugbreak(); - - // everyone starts in the og register form - TB_Node** phis = tb_arena_alloc(ra->arena, ctx->bb_count * sizeof(TB_Node*)); - - static const char* NAMES[] = { "SPILLED", "REG" }; - // SSA reconstruction - FOR_N(i, 0, ctx->bb_count) { - TB_BasicBlock* bb = &ctx->cfg.blocks[i]; - - int depth = tb_ffs((int) bb->freq) - 1; - FOR_N(j, 0, depth) { printf(" "); } - printf("BB%zu (entry=%s, exit=%s):\n", i, NAMES[W_entry[i]], NAMES[W_exit[i]]); - - TB_Node* bb_node = bb->start; - int pred_count = bb_node->type == TB_PROJ && bb_node->inputs[0]->type == TB_ROOT ? 0 : bb_node->input_count; - int* preds = tb_arena_alloc(ra->arena, pred_count * sizeof(int)); - - FOR_N(j, 0, pred_count) { - TB_Node* pred = cfg_get_pred(&ctx->cfg, bb_node, j); - TB_ASSERT(pred->input_count != 0 && pred->type != TB_DEAD); - - TB_BasicBlock* pred_bb = f->scheduled[pred->gvn]; - preds[j] = pred_bb - ctx->cfg.blocks; - } - - FOR_N(j, 0, pred_count) { - TB_Node* pred_def = defs[preds[j]]; - // RELOAD FROM P TO B IF: - // it's in a register in B's entry but not in P's exit - if (W_entry[i] && !W_exit[preds[j]]) { - // TB_Node* v = tb_alloc_node(f, TB_MACH_COPY, spilled_n->dt, 2, sizeof(TB_NodeMachCopy)); - // set_input(f, v, pred_def, 1); - // TB_NODE_SET_EXTRA(v, TB_NodeMachCopy, .def = reload_rm, .use = spill_rm); - - #if TB_OPTDEBUG_REGALLOC - FOR_N(j, 0, depth) { printf(" "); } - // printf(" reloaded before entry! %%%u\n", v->gvn); - printf(" reloaded in BB%d!\n", preds[j]); - #endif - - // TB_BasicBlock* pred_bb = &ctx->cfg.blocks[preds[j]]; - // tb__insert_before(ctx, f, v, pred_bb->end); - continue; - } - // SPILL FROM P TO B IF: - // it's spilled in B's entry but not in P's exit and is in a register during - // the end of P. - if (S_entry[i] && !S_exit[preds[j]] && W_exit[preds[j]]) { - #if TB_OPTDEBUG_REGALLOC - FOR_N(j, 0, depth) { printf(" "); } - printf(" spilled in BB%d!\n", preds[j]); - #endif - } - - if (W_exit[preds[j]] != W_entry[i]) { - TB_Node* v = tb_alloc_node(f, TB_MACH_COPY, spilled_n->dt, 2, sizeof(TB_NodeMachCopy)); - set_input(f, v, pred_def, 1); - FOR_N(j, 0, depth) { printf(" "); } - if (W_entry[i]) { - // reg -> stack - TB_NODE_SET_EXTRA(v, TB_NodeMachCopy, .def = spill_rm, .use = reload_rm); - } else { - // stack -> reg - printf(" reloaded before entry! %%%u\n", v->gvn); - } - printf("AAA %%%u\n", bb->end->gvn); - defs[preds[j]] = v; - } - } - - if (pred_count > 0) { - TB_Node* phi = tb_alloc_node(f, TB_PHI, spilled_n->dt, 1 + pred_count, 0); - set_input(f, phi, bb_node, 0); - // printf(" inserted phi! %%%u\n", phi->gvn); - tb__insert_after(ctx, f, phi, bb_node); - phis[i] = defs[i] = phi; - } else { - phis[i] = NULL; - } - tb_arena_free(ra->arena, preds, pred_count * sizeof(int)); - - bool is_hrp = ra->block_pressures[def_class][i].max >= ctx->num_regs[def_class]; - bool in_stk = W_entry[i]; - for (size_t j = 0; j < aarray_length(bb->items); j++) { - TB_Node* n = bb->items[j]; - if (n->type == TB_PHI) { continue; } - if (!in_stk) { - // spill because we just hit the HRP region - if ((n == spilled_n && is_hrp) || ra->block_pressures[def_class][i].lo2hi == j) { - in_stk = true; - - TB_Node* v = tb_alloc_node(f, TB_MACH_COPY, spilled_n->dt, 2, sizeof(TB_NodeMachCopy)); - set_input(f, v, defs[i], 1); - TB_NODE_SET_EXTRA(v, TB_NodeMachCopy, .def = spill_rm, .use = reload_rm); - - tb__insert_before(ctx, f, v, n); - j++; - - FOR_N(j, 0, depth) { printf(" "); } - printf(" spilled during body! %%%u\n", v->gvn); - defs[i] = v; - continue; - } - } - // any uses will force a reload which means it'll be back in registers by - // the end of the block - FOR_N(k, 1, n->input_count) { - if (n->type != TB_PHI && n->inputs[k] == spilled_n) { - if (in_stk) { - in_stk = false; - TB_Node* v = tb_alloc_node(f, TB_MACH_COPY, spilled_n->dt, 2, sizeof(TB_NodeMachCopy)); - set_input(f, v, defs[i], 1); - TB_NODE_SET_EXTRA(v, TB_NodeMachCopy, .def = reload_rm, .use = spill_rm); - defs[i] = v; - - FOR_N(j, 0, depth) { printf(" "); } - printf(" reloaded during body! %%%u\n", v->gvn); - } - - FOR_N(j, 0, depth) { printf(" "); } - printf(" we use the value! %%%u[%zu]\n", n->gvn, k); - set_input(f, n, defs[i], k); - } + defs[i] = n; + is_spilled[i] = false; } } } @@ -581,35 +527,6 @@ static void spill_fancy(Ctx* ctx, Briggs* ra, int vreg_id) { briggs_dump_sched(ctx, ra); __debugbreak(); - #if 0 - FOR_N(i, 1, ctx->bb_count) { - TB_BasicBlock* bb = &ctx->cfg.blocks[i]; - - TB_Node* bb_node = bb->start; - int pred_count = bb_node->type == TB_PROJ && bb_node->inputs[0]->type == TB_ROOT ? 0 : bb_node->input_count; - - // stitch up the phis - TB_Node* phi = phis[i]; - FOR_N(j, 0, pred_count) { - TB_Node* pred = cfg_get_pred(&ctx->cfg, bb_node, j); - TB_ASSERT(pred->input_count != 0 && pred->type != TB_DEAD); - - TB_BasicBlock* pred_bb = f->scheduled[pred->gvn]; - set_input(f, phi, defs[pred_bb - ctx->cfg.blocks], 1 + j); - } - } - - FOR_N(i, 1, ctx->bb_count) { - TB_Node* k = identity_phi(f, phis[i]); - if (k != phis[i]) { - printf("ID %%%u\n", k->gvn); - - subsume_node(f, phis[i], k); - tb__remove_node(ctx, ctx->f, phis[i]); - } - } - #endif - #if 0 tb__insert_after(ctx, f, spill_n, n); VReg* spill_vreg = tb__set_node_vreg(ctx, spill_n); @@ -623,30 +540,13 @@ void tb__briggs(Ctx* restrict ctx, TB_Arena* arena) { Briggs ra = { .ctx = ctx, .arena = arena }; ra.spills = dyn_array_create(int, 32); - // creating fixed vregs which coalesce all fixed reg uses - // so i can more easily tell when things are asking for them. int max_regs_in_class = 0; CUIK_TIMED_BLOCK("pre-pass on fixed intervals") { - ra.fixed = tb_arena_alloc(arena, ctx->num_classes * sizeof(int)); - FOR_N(i, 0, ctx->num_classes) { size_t count = ctx->num_regs[i]; if (max_regs_in_class < count) { max_regs_in_class = count; } - - int base = aarray_length(ctx->vregs); - FOR_N(j, 0, count) { - RegMask* mask = intern_regmask(ctx, i, false, i == 0 ? j : 1ull << j); - aarray_push(ctx->vregs, (VReg){ - .class = i, - .assigned = j, - .mask = mask, - .spill_cost = INFINITY, - .uses = 1, - }); - } - ra.fixed[i] = base; } ra.num_regs = ctx->num_regs; assert(max_regs_in_class <= 64 && "TODO: we assume some 64bit masks in places lol"); @@ -686,17 +586,17 @@ void tb__briggs(Ctx* restrict ctx, TB_Arena* arena) { tmps->count = tmp_count; nl_table_put(&ctx->tmps_map, n, tmps); + TB_OPTDEBUG(REGALLOC)(printf("TMPS %%%u:\n", n->gvn)); FOR_N(k, in_count, in_count + tmp_count) { RegMask* in_mask = ins[k]; TB_ASSERT(in_mask != &TB_REG_EMPTY); - /* int fixed = fixed_reg_mask(in_mask); - if (fixed >= 0) { - // insert new range to the existing vreg - int vreg_id = tmps->elems[k - in_count] = ra.fixed[in_mask->class] + fixed; - ctx->vregs[vreg_id].uses += 1; - } else { - } */ + #if TB_OPTDEBUG_REGALLOC + printf(" V%u: ", aarray_length(ctx->vregs)); + tb__print_regmask(in_mask); + printf("\n"); + #endif + tmps->elems[k - in_count] = aarray_length(ctx->vregs); aarray_push(ctx->vregs, (VReg){ .mask = in_mask, .assigned = -1, .spill_cost = INFINITY, .uses = 1 }); } @@ -728,7 +628,7 @@ void tb__briggs(Ctx* restrict ctx, TB_Arena* arena) { // that's a lot of rounds... you sure we're making forward progress? rounds += 1; - TB_ASSERT(rounds < 10); + TB_ASSERT(rounds < 5); // build IFG CUIK_TIMED_BLOCK("IFG build") { @@ -821,7 +721,7 @@ void tb__briggs(Ctx* restrict ctx, TB_Arena* arena) { int mask_cap = stack_cap < max_regs_in_class ? max_regs_in_class : stack_cap; uint64_t* mask = tb_arena_alloc(arena, ((mask_cap+63)/64) * sizeof(uint64_t)); - int max_stack_usage = ctx->num_regs[REG_CLASS_STK]; + int num_spills = ctx->num_spills; cuikperf_region_start("select", NULL); dyn_array_clear(ra.spills); FOR_REV_N(i, 0, aarray_length(stk)) { @@ -838,12 +738,17 @@ void tb__briggs(Ctx* restrict ctx, TB_Arena* arena) { briggs_print_vreg(ctx, &ra, vreg); #endif - int def_class = vreg->mask->class; - int num_regs = def_class == REG_CLASS_STK ? stack_cap : ctx->num_regs[vreg->mask->class]; + RegMask* rm = vreg->mask; + int def_class = rm->class; + int num_regs = def_class == REG_CLASS_STK ? stack_cap : ctx->num_regs[rm->class]; size_t mask_word_count = (num_regs + 63) / 64; + TB_ASSERT(mask_word_count <= mask_cap); - FOR_N(j, 0, mask_word_count) { - mask[j] = 0; + // make sure it thinks the unusable regs are "in use" by someone else + FOR_N(j, 0, rm->count) { mask[j] = ~rm->mask[j]; } + FOR_N(j, rm->count, (ctx->num_regs[rm->class] + 63) / 64) { mask[j] = UINT64_MAX; } + if (ctx->num_regs[rm->class] % 64) { + mask[num_regs / 64] &= UINT64_MAX >> (64ull - (ctx->num_regs[rm->class] % 64)); } #if TB_OPTDEBUG_REGALLOC @@ -858,7 +763,7 @@ void tb__briggs(Ctx* restrict ctx, TB_Arena* arena) { mask[other_assigned / 64u] |= (1ull << (other_assigned % 64u)); #if 1 && TB_OPTDEBUG_REGALLOC - if (def_class != REG_CLASS_STK) { + if (def_class != 1) { continue; } printf("# MASK: 0x"); @@ -887,14 +792,17 @@ void tb__briggs(Ctx* restrict ctx, TB_Arena* arena) { } } - if (reg_assign(ctx, vreg, mask, num_regs)) { - // we need to know how much actual stack space we use - if (def_class == REG_CLASS_STK && max_stack_usage < vreg->assigned + 1) { - max_stack_usage = vreg->assigned + 1; + if (!reg_assign(ctx, vreg, mask, num_regs)) { + // if a stack slot failed to color then it means we + // need more stack slots (there's an indefinite amount :p) + if (def_class == REG_CLASS_STK) { + vreg->class = REG_CLASS_STK; + vreg->assigned = num_spills++; + + TB_OPTDEBUG(REGALLOC)(printf("# assigned to STACK%d (new stack slot)\n", vreg->assigned)); + } else { + dyn_array_put(ra.spills, s.vreg_id); } - } else { - TB_ASSERT_MSG(def_class != REG_CLASS_STK, "you fucked something up... bad"); - dyn_array_put(ra.spills, s.vreg_id); } } cuikperf_region_end(); @@ -905,7 +813,7 @@ void tb__briggs(Ctx* restrict ctx, TB_Arena* arena) { dyn_array_destroy(ra.spills); tb_arena_restore(arena, sp); - ctx->num_spills = max_stack_usage - (1 + ctx->param_count + ctx->call_usage); + ctx->num_spills = num_spills - (1 + ctx->param_count + ctx->call_usage); cuikperf_region_end(); break; } @@ -930,7 +838,21 @@ void tb__briggs(Ctx* restrict ctx, TB_Arena* arena) { if (can_remat(ctx, n)) { rematerialize(ctx, NULL, n); } else { - spill_fancy(ctx, &ra, vreg_id); + ctx->vregs[vreg_id].mask = ctx->constraint(ctx, n, NULL); + ctx->vregs[vreg_id].spill_cost = NAN; + + RegMask* spill_rm = intern_regmask(ctx, REG_CLASS_STK, true, 0); + TB_Node* spill_n = tb_alloc_node(f, TB_MACH_COPY, n->dt, 2, sizeof(TB_NodeMachCopy)); + subsume_node2(f, n, spill_n); + set_input(f, spill_n, n, 1); + TB_NODE_SET_EXTRA(spill_n, TB_NodeMachCopy, .def = spill_rm, .use = ctx->vregs[vreg_id].mask); + + tb__insert_after(ctx, f, spill_n, n); + VReg* spill_vreg = tb__set_node_vreg(ctx, spill_n); + spill_vreg->spill_cost = INFINITY; + spill_entire_lifetime(ctx, spill_vreg, spill_rm, false); + + // spill_fancy(ctx, &ra, vreg_id); } } cuikperf_region_end(); @@ -948,6 +870,7 @@ void tb__briggs(Ctx* restrict ctx, TB_Arena* arena) { // recompute liveness redo_dataflow(ctx, arena); + dump_sched(ctx); // time to retry dyn_array_clear(ra.spills); @@ -1045,36 +968,6 @@ static void interfere_live(Ctx* restrict ctx, Briggs* ra, uint32_t* live, int vr } } -static void interfere_mask(Ctx* restrict ctx, Briggs* ra, int vreg_id, RegMask* def_mask) { - // definition should interfere with each physical reg's node it doesn't intersect with - // such that it can't be seen alive in those registers. - if (reg_mask_is_not_empty(def_mask)) { - size_t reg_count = ctx->num_regs[def_mask->class]; - uint64_t word_count = (reg_count + 63) / 64; - FOR_N(i, 0, word_count) { - uint64_t bits = ~def_mask->mask[i]; - while (bits) { - int j = tb_ffs64(bits) - 1; - if (i*64 + j >= reg_count) { - return; - } - - int in_vreg_id = ra->fixed[def_mask->class] + i*64 + j; - - TB_ASSERT(in_vreg_id < aarray_length(ctx->vregs)); - ifg_edge(ra, in_vreg_id, vreg_id); - bits &= ~(1ull << j); - } - } - } else if (def_mask->class == REG_CLASS_STK) { - // if it's both empty and a stack slot, interfere with ALL the fixed stack slots - int base = ra->fixed[REG_CLASS_STK]; - FOR_N(i, 0, ctx->num_regs[REG_CLASS_STK]) { - ifg_edge(ra, base+i, vreg_id); - } - } -} - static void p_up(Briggs_Pressure* p, int pos) { if (++p->curr > p->max) { p->max = p->curr; @@ -1113,21 +1006,13 @@ static void ifg_build(Ctx* restrict ctx, Briggs* ra) { memset(ra->ifg[i], 0, set_size); } - // fixed vregs interfere with their fellow fixed vregs - FOR_N(i, 0, ctx->num_classes) { - int base = ra->fixed[i]; - FOR_N(j, 0, ctx->num_regs[i]) FOR_N(k, j + 1, ctx->num_regs[i]) { - ifg_edge(ra, base + k, base + j); - } - } - - size_t live_count = ((f->node_count + 63) / 32); + size_t live_count = ((f->node_count + 63) / 64) * 2; uint32_t* live = tb_arena_alloc(ra->arena, live_count * sizeof(uint32_t)); FOR_REV_N(i, 0, ctx->bb_count) { TB_BasicBlock* bb = &ctx->cfg.blocks[i]; - FOR_N(j, 0, (live_count + 1) / 2) { + FOR_N(j, 0, (bb->live_out.capacity + 63) / 64) { live[j*2 + 0] = bb->live_out.data[j] & 0xFFFFFFFF; live[j*2 + 1] = bb->live_out.data[j] >> 32ull; } @@ -1169,7 +1054,6 @@ static void ifg_build(Ctx* restrict ctx, Briggs* ra) { } interfere_live(ctx, ra, live, vreg_id); - interfere_mask(ctx, ra, vreg_id, vreg->mask); // 2 address ops will interfere with their own inputs (except for // shared dst/src) @@ -1199,7 +1083,6 @@ static void ifg_build(Ctx* restrict ctx, Briggs* ra) { FOR_N(k, 0, tmps->count) { RegMask* tmp_mask = ctx->vregs[tmps->elems[k]].mask; interfere_live(ctx, ra, live, tmps->elems[k]); - interfere_mask(ctx, ra, tmps->elems[k], tmp_mask); } } @@ -1375,20 +1258,6 @@ static bool ifg_coalesce(Ctx* restrict ctx, Briggs* ra, bool aggro) { ctx->vreg_map[i] = uf[ctx->vreg_map[i]]; } - // relocate the fixed regs, they couldn't be compacted so they should - // still be next to each other. - FOR_N(i, 0, ctx->num_classes) { - int base = ra->fixed[i]; - ra->fixed[i] = uf[base]; - - #if TB_OPTDEBUG_REGALLOC - size_t count = ctx->num_regs[i]; - FOR_N(j, 0, count) { - TB_ASSERT(uf[base] + j == uf[base + j]); - } - #endif - } - // relocate temporaries nl_table_for(it, &ctx->tmps_map) { Tmps* tmps = it->v; @@ -1409,7 +1278,7 @@ static bool ifg_coalesce(Ctx* restrict ctx, Briggs* ra, bool aggro) { static bool ifg_is_lo_degree(Ctx* ctx, Briggs* ra, int vreg_id) { RegMask* mask = ctx->vregs[vreg_id].mask; // note the stack has infinite colors so it never spills - return reg_mask_is_stack(mask) || ifg_degree(ra, vreg_id) < ctx->num_regs[mask->class]; + return mask->class == REG_CLASS_STK || ifg_degree(ra, vreg_id) < popcnt_reg_mask(mask); } static void ifg_remove(Briggs* ra, int i, int j) { diff --git a/tb/codegen.h b/tb/codegen.h index 6314e217..9570ac86 100644 --- a/tb/codegen.h +++ b/tb/codegen.h @@ -155,7 +155,6 @@ struct Ctx { // Basic blocks int bb_count; - TB_Node** rpo_nodes; // used when calling node_constraint since it needs an array, we // figure out the max input count of all nodes before allocating it. @@ -284,6 +283,14 @@ static bool reg_mask_is_stack(RegMask* mask) { return mask->class == REG_CLASS_STK; } +static int popcnt_reg_mask(RegMask* mask) { + int sum = 0; + FOR_N(i, 0, mask->count) { + sum += tb_popcount64(mask->mask[i]); + } + return sum; +} + static int fixed_reg_mask(RegMask* mask) { int set = -1; FOR_N(i, 0, mask->count) { diff --git a/tb/codegen_impl.h b/tb/codegen_impl.h index a34d9105..ac5dc5aa 100644 --- a/tb/codegen_impl.h +++ b/tb/codegen_impl.h @@ -83,7 +83,7 @@ static void flush_bundle(Ctx* restrict ctx, TB_CGEmitter* restrict e, Bundle* b) printf(" ========= BUNDLE (%d) =========\n", b->count); FOR_N(i, 0, b->count) { TB_Node* n = b->arr[i]; - int def_id = ctx->vreg_map[n->gvn]; + int def_id = n->gvn < aarray_length(ctx->vreg_map) ? ctx->vreg_map[n->gvn] : 0; VReg* vreg = def_id > 0 ? &ctx->vregs[def_id] : NULL; printf(" "), tb_print_dumb_node(NULL, n), printf("\n"); @@ -94,7 +94,7 @@ static void flush_bundle(Ctx* restrict ctx, TB_CGEmitter* restrict e, Bundle* b) FOR_N(j, 1, n->input_count) { TB_Node* in = n->inputs[j]; - int in_id = in ? ctx->vreg_map[in->gvn] : 0; + int in_id = in && in->gvn < aarray_length(ctx->vreg_map) ? ctx->vreg_map[in->gvn] : 0; if (in_id > 0) { VReg* other = &ctx->vregs[in_id]; printf(" IN[%zu] = %s:R%d\n", j, reg_class_name(other->class), other->assigned); @@ -650,11 +650,13 @@ static void compile_function(TB_Function* restrict f, TB_FunctionOutput* restric // TODO(NeGate): move the assembly output to code arena if (emit_asm) CUIK_TIMED_BLOCK("dissassembly") { - dump_stack_layout(&ctx, &ctx.emit); - + // dump_stack_layout(&ctx, &ctx.emit); dyn_array_for(i, ctx.debug_stack_slots) { TB_StackSlot* s = &ctx.debug_stack_slots[i]; - EMITA(&ctx.emit, "// %s = [rsp + %d]\n", s->name, s->storage.offset); + + TB_OPTDEBUG(ANSI)(EMITA(&ctx.emit, "\x1b[32m")); + EMITA(&ctx.emit, "// %s = [rsp + %d]\n", s->name, (ctx.stack_usage - ctx.stack_header) + s->storage.offset); + TB_OPTDEBUG(ANSI)(EMITA(&ctx.emit, "\x1b[0m")); } EMITA(&ctx.emit, "%s:\n", f->super.name); @@ -749,6 +751,7 @@ static void compile_function(TB_Function* restrict f, TB_FunctionOutput* restric func_out->code_size = ctx.emit.count; func_out->locations = ctx.locations; func_out->stack_slots = ctx.debug_stack_slots; + func_out->stack_header = ctx.stack_header; func_out->stack_usage = ctx.stack_usage; func_out->prologue_length = ctx.prologue_length; func_out->epilogue_length = ctx.epilogue_length; diff --git a/tb/debug/cv.c b/tb/debug/cv.c index a693c3bd..25093c4f 100644 --- a/tb/debug/cv.c +++ b/tb/debug/cv.c @@ -509,7 +509,7 @@ static TB_SectionGroup codeview_generate_debug_info(TB_Module* m, TB_Arena* aren CV_RegRel32 l = { .reclen = sizeof(CV_RegRel32) + (var_name_len + 1) - 2, .rectyp = S_REGREL32, - .off = out_f->stack_usage + stack_pos, + .off = (out_f->stack_usage - out_f->stack_header) + stack_pos, .typind = type_index, // AMD64_RBP is 334, AMD64_RSP is 335 .reg = 335, diff --git a/tb/new_builder.c b/tb/new_builder.c index b7839893..3d13852c 100644 --- a/tb/new_builder.c +++ b/tb/new_builder.c @@ -230,7 +230,12 @@ TB_Node* tb_builder_string(TB_GraphBuilder* g, ptrdiff_t len, const char* str) { TB_Node* tb_builder_cast(TB_GraphBuilder* g, TB_DataType dt, int type, TB_Node* src) { TB_ASSERT(type >= TB_TRUNCATE && type <= TB_BITCAST); - if (type == TB_SIGN_EXT && src->type == TB_ICONST) { + if (type == TB_ZERO_EXT && src->type == TB_ICONST) { + int bits = tb_data_type_bit_size(g->f->super.module, src->dt.type); + + uint64_t y = TB_NODE_GET_EXTRA_T(src, TB_NodeInt)->value; + return tb_builder_uint(g, dt, y & (~UINT64_C(0) >> (64 - bits))); + } else if (type == TB_SIGN_EXT && src->type == TB_ICONST) { uint64_t y = TB_NODE_GET_EXTRA_T(src, TB_NodeInt)->value; y = tb_sign_ext(g->f->super.module, src->dt, y); return tb_builder_uint(g, dt, y); @@ -291,7 +296,7 @@ TB_Node* tb_builder_neg(TB_GraphBuilder* g, TB_Node* src) { if (TB_IS_FLOAT_TYPE(src->dt)) { return tb_builder_unary(g, TB_FNEG, src); } else { - return tb_builder_unary(g, TB_NEG, src); + return tb_builder_binop_int(g, TB_SUB, tb_builder_sint(g, src->dt, 0), src, 0); } } @@ -342,7 +347,7 @@ TB_Node* tb_builder_ptr_member(TB_GraphBuilder* g, TB_Node* base, int64_t offset } TB_Function* f = g->f; - TB_Node* con = tb_opt_peep_node(f, tb_inst_sint(f, TB_TYPE_I64, offset)); + TB_Node* con = g->peep(f, tb_inst_sint(f, TB_TYPE_I64, offset)); TB_Node* n = tb_alloc_node(f, TB_PTR_OFFSET, TB_TYPE_PTR, 3, 0); set_input(f, n, base, 1); set_input(f, n, con, 2); @@ -512,13 +517,24 @@ TB_Node* tb_builder_label_make(TB_GraphBuilder* g) { return syms; } -TB_Node* tb_builder_label_make2(TB_GraphBuilder* g, TB_Node* label) { +TB_Node* tb_builder_label_make2(TB_GraphBuilder* g, TB_Node* label, bool has_backward_jumps) { TB_Function* f = g->f; TB_Node* r = tb_alloc_node_dyn(f, TB_REGION, TB_TYPE_CONTROL, 0, 2, sizeof(TB_NodeRegion)); TB_Node* syms = tb_alloc_node(f, TB_SYMBOL_TABLE, TB_TYPE_VOID, label->input_count, sizeof(TB_NodeSymbolTable)); set_input(f, syms, r, 0); set_input(f, syms, r, 1); + + if (has_backward_jumps) { + // pre-emptively enter phis + FOR_N(i, 2, label->input_count) { + TB_Node* n = tb_alloc_node_dyn(f, TB_PHI, label->inputs[i]->dt, 1, 3, 0); + set_input(f, n, r, 0); + set_input(f, syms, n, i); + } + TB_NODE_SET_EXTRA(syms, TB_NodeSymbolTable, .complete = true); + } + return syms; } @@ -602,8 +618,9 @@ TB_Node* tb_builder_label_clone(TB_GraphBuilder* g, TB_Node* label) { FOR_N(j, 0, label->input_count) if (label->inputs[j]) { set_input(f, syms, label->inputs[j], j); } - TB_NODE_SET_EXTRA(syms, TB_NodeSymbolTable, .complete = false); + bool complete = TB_NODE_GET_EXTRA_T(label, TB_NodeSymbolTable)->complete; + TB_NODE_SET_EXTRA(syms, TB_NodeSymbolTable, .complete = complete); return syms; } @@ -743,6 +760,7 @@ void tb_builder_br(TB_GraphBuilder* g, TB_Node* target) { TB_Node* tb_builder_loop(TB_GraphBuilder* g) { TB_Function* f = g->f; TB_Node* curr = g->curr; + TB_ASSERT(curr); TB_Node* r = tb_alloc_node_dyn(f, TB_REGION, TB_TYPE_CONTROL, 1, 2, sizeof(TB_NodeRegion)); set_input(f, r, curr->inputs[0], 0); diff --git a/tb/opt/bb_placement.h b/tb/opt/bb_placement.h index 84e4cac7..deaff054 100644 --- a/tb/opt/bb_placement.h +++ b/tb/opt/bb_placement.h @@ -34,6 +34,8 @@ typedef struct Trace { int first_bb; int last_bb; + bool complete; + // I'm gonna assume the first // block's frequency is a good metric float freq; @@ -139,27 +141,26 @@ int bb_placement_trace(TB_Arena* arena, TB_CFG* cfg, int* dst_order) { // place starting point and any missed BBs will be placed on a worklist to attempt // trace growing when we can't grow the main trace anymore. int ws_cnt = 0; - Trace** ws = tb_arena_alloc(arena, bb_count * sizeof(Trace*)); + int* ws = tb_arena_alloc(arena, bb_count * sizeof(int)); bool* visited = tb_arena_alloc(arena, bb_count); FOR_N(i, 0, bb_count) { visited[i] = false; } // place entry - ws[ws_cnt++] = traces.block_to_trace[0]; + ws[ws_cnt++] = 0; int order_cnt = 0; Trace** order = tb_arena_alloc(arena, bb_count * sizeof(Trace*)); // grow traces by placing likely traces next to them while (ws_cnt > 0) { - Trace* trace = ws[--ws_cnt]; - if (trace == NULL) { continue; } - // if we've already tried to grow this trace, don't :p - if (visited[trace->id]) { continue; } - visited[trace->id] = true; + int first_bb = ws[--ws_cnt]; + Trace* trace = traces.block_to_trace[first_bb]; + // if the block was already stitched somewhere else we can't start a trace here + if (trace->first_bb != first_bb) { continue; } TB_OPTDEBUG(PLACEMENT)(printf("Grow Trace %d?\n", trace->id)); - trace->freq = cfg->blocks[trace->first_bb].freq; + trace->freq = cfg->blocks[first_bb].freq; order[order_cnt++] = trace; // extend the end of the trace until we hit an unlikely case or a backedge @@ -185,7 +186,9 @@ int bb_placement_trace(TB_Arena* arena, TB_CFG* cfg, int* dst_order) { // can't do backedges in traces succ->fwd > curr && // it's only an option if the block is the start of it's trace - traces.block_to_trace[succ->fwd]->first_bb == succ->fwd + traces.block_to_trace[succ->fwd]->first_bb == succ->fwd && + // and it's not part of a completed trace + !traces.block_to_trace[succ->fwd]->complete ) { trace_append(&traces, curr, succ->fwd); curr = succ->fwd; @@ -200,15 +203,18 @@ int bb_placement_trace(TB_Arena* arena, TB_CFG* cfg, int* dst_order) { Trace* t = traces.block_to_trace[bb->fwd]; // it's only an option if the block is the start of it's trace if (t->first_bb != bb->fwd) { continue; } - // if it's already visited, we're too late to build it up here - if (visited[t->id]) { continue; } + // if it's already in the worklist, we don't need to add it again + if (visited[bb->fwd]) { continue; } - TB_OPTDEBUG(PLACEMENT)(printf(" Postpone Trace%d\n", t->id)); + TB_OPTDEBUG(PLACEMENT)(printf(" Postpone BB%d\n", bb->fwd)); TB_ASSERT(ws_cnt < bb_count); - ws[ws_cnt++] = t; + ws[ws_cnt++] = bb->fwd; + visited[bb->fwd] = true; } } while (succ != NULL); + + trace->complete = true; } qsort(order, order_cnt, sizeof(Trace*), trace_cmp); diff --git a/tb/opt/gvn.h b/tb/opt/gvn.h index 766e5a06..447d0f2e 100644 --- a/tb/opt/gvn.h +++ b/tb/opt/gvn.h @@ -59,7 +59,6 @@ static size_t extra_bytes(TB_Node* n) { case TB_FMAX: case TB_FMIN: case TB_FNEG: - case TB_NEG: case TB_PHI: case TB_CLZ: case TB_CTZ: diff --git a/tb/opt/list_sched.h b/tb/opt/list_sched.h index 0b30c084..85406e60 100644 --- a/tb/opt/list_sched.h +++ b/tb/opt/list_sched.h @@ -38,7 +38,7 @@ static void ready_up(ListSched* sched, TB_Node* n, TB_Node* end) { int prio = sched->get_lat(sched->f, n, end); uint64_t unit_mask = sched->get_unit_mask(sched->f, n); - TB_OPTDEBUG(SCHEDULE)(printf(" READY "), tb_print_dumb_node(NULL, n), printf("\n")); + TB_OPTDEBUG(SCHEDULE)(printf(" READY "), tb_print_dumb_node(NULL, n), printf(" (lat=%d)\n", prio)); set_put(&sched->ready_set, n->gvn); // projections are readied but not in the ready list @@ -161,6 +161,31 @@ void tb_list_scheduler(TB_Function* f, TB_CFG* cfg, TB_Worklist* ws, DynArray(Ph while (aarray_length(active) > 0 || aarray_length(sched.ready) > 0) { bool stall = true; + // retire active nodes + for (size_t i = 0; i < aarray_length(active);) { + TB_Node* n = active[i].n; + if (active[i].end > cycle) { i++; continue; } + + in_use_mask &= ~(1ull << active[i].unit_i); + aarray_remove(active, i); + TB_OPTDEBUG(SCHEDULE)(printf(" T=%2d: RETIRE ", cycle), tb_print_dumb_node(NULL, n), printf("\n")); + + // instruction's retired, time to ready up users + FOR_USERS(u, n) { + TB_Node* un = USERN(u); + if (is_proj(un)) { + // projections are where all the real users ended up + FOR_USERS(proj_u, un) { + if (can_ready_user(f, ws, bb, &sched.ready_set, USERN(proj_u))) { + ready_up(&sched, USERN(proj_u), end); + } + } + } else if (can_ready_user(f, ws, bb, &sched.ready_set, un)) { + ready_up(&sched, un, end); + } + } + } + // dispatch one instruction per machine per cycle while (in_use_mask != blocked_mask && aarray_length(sched.ready) > 0) { int idx = best_ready_node(&sched, in_use_mask); @@ -170,7 +195,7 @@ void tb_list_scheduler(TB_Function* f, TB_CFG* cfg, TB_Worklist* ws, DynArray(Ph int unit_i = tb_ffs64(avail) - 1; TB_Node* n = sched.ready[idx].n; - // in_use_mask |= 1ull << unit_i; + in_use_mask |= 1ull << unit_i; stall = false; remove_ready(&sched, idx); @@ -195,35 +220,13 @@ void tb_list_scheduler(TB_Function* f, TB_CFG* cfg, TB_Worklist* ws, DynArray(Ph TB_OPTDEBUG(SCHEDULE)(printf(" T=%2d: DISPATCH ", cycle), tb_print_dumb_node(NULL, n), printf(" (on machine %d, until t=%d)\n", unit_i, end_cycle)); } } + in_use_mask = 0; if (stall) { TB_OPTDEBUG(SCHEDULE)(printf(" T=%2d: STALL\n", cycle)); } - cycle += 1; - for (size_t i = 0; i < aarray_length(active);) { - TB_Node* n = active[i].n; - if (active[i].end > cycle) { i++; continue; } - - in_use_mask &= ~(1ull << active[i].unit_i); - aarray_remove(active, i); - TB_OPTDEBUG(SCHEDULE)(printf(" T=%2d: RETIRE ", cycle), tb_print_dumb_node(NULL, n), printf("\n")); - - // instruction's retired, time to ready up users - FOR_USERS(u, n) { - TB_Node* un = USERN(u); - if (is_proj(un)) { - // projections are where all the real users ended up - FOR_USERS(proj_u, un) { - if (can_ready_user(f, ws, bb, &sched.ready_set, USERN(proj_u))) { - ready_up(&sched, USERN(proj_u), end); - } - } - } else if (can_ready_user(f, ws, bb, &sched.ready_set, un)) { - ready_up(&sched, un, end); - } - } - } + cycle += 1; } // place end node diff --git a/tb/opt/loop.h b/tb/opt/loop.h index c1a068ed..53e17cf5 100644 --- a/tb/opt/loop.h +++ b/tb/opt/loop.h @@ -109,7 +109,7 @@ static void loop_scc_walk(LoopSCC* restrict scc, TB_CFG* restrict cfg, TB_BasicB if (cfg->root_loop == NULL) { cfg->root_loop = new_loop; - } else { + } else if (new_loop != cfg->root_loop) { // if we dominate the previously placed loop, we're its parent, if not // then we're siblings. if (slow_dommy(cfg, cfg->root_loop->header, succ_bb->start)) { diff --git a/tb/opt/optimizer.c b/tb/opt/optimizer.c index 17498b5c..2b1cda73 100644 --- a/tb/opt/optimizer.c +++ b/tb/opt/optimizer.c @@ -1342,7 +1342,7 @@ bool tb_opt(TB_Function* f, TB_Worklist* ws, bool preserve_types) { } // TODO(NeGate): doesn't do anything yet - // progress |= tb_opt_vectorize(f); + progress |= tb_opt_vectorize(f); progress |= major_progress; } while (major_progress); diff --git a/tb/opt/peep_int.h b/tb/opt/peep_int.h index da3996b7..1e0c9bd1 100644 --- a/tb/opt/peep_int.h +++ b/tb/opt/peep_int.h @@ -101,10 +101,10 @@ static Lattice* value_arith_raw(TB_Function* f, TB_NodeTypeEnum type, TB_DataTyp max = ssub(amax, bmin, mask); if (amin != amax || bmin != bmax) { // Ahh sweet, Hacker's delight horrors beyond my comprehension - uint64_t u = ~(amin ^ bmax) | ~(amin ^ min); - uint64_t v = ~(amax ^ bmin) | ~(amax ^ max); + uint64_t u = (amin ^ bmax) | (amin ^ min); + uint64_t v = (amax ^ bmin) | (amax ^ max); - if (((u & v) & imin) == 0) { + if ((u & v) & imin) { overflow = true; min = imin, max = imax; } diff --git a/tb/opt/peeps.h b/tb/opt/peeps.h index 663fdfff..8a0953ab 100644 --- a/tb/opt/peeps.h +++ b/tb/opt/peeps.h @@ -102,8 +102,6 @@ static const NodeVtable node_vtables[TB_NODE_TYPE_MAX] = { [TB_SHL] = { ideal_shift, identity_int_binop, value_shift }, [TB_SHR] = { ideal_shift, identity_int_binop, value_shift }, [TB_SAR] = { NULL, identity_int_binop, value_shift }, - // unary - [TB_NEG] = { NULL, NULL, value_negate }, // casts [TB_BITCAST] = { ideal_bitcast, NULL, value_bitcast }, [TB_TRUNCATE] = { ideal_truncate, NULL, value_trunc }, diff --git a/tb/opt/print.h b/tb/opt/print.h index c6f340d9..15df9082 100644 --- a/tb/opt/print.h +++ b/tb/opt/print.h @@ -91,7 +91,6 @@ const char* tb_node_get_name(TB_NodeTypeEnum n_type) { case TB_CLZ: return "clz"; case TB_CTZ: return "ctz"; - case TB_NEG: return "neg"; case TB_AND: return "and"; case TB_OR: return "or"; case TB_XOR: return "xor"; diff --git a/tb/opt/slp.h b/tb/opt/slp.h index 0348b28f..7bd91df3 100644 --- a/tb/opt/slp.h +++ b/tb/opt/slp.h @@ -6,13 +6,20 @@ // only type of PackSet we need typedef struct Pair { struct Pair* next; + int id; TB_Node* lhs; TB_Node* rhs; } Pair; typedef struct { + int count; + Pair* first; + Pair* last; + + Pair** l_map; + Pair** r_map; } PairSet; typedef struct { @@ -47,7 +54,11 @@ static bool independent(TB_Node* a, TB_Node* b) { return a != b; } -static bool can_pack(TB_Node* a, TB_Node* b) { +static bool can_pack(PairSet* pairs, TB_Node* a, TB_Node* b) { + if (pairs->l_map[a->gvn] || pairs->r_map[b->gvn]) { + return false; + } + if (is_valid_vector_component(slp_node_data_type(a)) && is_valid_vector_component(slp_node_data_type(b)) && isomorphic(a, b) && @@ -63,6 +74,7 @@ static int ref_cmp(const void* a, const void* b) { const MemRef* aa = a; const MemRef* bb = b; + if (aa->mem->type != bb->mem->type) { return aa->base->type - bb->base->type; } if (aa->base->gvn != bb->base->gvn) { return aa->base->gvn - bb->base->gvn; } if (aa->size != bb->size) { return aa->size - bb->size; } if (aa->offset != bb->offset) { return aa->offset - bb->offset; } @@ -70,142 +82,213 @@ static int ref_cmp(const void* a, const void* b) { return 0; } -static bool slp_in_pairs(PairSet* pairs, TB_Node* n) { - for (Pair* p = pairs->first; p; p = p->next) { - if (p->lhs == n || p->rhs == n) { return true; } - } - return false; -} - static void slp_add_pair(TB_Function* f, PairSet* pairs, TB_Node* lhs, TB_Node* rhs) { Pair* p = tb_arena_alloc(&f->tmp_arena, sizeof(Pair)); - p->next = pairs->first; + p->next = NULL; + p->id = pairs->count++; p->lhs = lhs; p->rhs = rhs; - pairs->first = p; + + if (pairs->first == NULL) { + pairs->first = pairs->last = p; + } else { + pairs->last->next = p; + pairs->last = p; + } + + pairs->l_map[lhs->gvn] = p; + pairs->r_map[rhs->gvn] = p; } -void generate_pack(TB_Function* f, PairSet* pairs, TB_Node* n) { - if (n->type == TB_MERGEMEM) { - // independent stores - ArenaArray(MemRef) refs = aarray_create(&f->tmp_arena, MemRef, 8); - FOR_N(i, 2, n->input_count) { - TB_Node* mem = n->inputs[i]; - if (mem->type == TB_STORE) { - MemRef r = { mem, mem->inputs[2] }; - if (r.base->type == TB_PTR_OFFSET && r.base->inputs[2]->type == TB_ICONST) { - r.offset = TB_NODE_GET_EXTRA_T(r.base->inputs[2], TB_NodeInt)->value; - r.base = r.base->inputs[1]; - } +void generate_pack(TB_Function* f, PairSet* pairs) { + ArenaArray(MemRef) refs = aarray_create(&f->tmp_arena, MemRef, 8); + pairs->l_map = tb_arena_alloc(&f->tmp_arena, f->node_count * sizeof(Pair*)); + pairs->r_map = tb_arena_alloc(&f->tmp_arena, f->node_count * sizeof(Pair*)); + FOR_N(i, 0, f->node_count) { + pairs->l_map[i] = NULL; + pairs->r_map[i] = NULL; + } + + TB_Node* root_mem = USERN(proj_with_index(f->root_node, 1)); + TB_ASSERT(root_mem->dt.type == TB_TAG_MEMORY); + worklist_push(f->worklist, root_mem); + + for (size_t i = 0; i < dyn_array_length(f->worklist->items); i++) { + TB_Node* mem = f->worklist->items[i]; + + if (mem->type == TB_LOAD || mem->type == TB_STORE) { + MemRef r = { mem, mem->inputs[2] }; + if (r.base->type == TB_PTR_OFFSET && r.base->inputs[2]->type == TB_ICONST) { + r.offset = TB_NODE_GET_EXTRA_T(r.base->inputs[2], TB_NodeInt)->value; + r.base = r.base->inputs[1]; + } + + if (mem->type == TB_LOAD) { + r.size = tb_data_type_byte_size(f->super.module, mem->dt.type); + } else { r.size = tb_data_type_byte_size(f->super.module, mem->inputs[3]->dt.type); - aarray_push(refs, r); } + aarray_push(refs, r); } - // sort for faster queries later on - qsort(refs, aarray_length(refs), sizeof(MemRef), ref_cmp); + if (mem->dt.type == TB_TAG_MEMORY) { + FOR_USERS(u, mem) { + if (cfg_is_mproj(USERN(u))) { + mem = USERN(u); + break; + } + } + } - // scan for groups with the same base & element size - int start = 0; - while (start < aarray_length(refs)) { - int end = start + 1; - while (refs[end].base == refs[start].base - && refs[end].size == refs[start].size) { - end++; + // walk all the memory users of the memory node + if (mem->dt.type == TB_TAG_MEMORY) { + FOR_USERS(u, mem) { + if ((USERN(u)->type == TB_PHI && USERN(u)->dt.type == TB_TAG_MEMORY) || + (USERI(u) == 1 && cfg_flags(USERN(u)) & NODE_MEMORY_IN)) { + worklist_push(f->worklist, USERN(u)); + } } + } + } - if (start + 1 != end) { // no group :( - TB_Node* base = refs[start].base; - int32_t size = refs[start].size; - TB_DataType elem_dt = refs[start].mem->inputs[3]->dt; - - // find adjacent stores - FOR_N(i, start, end) { - MemRef* a = &refs[i]; - FOR_N(j, start+1, end) { - MemRef* b = &refs[j]; - - // there's a weird overlapping memory op - if (a->offset + size < b->offset) { break; } - if (a->offset + size == b->offset && can_pack(a->mem, b->mem)) { - // add to pair - slp_add_pair(f, pairs, a->mem, b->mem); - } + // sort for faster queries later on + qsort(refs, aarray_length(refs), sizeof(MemRef), ref_cmp); + + aarray_for(i, refs) { + MemRef r = refs[i]; + + printf("AAA! "); + tb_print_dumb_node(NULL, r.mem); + printf(" (%%%u + %d, size=%d)\n", r.base->gvn, r.offset, r.size); + } + + // scan for groups with the same base & element size + int start = 0; + while (start < aarray_length(refs)) { + int end = start + 1; + while (refs[end].base == refs[start].base + && refs[end].size == refs[start].size) { + end++; + } + + if (start + 1 != end) { // no group :( + TB_Node* base = refs[start].base; + int32_t size = refs[start].size; + TB_DataType elem_dt = refs[start].mem->inputs[3]->dt; + + // find adjacent stores + FOR_N(i, start, end) { + MemRef* a = &refs[i]; + FOR_N(j, start+1, end) { + MemRef* b = &refs[j]; + + // there's a weird overlapping memory op + if (a->offset + size < b->offset) { break; } + if (a->offset + size == b->offset && can_pack(pairs, a->mem, b->mem)) { + slp_add_pair(f, pairs, a->mem, b->mem); } } + } - __debugbreak(); - - // extend packs based on use-def - bool progress; - do { - progress = false; - - #if TB_OPTDEBUG_SLP - printf("=== PAIRS ===\n"); - for (Pair* p = pairs->first; p; p = p->next) { - printf("\x1b[96m%%%-4u -- %%%-4u %s\x1b[0m\n ", p->lhs->gvn, p->rhs->gvn, tb_node_get_name(p->lhs->type)); - tb_print_dumb_node(NULL, p->lhs); - printf("\n "); - tb_print_dumb_node(NULL, p->rhs); - printf("\n\n"); + // extend packs based on use-def + bool progress; + do { + progress = false; + + #if TB_OPTDEBUG_SLP + printf("=== PAIRS ===\n"); + for (Pair* p = pairs->first; p; p = p->next) { + printf("\x1b[96m%%%-4u -- %%%-4u %s\x1b[0m\n ", p->lhs->gvn, p->rhs->gvn, tb_node_get_name(p->lhs->type)); + tb_print_dumb_node(NULL, p->lhs); + printf("\n "); + tb_print_dumb_node(NULL, p->rhs); + printf("\n\n"); + } + printf("\n\n\n"); + #endif + + // check if all input edges do the same op + for (Pair* p = pairs->first; p; p = p->next) { + TB_Node* lhs = p->lhs; + TB_Node* rhs = p->rhs; + TB_ASSERT(lhs->type == rhs->type); + + // loads always terminate the SIMD chains, they only have an address input and those are scalar + if (lhs->type == TB_LOAD) { + continue; } - printf("\n\n\n"); - #endif - - // check if all input edges do the same op - for (Pair* p = pairs->first; p; p = p->next) { - TB_Node* lhs = p->lhs; - TB_Node* rhs = p->rhs; - TB_ASSERT(lhs->type == rhs->type); - - // loads always terminate the SIMD chains, they only have an address input and those are scalar - if (lhs->type == TB_LOAD) { - continue; - } - // can we pack the normal input ops (doesn't count the memory or address for a store) - FOR_N(j, lhs->type == TB_STORE ? 3 : 1, lhs->input_count) { - TB_Node* a = lhs->inputs[j]; - TB_Node* b = rhs->inputs[j]; - if (!slp_in_pairs(pairs, a) && - !slp_in_pairs(pairs, b) && - can_pack(a, b)) - { - slp_add_pair(f, pairs, a, b); - progress = true; - } + // can we pack the normal input ops (doesn't count the memory or address for a store) + FOR_N(j, lhs->type == TB_STORE ? 3 : 1, lhs->input_count) { + TB_Node* a = lhs->inputs[j]; + TB_Node* b = rhs->inputs[j]; + if (can_pack(pairs, a, b)) { + slp_add_pair(f, pairs, a, b); + progress = true; } } + } + } while (progress); - __debugbreak(); - } while (progress); + bool* visited = tb_arena_alloc(&f->tmp_arena, pairs->count * sizeof(bool)); + FOR_N(i, 0, pairs->count) { + visited[i] = false; + } + + // combine packs + #if TB_OPTDEBUG_SLP + printf("=== COMBINED ===\n"); + for (Pair* p = pairs->first; p; p = p->next) { + if (visited[p->id]) { continue; } + visited[p->id] = true; + + printf(" "); + tb_print_dumb_node(NULL, p->lhs); + printf("\n"); + + printf(" "); + tb_print_dumb_node(NULL, p->rhs); + printf("\n"); + + // if one pack ends where the other starts, we join them + Pair* curr = p; + while (pairs->l_map[curr->rhs->gvn]) { + curr = pairs->l_map[curr->rhs->gvn]; + visited[curr->id] = true; + + printf(" "); + tb_print_dumb_node(NULL, curr->rhs); + printf("\n"); + } - __debugbreak(); + printf("\n\n"); } + printf("\n"); + #endif - start = end; + tb_arena_free(&f->tmp_arena, visited, pairs->count * sizeof(bool)); } - __debugbreak(); + start = end; } + + __debugbreak(); } -void tb_opt_vectorize(TB_Function* f) { - /* tb_print_dumb(f); +bool tb_opt_vectorize(TB_Function* f) { + #if 0 + tb_print_dumb(f); + + TB_ASSERT(tb_arena_is_empty(&f->tmp_arena)); - // TODO(NeGate): search for reductions & stores throughout - // the entire graph, for now we're only searching the exit - // paths PairSet pairs = { 0 }; - FOR_N(i, 1, f->root_node->input_count) { - TB_Node* exit = f->root_node->inputs[i]; - if (exit->type == TB_RETURN) { - generate_pack(f, &pairs, exit->inputs[1]); - } - } + generate_pack(f, &pairs); __debugbreak(); - tb_arena_clear(&f->tmp_arena); */ + + tb_arena_clear(&f->tmp_arena); + #endif + + return false; } diff --git a/tb/rogers_ra.c b/tb/rogers_ra.c index 6a733674..d4520bc6 100644 --- a/tb/rogers_ra.c +++ b/tb/rogers_ra.c @@ -256,7 +256,6 @@ void tb__rogers(Ctx* restrict ctx, TB_Arena* arena) { } ra.num_regs = ctx->num_regs; ra.max_regs_in_class = max_regs_in_class; - TB_ASSERT(max_regs_in_class <= 64 && "TODO: we assume some 64bit masks in places lol"); } ra.spills = dyn_array_create(int, 32); @@ -382,7 +381,7 @@ void tb__rogers(Ctx* restrict ctx, TB_Arena* arena) { // if the def_mask got tightened, we needed the copy RegMask* def_mask = ctx->vregs[ctx->vreg_map[n->gvn]].mask; - if (!interfere(ctx, &ra, n, n->inputs[1])) { + if (def_mask == cpy->def && !interfere(ctx, &ra, n, n->inputs[1])) { // delete copy tb__remove_node(ctx, f, n); subsume_node(f, n, n->inputs[1]); @@ -667,9 +666,9 @@ static bool allocate_reg(Ctx* restrict ctx, Rogers* restrict ra, int vreg_id, ui // what the regmask holds only applies up until num_regs[class], this is mostly // just relevant for the stack coloring i suppose - FOR_N(j, 0, mask->count) { ra->mask[j] = ~mask->mask[0]; } - FOR_N(j, mask->count, mask_word_count) { ra->mask[j] = 0; } - if (num_regs % 64) { + FOR_N(j, 0, mask->count) { ra->mask[j] = ~mask->mask[j]; } + FOR_N(j, mask->count, (ctx->num_regs[mask->class] + 63) / 64) { ra->mask[j] = UINT64_MAX; } + if (ctx->num_regs[mask->class] % 64) { ra->mask[num_regs / 64] &= UINT64_MAX >> (64ull - (num_regs % 64)); } @@ -731,7 +730,7 @@ static bool allocate_reg(Ctx* restrict ctx, Rogers* restrict ra, int vreg_id, ui dyn_array_put(ra->potential_spills, in_vreg - ctx->vregs); } - in_use |= (1ull << in_vreg->assigned); + ra->mask[in_vreg->assigned / 64ull] |= (1ull << (in_vreg->assigned % 64ull)); } } @@ -786,19 +785,44 @@ static int choose_decent_spill(Ctx* restrict ctx, Rogers* restrict ra, VReg* att bool can_spill_self = false; if (attempted_vreg) { - if (can_remat(ctx, attempted_vreg->n)) { - // this limits the interference thus improving colorability + // this limits the interference thus improving colorability + if (attempted_vreg->spill_bias < 1e9 && can_remat(ctx, attempted_vreg->n)) { can_spill_self = true; - } else if (fixed_reg_mask(attempted_vreg->mask) >= 0) { - // we can only spill ourselves if that meant loosening the vreg's mask - RegMask* def = ctx->constraint(ctx, attempted_vreg->n, NULL); - can_spill_self = (attempted_vreg->mask != def); + } + + // we can only spill ourselves if that meant loosening the vreg's mask + if (fixed_reg_mask(attempted_vreg->mask) >= 0) { + RegMask* expected_mask = ctx->constraint(ctx, attempted_vreg->n, NULL); + printf(" self spill? %%%u\n", attempted_vreg->n->gvn); + + FOR_USERS(u, attempted_vreg->n) { + RegMask* in_mask = constraint_in(ctx, USERN(u), USERI(u)); + RegMask* new_mask = tb__reg_mask_meet(ctx, expected_mask, in_mask); + + printf(" use %%%u[%d]: ", USERN(u)->gvn, USERI(u)); + tb__print_regmask(new_mask); + printf("\n"); + + // shouldn't see any hard splits here? + if (new_mask == &TB_REG_EMPTY) { + break; + } + expected_mask = new_mask; + } + + if (attempted_vreg->mask != expected_mask) { + TB_OPTDEBUG(REGALLOC)(printf("# can self spill since mask is loosened from "), tb__print_regmask(attempted_vreg->mask), printf(" to "), tb__print_regmask(expected_mask), printf("\n")); + } + + if (attempted_vreg->mask != expected_mask) { + can_spill_self = true; + } } } int best_spill = -1; float best_score = INFINITY; - FOR_N(i, 0, dyn_array_length(ra->potential_spills)) { + FOR_REV_N(i, 0, dyn_array_length(ra->potential_spills)) { int vreg_id = ra->potential_spills[i]; VReg* vreg = &ctx->vregs[vreg_id]; @@ -921,6 +945,7 @@ static int allocate_loop(Ctx* restrict ctx, Rogers* restrict ra, TB_Arena* arena if (!allocate_reg(ctx, ra, vreg_id, 0)) { RegMask* mask = ctx->vregs[vreg_id].mask; commit_spill(ctx, ra, &ctx->vregs[vreg_id], mask->class, mask->mask[0]); + return ALLOC_FAIL; } } } @@ -1054,6 +1079,7 @@ static int allocate_loop(Ctx* restrict ctx, Rogers* restrict ra, TB_Arena* arena if (in_use == UINT64_MAX) { int r = commit_spill(ctx, ra, NULL, tmp_mask->class, tmp_mask->mask[0]); in_use &= ~(1ull << r); + return ALLOC_FAIL; } TB_OPTDEBUG(REGALLOC)(printf("# available: %#"PRIx64"\n", ~in_use)); @@ -1075,8 +1101,9 @@ static int allocate_loop(Ctx* restrict ctx, Rogers* restrict ra, TB_Arena* arena RegMask* mask = ctx->vregs[vreg_id].mask; int r = commit_spill(ctx, ra, &ctx->vregs[vreg_id], mask->class, mask->mask[0]); - ctx->vregs[vreg_id].class = class; - ctx->vregs[vreg_id].assigned = r; + // ctx->vregs[vreg_id].class = class; + // ctx->vregs[vreg_id].assigned = r; + return ALLOC_FAIL; } TB_Node* def = ctx->vregs[vreg_id].n; @@ -1092,8 +1119,9 @@ static int allocate_loop(Ctx* restrict ctx, Rogers* restrict ra, TB_Arena* arena RegMask* mask = ctx->vregs[vreg_id].mask; int r = commit_spill(ctx, ra, &ctx->vregs[vreg_id], mask->class, mask->mask[0]); - ctx->vregs[vreg_id].class = class; - ctx->vregs[vreg_id].assigned = r; + // ctx->vregs[vreg_id].class = class; + // ctx->vregs[vreg_id].assigned = r; + return ALLOC_FAIL; } set_put(&ra->live_out, un->gvn); diff --git a/tb/tb.c b/tb/tb.c index 26b9d463..b2970ab5 100644 --- a/tb/tb.c +++ b/tb/tb.c @@ -458,9 +458,9 @@ TB_FunctionPrototype* tb_function_get_prototype(TB_Function* f) { } void* tb_global_add_region(TB_Module* m, TB_Global* g, size_t offset, size_t size) { - assert(offset == (uint32_t)offset); - assert(size == (uint32_t)size); - assert(g->obj_count + 1 <= g->obj_capacity); + TB_ASSERT(offset == (uint32_t)offset); + TB_ASSERT(size == (uint32_t)size); + TB_ASSERT(g->obj_count < g->obj_capacity); void* ptr = cuik_malloc(size); g->objects[g->obj_count++] = (TB_InitObj) { @@ -471,15 +471,15 @@ void* tb_global_add_region(TB_Module* m, TB_Global* g, size_t offset, size_t siz } void tb_global_add_symbol_reloc(TB_Module* m, TB_Global* g, size_t offset, TB_Symbol* symbol) { - assert(offset == (uint32_t) offset); - assert(g->obj_count + 1 <= g->obj_capacity); - assert(symbol != NULL); + TB_ASSERT(offset == (uint32_t) offset); + TB_ASSERT(g->obj_count + 1 <= g->obj_capacity); + TB_ASSERT(symbol != NULL); g->objects[g->obj_count++] = (TB_InitObj) { .type = TB_INIT_OBJ_RELOC, .offset = offset, .reloc = symbol }; } TB_Symbol* tb_symbol_alloc(TB_Module* m, TB_SymbolTag tag, ptrdiff_t len, const char* name, size_t size) { - assert(tag != TB_SYMBOL_NONE); + TB_ASSERT(tag != TB_SYMBOL_NONE); cuikperf_region_start("symbol_alloc", NULL); TB_ThreadInfo* info = tb_thread_info(m); diff --git a/tb/tb_builder.c b/tb/tb_builder.c index 987267df..eacef317 100644 --- a/tb/tb_builder.c +++ b/tb/tb_builder.c @@ -598,7 +598,7 @@ TB_Node* tb_inst_neg(TB_Function* f, TB_Node* src) { } else if (TB_IS_FLOAT_TYPE(src->dt)) { return tb_unary(f, TB_FNEG, src->dt, src); } else { - return tb_unary(f, TB_NEG, src->dt, src); + return tb_bin_arith(f, TB_SUB, 0, tb_inst_sint(f, src->dt, 0), src); } } diff --git a/tb/tb_internal.h b/tb/tb_internal.h index d22f39d2..5e31813b 100644 --- a/tb/tb_internal.h +++ b/tb/tb_internal.h @@ -256,6 +256,7 @@ typedef struct TB_FunctionOutput { uint64_t ordinal; uint64_t stack_usage; + uint64_t stack_header; uint8_t* code; uint32_t code_size; diff --git a/tb/x64/x64_disasm.c b/tb/x64/x64_disasm.c index 1fbc9312..ee592d22 100644 --- a/tb/x64/x64_disasm.c +++ b/tb/x64/x64_disasm.c @@ -408,6 +408,7 @@ const char* tb_x86_mnemonic(TB_X86_Inst* inst) { case 0x00F6: case 0x00F7: return "test"; case 0x20F6: case 0x20F7: return "not"; + case 0x30F6: case 0x30F7: return "neg"; case 0x60F6: case 0x60F7: return "div"; case 0x70F6: case 0x70F7: return "idiv"; diff --git a/tb/x64/x64_emitter.h b/tb/x64/x64_emitter.h index cf8507c6..fccdc1c3 100644 --- a/tb/x64/x64_emitter.h +++ b/tb/x64/x64_emitter.h @@ -157,7 +157,7 @@ static void inst2(TB_CGEmitter* restrict e, InstType type, const Val* a, const V emit_memory_operand(e, rx, a); // BTW memory displacements go before immediates - ptrdiff_t disp_patch = e->count - 4; + ptrdiff_t disp_patch = e->count; if (b->type == VAL_IMM) { if (dt == TB_X86_BYTE || short_imm) { if (short_imm) { @@ -168,16 +168,15 @@ static void inst2(TB_CGEmitter* restrict e, InstType type, const Val* a, const V } else if (dt == TB_X86_WORD) { uint32_t imm = b->imm; assert((imm & 0xFFFF0000) == 0xFFFF0000 || (imm & 0xFFFF0000) == 0); - EMIT2(e, imm); } else { EMIT4(e, (int32_t)b->imm); } } - /* if (a->type == VAL_GLOBAL && disp_patch + 4 != e->count) { - RELOC4(e, disp_patch, (disp_patch + 4) - e->count); - } */ + if (a->type == VAL_GLOBAL && disp_patch != e->count) { + RELOC4(e, disp_patch - 4, disp_patch - e->count, 0xFFFFFFFF); + } } static void inst2sse(TB_CGEmitter* restrict e, InstType type, const Val* a, const Val* b, TB_X86_DataType dt) { diff --git a/tb/x64/x64_gen.inc b/tb/x64/x64_gen.inc new file mode 100644 index 00000000..583692ef --- /dev/null +++ b/tb/x64/x64_gen.inc @@ -0,0 +1,27 @@ +// Hello, World! +typedef enum X86NodeType { + x86_int3, + x86_add, + x86_or, + x86_and, + x86_sub, + x86_xor, + x86_cmp, + x86_mov, + x86_test, +} + +static size_t extra_bytes(TB_Node* n) { + switch (n->type) { + case x86_add: return sizeof(X86MemOp); + case x86_or: return sizeof(X86MemOp); + case x86_and: return sizeof(X86MemOp); + case x86_sub: return sizeof(X86MemOp); + case x86_xor: return sizeof(X86MemOp); + case x86_cmp: return sizeof(X86MemOp); + case x86_mov: return sizeof(X86MemOp); + case x86_test: return sizeof(X86MemOp); + default: return 0; + } +} + diff --git a/tb/x64/x64_nodes.inc b/tb/x64/x64_nodes.inc index 96046e45..8a158327 100644 --- a/tb/x64/x64_nodes.inc +++ b/tb/x64/x64_nodes.inc @@ -8,7 +8,7 @@ X(xorimm) X(cmpimm) X(movimm) X(testimm) X(shlimm) X(shrimm) X(sarimm) X(rolimm) X(rorimm) // misc // sxt_a2d is CDQ and CQO since they sign extend the (e|r)Ax reg to (e|r)Dx -X(lea) X(cmovcc) X(imulimm) X(div) X(idiv) X(sxt_a2d) +X(lea) X(cmovcc) X(imulimm) X(div) X(idiv) X(sxt_a2d) X(neg) // casts X(movsx8) X(movzx8) diff --git a/tb/x64/x64_target.c b/tb/x64/x64_target.c index d320e9e6..999a0056 100644 --- a/tb/x64/x64_target.c +++ b/tb/x64/x64_target.c @@ -24,16 +24,22 @@ enum { MODE_ST, // mem <- reg }; +enum { + HAS_IMMEDATE = 1, +}; + // node with X86MemOp (mov, add, and...) will have this layout of inputs: // [1] mem // [2] base (or first src) // [3] idx -// [4] val +// [4] val (only if flags' HAS_IMMEDATE is unset) typedef struct { uint8_t mode : 2; uint8_t scale : 2; uint8_t cond : 4; + uint8_t flags; TB_DataType dt; + int32_t disp; int32_t imm; } X86MemOp; @@ -57,6 +63,8 @@ typedef enum X86NodeType { #include "x64_nodes.inc" } X86NodeType; +// #include "x64_gen.inc" + static bool can_gvn(TB_Node* n) { return true; } @@ -301,7 +309,8 @@ static int node_2addr(TB_Node* n) { case x86_vmin: case x86_vmax: case x86_vdiv: case x86_vxor: { X86MemOp* op = TB_NODE_GET_EXTRA(n); - return op->mode == MODE_ST ? -1 : 4; + if (op->mode == MODE_ST) return -1; + return 4; } case x86_mov: @@ -316,6 +325,9 @@ static int node_2addr(TB_Node* n) { return op->mode == MODE_REG ? 2 : 0; } + case x86_neg: + return 1; + // ANY_GPR = OP(COND, shared: ANY_GPR, ANY_GPR) case x86_cmovcc: return 2; @@ -464,8 +476,7 @@ static bool same_mem_edge(TB_Node* ld_mem, TB_Node* st_mem) { // store(binop(load(a), b)) static bool can_folded_store(TB_Node* mem, TB_Node* addr, TB_Node* n) { - if ((n->type >= TB_AND && n->type <= TB_SUB) || - (n->type >= TB_FADD && n->type <= TB_FMAX)) { + if (n->type >= TB_AND && n->type <= TB_SUB) { return n->inputs[1]->type == TB_LOAD && same_mem_edge(n->inputs[1]->inputs[1], mem) && @@ -1047,6 +1058,15 @@ static TB_Node* node_isel(Ctx* restrict ctx, TB_Function* f, TB_Node* n) { } } + // negate + if (n->type == TB_SUB && n->inputs[1]->type == TB_ICONST && TB_NODE_GET_EXTRA_T(n->inputs[1], TB_NodeInt)->value == 0) { + n->type = x86_neg; + set_input(f, n, n->inputs[2], 1); + set_input(f, n, NULL, 2); + n->input_count = 2; + return n; + } + TB_Node* op = tb_alloc_node(f, x86_lea, n->dt, 5, sizeof(X86MemOp)); X86MemOp* op_extra = TB_NODE_GET_EXTRA(op); op_extra->mode = MODE_LD; @@ -1075,8 +1095,7 @@ static TB_Node* node_isel(Ctx* restrict ctx, TB_Function* f, TB_Node* n) { } int32_t x; - if (op->type >= x86_add && op->type <= x86_test && - try_for_imm32(rhs->dt, rhs, &x)) { + if (op->type >= x86_add && op->type <= x86_test && try_for_imm32(rhs->dt, rhs, &x)) { op_extra->imm = x; op->type += (x86_andimm - x86_and); } else { @@ -1478,11 +1497,6 @@ static RegMask* node_constraint(Ctx* restrict ctx, TB_Node* n, RegMask** ins) { return ctx->normie_mask[REG_CLASS_XMM]; } - case TB_NEG: { - if (ins) { ins[1] = ctx->normie_mask[REG_CLASS_GPR]; } - return ctx->normie_mask[REG_CLASS_GPR]; - } - case TB_INT2FLOAT: case TB_UINT2FLOAT: { if (ins) { ins[1] = ctx->normie_mask[REG_CLASS_XMM]; } @@ -1565,6 +1579,10 @@ static RegMask* node_constraint(Ctx* restrict ctx, TB_Node* n, RegMask** ins) { return &TB_REG_EMPTY; } + case x86_neg: + if (ins) { ins[1] = ctx->normie_mask[REG_CLASS_GPR]; } + return ctx->normie_mask[REG_CLASS_GPR]; + case x86_imulimm: if (ins) { ins[1] = ctx->normie_mask[REG_CLASS_GPR]; } return ctx->normie_mask[REG_CLASS_GPR]; @@ -1859,7 +1877,7 @@ static void bundle_emit(Ctx* restrict ctx, TB_CGEmitter* e, Bundle* bundle) { j += snprintf(buf+j, BUF_SIZE-j, "%%%-3u: ", n->gvn); - int dst = ctx->vreg_map[n->gvn]; + int dst = n->gvn < aarray_length(ctx->vreg_map) ? ctx->vreg_map[n->gvn] : 0; if (dst > 0) { j += snprintf(buf+j, BUF_SIZE-j, "V%-3d", dst); } else { @@ -1867,7 +1885,7 @@ static void bundle_emit(Ctx* restrict ctx, TB_CGEmitter* e, Bundle* bundle) { } j += snprintf(buf+j, BUF_SIZE-j, " = %-14s (", tb_node_get_name(n->type)); FOR_N(i, 0, n->input_count) { - int src = n->inputs[i] ? ctx->vreg_map[n->inputs[i]->gvn] : 0; + int src = n->inputs[i] && n->inputs[i]->gvn < aarray_length(ctx->vreg_map) ? ctx->vreg_map[n->inputs[i]->gvn] : 0; if (src > 0) { j += snprintf(buf+j, BUF_SIZE-j, " V%-3d", src); } else { @@ -2081,14 +2099,14 @@ static void bundle_emit(Ctx* restrict ctx, TB_CGEmitter* e, Bundle* bundle) { break; } - case TB_NEG: { + case x86_neg: { TB_X86_DataType dt = legalize_int(n->dt); Val dst = op_at(ctx, n); Val src = op_at(ctx, n->inputs[1]); if (!is_value_match(&dst, &src)) { __(MOV, dt, &dst, &src); } - __(NEG, dt, &dst, &dst); + __(NEG, dt, &dst); break; } @@ -2426,8 +2444,10 @@ static void bundle_emit(Ctx* restrict ctx, TB_CGEmitter* e, Bundle* bundle) { }; TB_X86_DataType dt = legalize_int(n->inputs[2]->dt); - if (n->type == x86_movsx8 || n->type == x86_movsx16) { + if (n->type == x86_movzx8 || n->type == x86_movzx16) { dt = TB_X86_DWORD; + } else if (n->type == x86_movsx32) { + dt = TB_X86_QWORD; } Val dst = op_at(ctx, n); @@ -2597,12 +2617,14 @@ static int node_latency(TB_Function* f, TB_Node* n, TB_Node* end) { switch (n->type) { case x86_vdiv: clk = 11; break; case x86_imulimm: clk = 3; break; + case x86_mov: clk = 0; break; + case x86_vmov: clk = 0; break; default: clk = 1; break; } if (op->mode == MODE_LD) clk += 3; // every store op except for x86_mov will do both a ld(3 clks) + st(4 clks) - if (op->mode == MODE_ST) clk += (n->type != x86_mov ? 7 : 4); + if (op->mode == MODE_ST) clk += ((n->type != x86_mov && n->type != x86_vmov) ? 7 : 4); return clk; } @@ -2650,7 +2672,7 @@ static void pre_emit(Ctx* restrict ctx, TB_CGEmitter* e, TB_Node* root) { // inserts a chkstk call if we use too much stack if (ctx->f->super.module->chkstk_extern && stack_usage >= param_descs[ctx->abi_index].chkstk_limit) { - assert(ctx->f->super.module->chkstk_extern); + TB_ASSERT(ctx->f->super.module->chkstk_extern); ctx->f->super.module->uses_chkstk++; Val sym = val_global(ctx->f->super.module->chkstk_extern, 0); diff --git a/tests/csmith/f0.c b/tests/csmith/f0.c new file mode 100644 index 00000000..f8284fbd --- /dev/null +++ b/tests/csmith/f0.c @@ -0,0 +1,1687 @@ +/* + * This is a RANDOMLY GENERATED PROGRAM. + * + * Generator: csmith 2.4.0 + * Git version: 0ec6f1b + * Options: (none) + * Seed: 5951167998698013427 + */ + +#include "csmith.h" + + +static long __undefined; + +/* --- Struct/Union Declarations --- */ +union U0 { + uint32_t f0; +}; + +union U1 { + uint16_t f0; + uint64_t f1; + uint16_t f2; + uint32_t f3; +}; + +/* --- GLOBAL VARIABLES --- */ +static volatile int32_t g_2 = 0x6BACD795L;/* VOLATILE GLOBAL g_2 */ +static int32_t g_3 = (-6L); +static uint16_t g_11 = 0x4650L; +static uint16_t g_35 = 0UL; +static int32_t *g_56 = &g_3; +static int32_t **g_55[1][5][3] = {{{&g_56,&g_56,&g_56},{&g_56,&g_56,&g_56},{&g_56,&g_56,&g_56},{&g_56,&g_56,&g_56},{&g_56,&g_56,&g_56}}}; +static int32_t g_59 = 0xE1FE01AFL; +static int8_t g_100 = (-1L); +static int8_t *g_99 = &g_100; +static union U0 g_118 = {0xAE65B8C0L}; +static union U1 g_122 = {0x5CA7L}; +static int8_t *g_130[5][2] = {{&g_100,&g_100},{&g_100,&g_100},{&g_100,&g_100},{&g_100,&g_100},{&g_100,&g_100}}; +static int8_t **g_129 = &g_130[1][1]; +static int32_t g_135 = 0L; +static int32_t g_137 = 6L; +static int16_t g_143 = 0x3715L; +static int32_t g_145 = 0x58142351L; +static const int8_t g_207 = 0x34L; +static int64_t g_214[3][6] = {{1L,0xFE2393D1FB21830ALL,(-7L),0x9850909C1F5AF660LL,(-7L),0xFE2393D1FB21830ALL},{(-7L),1L,8L,(-1L),(-1L),8L},{(-7L),(-7L),(-1L),0x9850909C1F5AF660LL,3L,0x9850909C1F5AF660LL}}; +static int64_t g_267 = 0x99DEFDC76B746737LL; +static volatile int32_t * volatile *g_280 = (void*)0; +static uint16_t g_305 = 0x45E6L; +static uint16_t g_307[10][4] = {{1UL,1UL,1UL,65533UL},{1UL,0x6941L,65533UL,65533UL},{0x0618L,0x0618L,1UL,0x6941L},{0x6941L,1UL,1UL,1UL},{0x0618L,0UL,65533UL,1UL},{1UL,0UL,0UL,1UL},{0UL,1UL,0x0618L,0x6941L},{0UL,0x0618L,0UL,65533UL},{1UL,0x6941L,65533UL,65533UL},{0x0618L,0x0618L,1UL,0x6941L}}; +static uint32_t g_364 = 18446744073709551615UL; +static uint64_t g_417 = 0xF00EEE758F6DF472LL; +static int32_t g_431 = 0xB172DE8AL; +static uint8_t g_441 = 0UL; +static uint16_t *g_456 = &g_122.f2; +static int8_t ***g_529 = &g_129; +static int8_t *** const *g_528[9] = {&g_529,&g_529,&g_529,&g_529,&g_529,&g_529,&g_529,&g_529,&g_529}; +static int8_t *** const **g_527[4] = {&g_528[4],&g_528[4],&g_528[4],&g_528[4]}; +static volatile union U0 g_589 = {6UL};/* VOLATILE GLOBAL g_589 */ +static volatile union U0 g_590 = {0x3B5174BCL};/* VOLATILE GLOBAL g_590 */ +static const volatile union U0 * volatile g_588[1][8][6] = {{{&g_589,&g_589,&g_589,&g_589,&g_589,&g_589},{&g_589,&g_589,&g_589,&g_589,&g_589,&g_589},{&g_589,&g_589,&g_589,&g_589,&g_589,&g_589},{&g_589,&g_589,&g_589,&g_589,&g_589,&g_589},{&g_589,&g_589,&g_589,&g_589,&g_589,&g_589},{&g_589,&g_589,&g_589,&g_589,&g_589,&g_589},{&g_589,&g_589,&g_589,&g_589,&g_589,&g_589},{&g_589,&g_589,&g_589,&g_589,&g_589,&g_589}}}; +static const volatile union U0 * volatile * const g_587 = &g_588[0][6][0]; +static const volatile union U0 * volatile * const volatile *g_586 = &g_587; +static uint32_t * volatile g_654 = &g_118.f0;/* VOLATILE GLOBAL g_654 */ +static uint32_t * volatile * volatile g_653 = &g_654;/* VOLATILE GLOBAL g_653 */ +static uint32_t * volatile * volatile *g_652 = &g_653; +static int64_t *g_712 = (void*)0; +static union U1 g_852[2] = {{1UL},{1UL}}; +static int32_t g_878 = 0xA3CEA4CDL; +static uint32_t *g_896 = &g_118.f0; +static uint32_t **g_895 = &g_896; +static int8_t g_933 = 2L; +static int8_t g_935 = 0xE8L; +static uint16_t g_1009[10][4][6] = {{{0x4AE5L,1UL,65528UL,0xDE6EL,0x4AE5L,0x94A9L},{1UL,65535UL,65535UL,0x94A9L,0x4AE5L,0xDE6EL},{0UL,1UL,0x5987L,65535UL,1UL,1UL},{1UL,5UL,65535UL,0x66E2L,0x66E2L,65535UL}},{{1UL,1UL,65528UL,65535UL,65535UL,0x4AE5L},{0UL,0x5987L,5UL,0x94A9L,0x66E2L,65528UL},{1UL,0UL,5UL,0xDE6EL,1UL,0x4AE5L},{0x4AE5L,0xDE6EL,65528UL,1UL,0x4AE5L,65535UL}},{{1UL,0x4AE5L,65535UL,65535UL,0x4AE5L,1UL},{0UL,0xDE6EL,0x5987L,0x4AE5L,1UL,0xDE6EL},{1UL,0UL,65535UL,65528UL,0x66E2L,0x94A9L},{1UL,0x5987L,65528UL,0x4AE5L,65535UL,65535UL}},{{0UL,1UL,5UL,65535UL,0x66E2L,0x66E2L},{1UL,5UL,5UL,1UL,1UL,65535UL},{0x4AE5L,1UL,65528UL,0xDE6EL,0x4AE5L,0x94A9L},{1UL,65535UL,65528UL,0x66E2L,0x94A9L,5UL}},{{0x4AE5L,0UL,4UL,65535UL,65535UL,0UL},{65535UL,65535UL,65528UL,1UL,1UL,65528UL},{65535UL,65535UL,0x5987L,65535UL,1UL,0x94A9L},{0x4AE5L,4UL,65535UL,0x66E2L,1UL,0x5987L}},{{0UL,0x4AE5L,65535UL,5UL,65535UL,0x94A9L},{0x94A9L,5UL,0x5987L,0UL,0x94A9L,65528UL},{0UL,0x94A9L,65528UL,65528UL,0x94A9L,0UL},{0x4AE5L,5UL,4UL,0x94A9L,65535UL,5UL}},{{65535UL,0x4AE5L,65528UL,0x5987L,1UL,0x66E2L},{65535UL,4UL,0x5987L,0x94A9L,1UL,65535UL},{0x4AE5L,65535UL,65535UL,65528UL,1UL,1UL},{0UL,65535UL,65535UL,0UL,65535UL,65535UL}},{{0x94A9L,0UL,0x5987L,5UL,0x94A9L,0x66E2L},{0UL,65535UL,65528UL,0x66E2L,0x94A9L,5UL},{0x4AE5L,0UL,4UL,65535UL,65535UL,0UL},{65535UL,65535UL,65528UL,1UL,1UL,65528UL}},{{65535UL,65535UL,0x5987L,65535UL,1UL,0x94A9L},{0x4AE5L,4UL,65535UL,0x66E2L,1UL,0x5987L},{0UL,0x4AE5L,65535UL,5UL,65535UL,0x94A9L},{0x94A9L,5UL,0x5987L,0UL,0x94A9L,65528UL}},{{0UL,0x94A9L,65528UL,65528UL,0x94A9L,0UL},{0x4AE5L,5UL,4UL,0x94A9L,65535UL,5UL},{65535UL,0x4AE5L,65528UL,0x5987L,1UL,0x66E2L},{65535UL,4UL,0x5987L,0x94A9L,1UL,65535UL}}}; +static uint8_t *g_1019 = &g_441; +static uint8_t **g_1018[7][6] = {{&g_1019,&g_1019,&g_1019,&g_1019,&g_1019,&g_1019},{&g_1019,&g_1019,&g_1019,&g_1019,(void*)0,&g_1019},{&g_1019,(void*)0,&g_1019,&g_1019,&g_1019,&g_1019},{&g_1019,&g_1019,&g_1019,&g_1019,&g_1019,&g_1019},{&g_1019,(void*)0,&g_1019,&g_1019,(void*)0,&g_1019},{&g_1019,&g_1019,&g_1019,&g_1019,&g_1019,&g_1019},{&g_1019,&g_1019,&g_1019,&g_1019,(void*)0,&g_1019}}; +static const uint8_t g_1056[1] = {252UL}; +static union U0 *g_1092 = &g_118; +static int64_t *g_1125 = &g_214[1][2]; +static const int32_t g_1137 = 0xC78F6367L; +static uint64_t g_1214 = 0UL; +static volatile uint8_t * volatile *g_1238[5] = {(void*)0,(void*)0,(void*)0,(void*)0,(void*)0}; +static volatile uint8_t * volatile * volatile *g_1237 = &g_1238[2]; +static volatile uint8_t * volatile * volatile * volatile *g_1236[10][7][3] = {{{(void*)0,&g_1237,(void*)0},{&g_1237,&g_1237,&g_1237},{&g_1237,&g_1237,&g_1237},{&g_1237,(void*)0,&g_1237},{&g_1237,&g_1237,&g_1237},{&g_1237,(void*)0,&g_1237},{&g_1237,&g_1237,&g_1237}},{{&g_1237,&g_1237,&g_1237},{&g_1237,(void*)0,&g_1237},{(void*)0,&g_1237,&g_1237},{&g_1237,(void*)0,&g_1237},{(void*)0,&g_1237,&g_1237},{(void*)0,&g_1237,&g_1237},{(void*)0,&g_1237,&g_1237}},{{&g_1237,(void*)0,&g_1237},{(void*)0,&g_1237,&g_1237},{(void*)0,&g_1237,(void*)0},{(void*)0,&g_1237,(void*)0},{&g_1237,&g_1237,&g_1237},{(void*)0,&g_1237,&g_1237},{&g_1237,(void*)0,&g_1237}},{{&g_1237,&g_1237,&g_1237},{&g_1237,(void*)0,&g_1237},{&g_1237,&g_1237,&g_1237},{&g_1237,(void*)0,(void*)0},{&g_1237,&g_1237,(void*)0},{&g_1237,&g_1237,&g_1237},{&g_1237,&g_1237,&g_1237}},{{(void*)0,&g_1237,&g_1237},{(void*)0,&g_1237,&g_1237},{&g_1237,&g_1237,&g_1237},{&g_1237,&g_1237,&g_1237},{&g_1237,(void*)0,&g_1237},{&g_1237,&g_1237,&g_1237},{&g_1237,(void*)0,&g_1237}},{{(void*)0,&g_1237,&g_1237},{(void*)0,(void*)0,&g_1237},{&g_1237,&g_1237,&g_1237},{&g_1237,&g_1237,&g_1237},{&g_1237,&g_1237,&g_1237},{&g_1237,&g_1237,&g_1237},{&g_1237,&g_1237,(void*)0}},{{(void*)0,(void*)0,(void*)0},{(void*)0,&g_1237,(void*)0},{&g_1237,&g_1237,&g_1237},{&g_1237,&g_1237,&g_1237},{&g_1237,(void*)0,&g_1237},{&g_1237,&g_1237,&g_1237},{&g_1237,(void*)0,&g_1237}},{{&g_1237,&g_1237,&g_1237},{&g_1237,&g_1237,&g_1237},{&g_1237,(void*)0,&g_1237},{(void*)0,&g_1237,&g_1237},{&g_1237,(void*)0,&g_1237},{(void*)0,&g_1237,&g_1237},{(void*)0,&g_1237,&g_1237}},{{(void*)0,&g_1237,&g_1237},{&g_1237,(void*)0,&g_1237},{(void*)0,&g_1237,&g_1237},{(void*)0,&g_1237,(void*)0},{(void*)0,&g_1237,(void*)0},{&g_1237,&g_1237,(void*)0},{&g_1237,&g_1237,&g_1237}},{{&g_1237,(void*)0,&g_1237},{(void*)0,&g_1237,&g_1237},{(void*)0,(void*)0,&g_1237},{&g_1237,&g_1237,(void*)0},{&g_1237,&g_1237,&g_1237},{&g_1237,&g_1237,&g_1237},{&g_1237,&g_1237,(void*)0}}}; +static int32_t * volatile *g_1303[10] = {&g_56,&g_56,&g_56,&g_56,&g_56,&g_56,&g_56,&g_56,&g_56,&g_56}; +static int32_t * volatile * volatile *g_1302 = &g_1303[6]; +static int32_t * volatile * volatile **g_1301[9][9] = {{&g_1302,&g_1302,&g_1302,(void*)0,(void*)0,&g_1302,&g_1302,&g_1302,&g_1302},{(void*)0,&g_1302,&g_1302,&g_1302,&g_1302,&g_1302,&g_1302,(void*)0,&g_1302},{&g_1302,&g_1302,&g_1302,(void*)0,&g_1302,(void*)0,&g_1302,&g_1302,&g_1302},{&g_1302,&g_1302,&g_1302,&g_1302,(void*)0,&g_1302,&g_1302,(void*)0,(void*)0},{&g_1302,&g_1302,(void*)0,&g_1302,&g_1302,&g_1302,&g_1302,(void*)0,&g_1302},{&g_1302,(void*)0,&g_1302,&g_1302,&g_1302,&g_1302,&g_1302,&g_1302,(void*)0},{&g_1302,&g_1302,&g_1302,&g_1302,(void*)0,&g_1302,(void*)0,&g_1302,&g_1302},{(void*)0,(void*)0,&g_1302,(void*)0,&g_1302,&g_1302,&g_1302,&g_1302,&g_1302},{&g_1302,&g_1302,&g_1302,&g_1302,&g_1302,&g_1302,&g_1302,&g_1302,&g_1302}}; +static volatile int32_t g_1331 = 0L;/* VOLATILE GLOBAL g_1331 */ +static volatile int32_t g_1332 = (-9L);/* VOLATILE GLOBAL g_1332 */ +static volatile int32_t g_1333 = 4L;/* VOLATILE GLOBAL g_1333 */ +static volatile int32_t g_1334[4][9][3] = {{{0x479DF922L,(-1L),3L},{0x1622EC52L,3L,0x1B89E708L},{8L,0x1C6DA929L,0x521F7E3EL},{0xFA5D1B18L,0x93422B94L,7L},{8L,3L,0x93422B94L},{0x1622EC52L,0L,3L},{0x479DF922L,0x10AE97C3L,0xFC8ECF11L},{0x2EAEE4C6L,(-2L),0L},{3L,0x249F1CF9L,0x40CD8A73L}},{{0x249F1CF9L,(-1L),(-2L)},{4L,0x6F995B3DL,8L},{(-1L),0x6F995B3DL,0x19835C20L},{0xFC8ECF11L,(-1L),0x3C0D7563L},{0L,0x249F1CF9L,0x479DF922L},{(-1L),(-2L),0xFA5D1B18L},{0x10AE97C3L,0x10AE97C3L,0x61FB6395L},{(-1L),0L,0x2C70A1FBL},{0x1C6DA929L,3L,(-1L)}},{{0x40CD8A73L,0x93422B94L,0x5F97C900L},{7L,0x1C6DA929L,(-1L)},{0xA47D0AEEL,3L,0x2C70A1FBL},{(-2L),(-1L),0x61FB6395L},{(-1L),7L,0xFA5D1B18L},{0xF4060BBDL,0x31D584C0L,0x479DF922L},{(-2L),0xF4060BBDL,0x5F97C900L},{3L,0x2EAEE4C6L,0L},{(-2L),(-1L),3L}},{{(-2L),0x5F97C900L,0x179FC3E7L},{3L,(-2L),8L},{0x179FC3E7L,0xA47D0AEEL,1L},{0x2C70A1FBL,0x31D584C0L,0x31D584C0L},{0x86656926L,0x1B89E708L,(-2L)},{0L,0x19835C20L,0x10AE97C3L},{(-2L),0x6F995B3DL,(-1L)},{(-1L),0x179FC3E7L,0x2EAEE4C6L},{8L,0x6F995B3DL,4L}}}; +static volatile int32_t g_1335 = 0x3761DC2BL;/* VOLATILE GLOBAL g_1335 */ +static volatile int32_t g_1336 = 0x4D665DD7L;/* VOLATILE GLOBAL g_1336 */ +static volatile int32_t g_1337 = 0xC3225845L;/* VOLATILE GLOBAL g_1337 */ +static volatile int32_t g_1338 = 0xE4B2EE40L;/* VOLATILE GLOBAL g_1338 */ +static volatile int32_t g_1339 = 0x6A4BF322L;/* VOLATILE GLOBAL g_1339 */ +static volatile int32_t * const g_1330[4][10][1] = {{{&g_1336},{&g_1333},{&g_1334[0][5][0]},{&g_1338},{&g_1334[0][5][0]},{&g_1333},{&g_1336},{(void*)0},{&g_1339},{(void*)0}},{{(void*)0},{(void*)0},{&g_1339},{(void*)0},{&g_1336},{&g_1333},{&g_1334[0][5][0]},{&g_1338},{&g_1334[0][5][0]},{&g_1333}},{{&g_1336},{(void*)0},{&g_1339},{(void*)0},{(void*)0},{(void*)0},{&g_1339},{(void*)0},{&g_1336},{&g_1333}},{{&g_1334[0][5][0]},{&g_1338},{&g_1334[0][5][0]},{&g_1333},{&g_1336},{(void*)0},{&g_1339},{(void*)0},{(void*)0},{(void*)0}}}; +static volatile int32_t * const * volatile g_1329 = &g_1330[2][8][0];/* VOLATILE GLOBAL g_1329 */ +static volatile int32_t * const *g_1340 = (void*)0; +static volatile int32_t * const * volatile *g_1328[2][9][3] = {{{&g_1340,&g_1340,&g_1340},{&g_1340,&g_1340,(void*)0},{&g_1340,&g_1340,(void*)0},{&g_1340,&g_1340,&g_1340},{&g_1340,&g_1340,(void*)0},{&g_1340,&g_1340,(void*)0},{&g_1340,&g_1340,&g_1340},{&g_1340,&g_1340,(void*)0},{&g_1340,&g_1340,(void*)0}},{{&g_1340,&g_1340,&g_1340},{&g_1340,&g_1340,(void*)0},{&g_1340,&g_1340,(void*)0},{&g_1340,&g_1340,&g_1340},{&g_1340,&g_1340,(void*)0},{&g_1340,&g_1340,(void*)0},{&g_1340,&g_1340,&g_1340},{&g_1340,&g_1340,(void*)0},{&g_1340,&g_1340,(void*)0}}}; +static uint32_t g_1374 = 0x2BC6B0C9L; +static uint8_t g_1433 = 255UL; +static uint8_t g_1481 = 0xCAL; +static uint8_t ****g_1515 = (void*)0; +static uint8_t *****g_1514[3] = {&g_1515,&g_1515,&g_1515}; +static uint8_t *****g_1516 = &g_1515; +static uint32_t ** volatile *g_1533 = &g_895; +static uint32_t ** volatile ** const g_1532 = &g_1533; +static uint32_t ** volatile ** const volatile *g_1531[4] = {&g_1532,&g_1532,&g_1532,&g_1532}; +static const volatile uint16_t *g_1553 = (void*)0; +static const volatile uint16_t * volatile *g_1552 = &g_1553; +static const volatile uint16_t * volatile **g_1551 = &g_1552; +static uint32_t g_1658 = 0xF6E4E46BL; +static union U0 g_1665 = {4294967286UL}; +static int32_t g_1689[4] = {0x5A69D29BL,0x5A69D29BL,0x5A69D29BL,0x5A69D29BL}; +static const int32_t *g_1703 = &g_135; +static const int32_t **g_1702 = &g_1703; +static const int32_t ***g_1701 = &g_1702; +static volatile int16_t g_1978 = 0x2EBDL;/* VOLATILE GLOBAL g_1978 */ +static volatile int16_t *g_1977 = &g_1978; +static volatile int16_t **g_1976 = &g_1977; +static uint16_t g_1999 = 0x467EL; +static int16_t g_2095 = 0x10C3L; +static int32_t g_2150 = 3L; +static volatile union U0 g_2157 = {0x93C394A7L};/* VOLATILE GLOBAL g_2157 */ +static volatile union U0 * volatile g_2156[6] = {&g_2157,&g_2157,&g_2157,&g_2157,&g_2157,&g_2157}; +static volatile union U0 * volatile *g_2155 = &g_2156[1]; +static volatile union U0 * volatile **g_2154[4][2] = {{&g_2155,&g_2155},{&g_2155,&g_2155},{&g_2155,&g_2155},{&g_2155,&g_2155}}; +static volatile union U0 * volatile *** volatile g_2153 = &g_2154[3][0];/* VOLATILE GLOBAL g_2153 */ +static volatile union U0 * volatile *** volatile *g_2152 = &g_2153; +static int32_t *g_2220 = (void*)0; +static int32_t **g_2219 = &g_2220; +static int8_t ****g_2240 = &g_529; +static int16_t g_2288 = 1L; +static const volatile union U0 g_2337 = {0x9297C0A9L};/* VOLATILE GLOBAL g_2337 */ +static const volatile union U0 *g_2336 = &g_2337; +static const volatile union U0 **g_2335[5][6] = {{&g_2336,&g_2336,&g_2336,&g_2336,&g_2336,&g_2336},{&g_2336,&g_2336,&g_2336,&g_2336,&g_2336,&g_2336},{&g_2336,&g_2336,&g_2336,&g_2336,&g_2336,&g_2336},{&g_2336,&g_2336,&g_2336,&g_2336,&g_2336,&g_2336},{&g_2336,&g_2336,&g_2336,&g_2336,&g_2336,&g_2336}}; +static const volatile union U0 ***g_2334 = &g_2335[1][5]; +static int32_t * volatile g_2339 = &g_135;/* VOLATILE GLOBAL g_2339 */ +static volatile uint32_t * volatile *g_2364[6] = {(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0}; +static union U1 ** volatile g_2433 = (void*)0;/* VOLATILE GLOBAL g_2433 */ +static volatile union U1 g_2437 = {1UL};/* VOLATILE GLOBAL g_2437 */ +static volatile union U1 g_2438 = {65535UL};/* VOLATILE GLOBAL g_2438 */ +static volatile union U1 g_2439 = {0x85D4L};/* VOLATILE GLOBAL g_2439 */ +static volatile union U1 g_2440 = {65535UL};/* VOLATILE GLOBAL g_2440 */ +static volatile union U1 g_2441 = {5UL};/* VOLATILE GLOBAL g_2441 */ +static volatile union U1 g_2442 = {65533UL};/* VOLATILE GLOBAL g_2442 */ +static volatile union U1 g_2443 = {0x0077L};/* VOLATILE GLOBAL g_2443 */ +static volatile union U1 *g_2436[8][8] = {{&g_2441,(void*)0,(void*)0,&g_2441,&g_2441,(void*)0,&g_2439,(void*)0},{&g_2437,&g_2441,(void*)0,&g_2441,&g_2437,&g_2437,&g_2441,(void*)0},{&g_2437,&g_2437,&g_2441,(void*)0,&g_2441,&g_2437,&g_2437,&g_2441},{(void*)0,&g_2441,&g_2441,(void*)0,&g_2439,(void*)0,&g_2441,&g_2441},{&g_2441,&g_2439,(void*)0,(void*)0,&g_2439,&g_2441,&g_2439,(void*)0},{(void*)0,&g_2439,(void*)0,&g_2441,&g_2441,(void*)0,&g_2439,(void*)0},{&g_2437,&g_2441,(void*)0,&g_2441,&g_2437,&g_2437,&g_2441,(void*)0},{&g_2437,&g_2437,&g_2441,(void*)0,&g_2441,&g_2437,&g_2437,&g_2441}}; +static volatile union U1 **g_2435 = &g_2436[5][1]; +static int32_t *** volatile g_2509[7][3][10] = {{{&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219},{&g_2219,&g_2219,(void*)0,&g_2219,&g_2219,(void*)0,&g_2219,&g_2219,(void*)0,&g_2219},{&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219}},{{&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219},{&g_2219,&g_2219,(void*)0,&g_2219,&g_2219,(void*)0,&g_2219,&g_2219,(void*)0,&g_2219},{&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219}},{{&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219},{&g_2219,&g_2219,(void*)0,&g_2219,&g_2219,(void*)0,&g_2219,&g_2219,(void*)0,&g_2219},{&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219}},{{&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219},{&g_2219,&g_2219,(void*)0,&g_2219,&g_2219,(void*)0,&g_2219,&g_2219,(void*)0,&g_2219},{&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219}},{{&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,(void*)0,(void*)0},{&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219},{&g_2219,(void*)0,(void*)0,&g_2219,(void*)0,(void*)0,&g_2219,(void*)0,(void*)0,&g_2219}},{{(void*)0,&g_2219,(void*)0,(void*)0,&g_2219,(void*)0,(void*)0,&g_2219,(void*)0,(void*)0},{&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219},{&g_2219,(void*)0,(void*)0,&g_2219,(void*)0,(void*)0,&g_2219,(void*)0,(void*)0,&g_2219}},{{(void*)0,&g_2219,(void*)0,(void*)0,&g_2219,(void*)0,(void*)0,&g_2219,(void*)0,(void*)0},{&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219,&g_2219},{&g_2219,(void*)0,(void*)0,&g_2219,(void*)0,(void*)0,&g_2219,(void*)0,(void*)0,&g_2219}}}; +static int8_t g_2545 = 1L; +static volatile int8_t g_2635 = 0x93L;/* VOLATILE GLOBAL g_2635 */ +static int32_t g_2660 = 0x58511230L; +static volatile int8_t * volatile **g_2698 = (void*)0; +static int16_t *g_2710 = &g_2095; +static int16_t **g_2709[10][8] = {{&g_2710,&g_2710,&g_2710,&g_2710,&g_2710,&g_2710,&g_2710,&g_2710},{&g_2710,&g_2710,&g_2710,&g_2710,&g_2710,&g_2710,&g_2710,&g_2710},{&g_2710,&g_2710,&g_2710,&g_2710,&g_2710,&g_2710,&g_2710,&g_2710},{&g_2710,&g_2710,&g_2710,&g_2710,(void*)0,&g_2710,(void*)0,&g_2710},{(void*)0,&g_2710,(void*)0,&g_2710,&g_2710,&g_2710,&g_2710,&g_2710},{&g_2710,&g_2710,&g_2710,(void*)0,&g_2710,&g_2710,&g_2710,&g_2710},{&g_2710,&g_2710,&g_2710,&g_2710,&g_2710,&g_2710,&g_2710,&g_2710},{(void*)0,&g_2710,&g_2710,&g_2710,(void*)0,&g_2710,&g_2710,&g_2710},{&g_2710,&g_2710,&g_2710,&g_2710,&g_2710,&g_2710,&g_2710,&g_2710},{&g_2710,&g_2710,(void*)0,&g_2710,&g_2710,&g_2710,&g_2710,&g_2710}}; +static int16_t ** const *g_2708 = &g_2709[6][2]; +static int16_t ** const **g_2707 = &g_2708; +static int16_t ** const *** volatile g_2706 = &g_2707;/* VOLATILE GLOBAL g_2706 */ +static uint16_t g_2714 = 0xD1D7L; +static volatile uint8_t g_2718 = 1UL;/* VOLATILE GLOBAL g_2718 */ +static int32_t g_2774[9][1] = {{(-9L)},{0x228480E2L},{(-9L)},{0x228480E2L},{(-9L)},{0x228480E2L},{(-9L)},{0x228480E2L},{(-9L)}}; +static int16_t g_2781 = 0xFE14L; +static volatile uint32_t g_2808[7] = {18446744073709551606UL,18446744073709551612UL,18446744073709551612UL,18446744073709551606UL,18446744073709551612UL,18446744073709551612UL,18446744073709551606UL}; +static const int32_t *g_2810 = &g_59; +static const int32_t ** volatile g_2809 = &g_2810;/* VOLATILE GLOBAL g_2809 */ + + +/* --- FORWARD DECLARATIONS --- */ +static union U0 func_1(void); +static int64_t func_27(union U1 p_28); +static int32_t func_40(uint8_t p_41); +static union U0 func_49(int64_t p_50, int32_t ** p_51, int32_t ** p_52, int32_t * p_53, int32_t ** p_54); +static int32_t * func_81(int8_t p_82, const uint16_t p_83); +static int32_t * func_88(int8_t p_89, uint8_t p_90, uint32_t p_91); +static uint16_t func_92(int32_t ** p_93, const int32_t p_94); +static union U0 func_104(uint8_t p_105); +static union U0 func_110(int8_t ** p_111); +static int8_t ** func_112(int32_t ** p_113, int32_t ** p_114, union U0 p_115, int8_t * p_116); + + +/* --- FUNCTIONS --- */ +/* ------------------------------------------ */ +/* + * reads : g_364 g_2438.f0 g_2334 g_2335 g_137 g_56 g_1125 g_214 g_1976 g_1977 g_1978 g_2336 g_2337 g_122.f1 g_307 g_3 g_1019 g_441 g_99 g_1009 g_1702 g_1703 g_122 g_2635 g_100 g_1701 g_35 g_2660 g_135 g_2288 g_2339 g_896 g_1137 g_456 g_586 g_587 g_588 g_590 g_589 g_2698 g_118.f0 g_935 g_267 g_305 g_852.f0 g_431 g_2706 g_2714 g_2718 g_1532 g_1533 g_895 g_2710 g_1665.f0 g_1092 g_118 g_653 g_654 g_2153 g_2154 g_2155 g_2156 g_2157 g_2150 g_2774 + * writes: g_3 g_1658 g_135 g_137 g_2545 g_933 g_305 g_935 g_122.f1 g_214 g_100 g_307 g_1214 g_1703 g_118.f0 g_122.f2 g_35 g_441 g_852 g_122.f0 g_267 g_2707 g_2714 g_2718 g_2095 g_1665.f0 g_56 + */ +static union U0 func_1(void) +{ /* block id: 0 */ + int8_t l_2286 = 0x8FL; + uint64_t l_2289 = 0UL; + uint8_t *l_2308 = &g_441; + int32_t l_2315 = 0x35C9623FL; + int8_t l_2317 = 0L; + int32_t l_2365 = 3L; + uint32_t l_2382 = 0xB20AB791L; + int64_t l_2386 = 0x0A6C2EC38D991BF4LL; + const int64_t *l_2390 = &l_2386; + const int64_t **l_2389 = &l_2390; + uint8_t l_2410 = 0x85L; + uint8_t ****l_2434 = (void*)0; + const uint64_t l_2488 = 0x8C78E4076FA71606LL; + int8_t * const **l_2497 = (void*)0; + union U0 l_2505 = {0x90E5C936L}; + int32_t **l_2508 = &g_2220; + int8_t **l_2542 = &g_130[1][1]; + uint32_t l_2553 = 0x1B89F431L; + union U1 *l_2618 = &g_122; + int32_t l_2621[9] = {0xE66FE87BL,0x707FB6F4L,0xE66FE87BL,0xE66FE87BL,0x707FB6F4L,0xE66FE87BL,0xE66FE87BL,0x707FB6F4L,0xE66FE87BL}; + int16_t l_2636 = 3L; + int64_t l_2643 = (-3L); + uint8_t l_2650 = 0x52L; + int16_t l_2653 = 0L; + int32_t **l_2664 = &g_56; + union U0 **l_2691 = &g_1092; + union U1 **l_2736 = &l_2618; + uint16_t **l_2749 = &g_456; + uint16_t ***l_2748 = &l_2749; + int64_t l_2772 = (-1L); + int32_t l_2818 = 0x1A579D2AL; + union U0 l_2824[3] = {{8UL},{8UL},{8UL}}; + int i; +lbl_2575: + for (g_3 = 0; (g_3 < 23); ++g_3) + { /* block id: 3 */ + uint16_t *l_10 = &g_11; + int32_t l_17 = 0x6C619A80L; + union U1 l_29 = {0xDC16L}; + int16_t *l_2287[6][3][3] = {{{&g_2288,&g_2288,&g_2288},{&g_2288,(void*)0,&g_2288},{&g_2288,&g_2288,&g_2288}},{{&g_2288,&g_2288,&g_2288},{&g_2288,&g_2288,(void*)0},{&g_2288,&g_2288,&g_2288}},{{&g_2288,&g_2288,&g_2288},{&g_2288,(void*)0,(void*)0},{&g_2288,&g_2288,(void*)0}},{{&g_2288,&g_2288,&g_2288},{&g_2288,(void*)0,&g_2288},{&g_2288,&g_2288,&g_2288}},{{&g_2288,&g_2288,&g_2288},{&g_2288,&g_2288,(void*)0},{&g_2288,&g_2288,&g_2288}},{{&g_2288,&g_2288,&g_2288},{&g_2288,(void*)0,(void*)0},{&g_2288,&g_2288,(void*)0}}}; + int32_t l_2290[3][7][5] = {{{0x51E6A045L,0xDADB69EBL,(-10L),1L,(-1L)},{3L,0xB2A123F6L,0L,0xDADB69EBL,6L},{0x51E6A045L,0xDEDA0BE5L,0x26D26517L,5L,0L},{0L,1L,0x496710E1L,0x6180D308L,0L},{0x4F2632C0L,4L,0L,0x496710E1L,0x19C9193DL},{4L,0x26D26517L,0x63535620L,0x496710E1L,0xDEDA0BE5L},{5L,3L,5L,0x6180D308L,5L}},{{0xB173B0BAL,0xB173B0BAL,7L,5L,0xB2A123F6L},{0x63535620L,0L,1L,0xDADB69EBL,0L},{0xA6C423DEL,0x5AC62A2EL,(-1L),1L,0xB900DAA4L},{0xDEDA0BE5L,0L,0xB173B0BAL,0x63535620L,0xDADB69EBL},{0xF8DB93C2L,0xB173B0BAL,0xA6C423DEL,0L,1L},{1L,3L,0L,6L,5L},{0x6180D308L,0x26D26517L,0x153381E5L,0x4F2632C0L,5L}},{{7L,4L,0xB900DAA4L,1L,1L},{0x5AC62A2EL,1L,0x5AC62A2EL,0L,0xDADB69EBL},{0L,0xDEDA0BE5L,7L,(-1L),0xB900DAA4L},{(-1L),0xB2A123F6L,(-1L),0xE036E825L,0L},{4L,0xDADB69EBL,7L,0xB900DAA4L,0xB2A123F6L},{0xB900DAA4L,0x4F2632C0L,0x5AC62A2EL,4L,5L},{0L,(-10L),0xB900DAA4L,0L,0xDEDA0BE5L}}}; + uint8_t *l_2309 = &g_441; + const union U0 *l_2333 = &g_1665; + const union U0 ** const l_2332[2] = {&l_2333,&l_2333}; + const union U0 ** const *l_2331 = &l_2332[0]; + int32_t l_2367 = 0xE03DBD97L; + uint8_t ****l_2368 = (void*)0; + int64_t * const *l_2387 = &g_712; + int8_t *l_2407 = (void*)0; + uint32_t ****l_2417 = (void*)0; + uint32_t *****l_2416 = &l_2417; + const uint32_t l_2418 = 0x2DD8A9ABL; + int64_t l_2450 = 1L; + const uint64_t l_2484 = 18446744073709551606UL; + int8_t l_2487[5]; + int i, j, k; + for (i = 0; i < 5; i++) + l_2487[i] = 1L; + } + for (g_1658 = 0; (g_1658 <= 12); ++g_1658) + { /* block id: 983 */ + int32_t ***l_2510 = (void*)0; + int32_t ***l_2511 = &l_2508; + uint64_t *l_2517 = (void*)0; + uint64_t *l_2518 = (void*)0; + uint64_t *l_2519[8]; + int32_t l_2520 = 0x30439F44L; + int32_t l_2521 = 1L; + int32_t *l_2543 = (void*)0; + int64_t l_2544 = 0L; + int32_t l_2546 = 0x9D9CDE3FL; + uint32_t l_2619[4][5] = {{0UL,0x9424EE37L,0UL,0x9424EE37L,0UL},{0x674D7C29L,0x674D7C29L,0x674D7C29L,0x674D7C29L,0x674D7C29L},{0UL,0x9424EE37L,0UL,0x9424EE37L,0UL},{0x674D7C29L,0x674D7C29L,0x674D7C29L,0x674D7C29L,0x674D7C29L}}; + int i, j; + for (i = 0; i < 8; i++) + l_2519[i] = &g_1214; + (*l_2511) = l_2508; + l_2546 &= (safe_lshift_func_uint32_t_u_s(((~(((l_2289 >= l_2317) | 7L) , (safe_mul_func_int64_t_s_s((((((l_2520 |= g_364) <= (l_2521 | (safe_add_func_uint8_t_u_u((((g_2545 = (safe_sub_func_int16_t_s_s(l_2286, (((((safe_lshift_func_int32_t_s_u((l_2544 |= (~((safe_add_func_uint8_t_u_u((safe_rshift_func_int32_t_s_u((((*g_56) = (func_110(((g_2438.f0 > ((safe_lshift_func_int64_t_s_s(l_2505.f0, (((safe_mod_func_int64_t_s_s((safe_mul_func_uint32_t_u_u((((((safe_mul_func_uint64_t_u_u((safe_unary_minus_func_uint8_t_u(((void*)0 != (*g_2334)))), l_2286)) || l_2521) , 0x3914L) & 0xBD81L) < 0xD7L), l_2521)), l_2386)) != l_2521) < l_2315))) & 0xCEL)) , l_2542)) , (-1L))) < 3L), 18)), l_2521)) != l_2521))), l_2488)) || 5L) == 4294967293UL) >= l_2289) || (*g_1125))))) , 1UL) ^ 0x62FC695F4632DF07LL), l_2286)))) > 0xE882L) && (**g_1976)) ^ l_2505.f0), 0x0C490DDEF2FD9020LL)))) || l_2410), l_2521)); + for (g_933 = 20; (g_933 == (-2)); g_933 = safe_sub_func_int16_t_s_s(g_933, 9)) + { /* block id: 992 */ + int32_t *l_2549 = &l_2521; + int32_t *l_2550 = &g_59; + int32_t *l_2551[4] = {&g_137,&g_137,&g_137,&g_137}; + int32_t l_2552 = (-2L); + uint32_t l_2556 = 6UL; + int i; + --l_2553; + l_2556++; + } + for (g_305 = 2; (g_305 == 31); g_305 = safe_add_func_uint64_t_u_u(g_305, 8)) + { /* block id: 998 */ + int16_t l_2569[9]; + const int8_t *l_2582 = &g_207; + const int8_t **l_2581 = &l_2582; + const int8_t ***l_2580 = &l_2581; + const int8_t ****l_2579[3]; + int32_t l_2605 = 8L; + int i; + for (i = 0; i < 9; i++) + l_2569[i] = 0L; + for (i = 0; i < 3; i++) + l_2579[i] = &l_2580; + (*g_56) = 0L; + for (g_935 = 0; (g_935 >= 3); ++g_935) + { /* block id: 1002 */ + uint64_t l_2572 = 0x3FD43EE1FDABA2F5LL; + int32_t l_2574 = (-3L); + union U1 l_2578[2][4] = {{{0xBEF5L},{0xBEF5L},{0xBEF5L},{0xBEF5L}},{{0xBEF5L},{0xBEF5L},{0xBEF5L},{0xBEF5L}}}; + uint32_t l_2595 = 1UL; + int i, j; + for (g_122.f1 = 0; (g_122.f1 <= 0); g_122.f1 += 1) + { /* block id: 1005 */ + int32_t l_2573[7][8] = {{0x7FE131B2L,1L,1L,(-5L),0x35940DA9L,(-5L),1L,(-3L)},{0xE61FD518L,(-5L),0x0975FDC4L,0x35940DA9L,0xFCA08C83L,0xFCA08C83L,0x35940DA9L,0x0975FDC4L},{0xFCA08C83L,0xFCA08C83L,0x35940DA9L,0x0975FDC4L,(-5L),0xE61FD518L,(-4L),0x37B19FC1L},{(-5L),0x35940DA9L,(-5L),1L,1L,0x7FE131B2L,0x7FAB5EF2L,0x37B19FC1L},{0x35940DA9L,(-10L),0xD4E75E4CL,0x0975FDC4L,1L,0x35940DA9L,1L,0x0975FDC4L},{1L,(-9L),1L,0x35940DA9L,0x2B66B907L,0L,(-9L),(-3L)},{0xF279814EL,0x37B19FC1L,0x00F83D03L,(-5L),0xFCA08C83L,0xB44C7251L,0x2B66B907L,0x00F83D03L}}; + int i, j; + for (l_2544 = 0; (l_2544 <= 0); l_2544 += 1) + { /* block id: 1008 */ + return (*g_2336); + } + (*g_56) |= g_307[(g_122.f1 + 6)][(g_122.f1 + 2)]; + if (((((safe_mul_func_int8_t_s_s((safe_mod_func_uint16_t_u_u((safe_mul_func_int16_t_s_s(l_2569[8], (1UL != (((**g_1976) , &g_1236[3][6][2]) == (void*)0)))), (l_2569[1] & (((-6L) <= l_2572) && (l_2574 = l_2573[2][1]))))), (*g_1019))) , l_2382) , (void*)0) != &g_896)) + { /* block id: 1013 */ + if (g_935) + goto lbl_2575; + if (l_2569[8]) + break; + } + else + { /* block id: 1016 */ + uint32_t l_2593[1][10]; + int32_t l_2594 = 0x2A051C5BL; + uint16_t *l_2602 = &g_307[(g_122.f1 + 6)][(g_122.f1 + 2)]; + uint64_t l_2616 = 18446744073709551610UL; + union U0 l_2617[7] = {{0x0B9A7CBFL},{0x2715FB80L},{0x0B9A7CBFL},{0x0B9A7CBFL},{0x2715FB80L},{0x0B9A7CBFL},{0x0B9A7CBFL}}; + int i, j; + for (i = 0; i < 1; i++) + { + for (j = 0; j < 10; j++) + l_2593[i][j] = 0UL; + } + (*g_56) &= (safe_add_func_int8_t_s_s(((*g_99) = (((l_2578[0][0] , (void*)0) == l_2579[2]) & ((safe_add_func_int64_t_s_s(((*g_1125) = (safe_rshift_func_int32_t_s_u(l_2365, 20))), (-3L))) >= l_2573[0][5]))), (((l_2286 > ((safe_lshift_func_uint8_t_u_u((((safe_mod_func_int64_t_s_s((safe_mod_func_uint64_t_u_u(g_307[9][2], l_2593[0][1])), l_2594)) , 2L) , l_2595), 5)) > (-4L))) & l_2578[0][0].f0) , 0xD6L))); + (*g_56) = ((*g_1125) >= (safe_add_func_int16_t_s_s(((safe_add_func_int16_t_s_s((**g_1976), ((safe_mul_func_uint16_t_u_u((l_2605 = ((*l_2602)--)), g_1009[9][3][3])) && g_214[1][3]))) , (safe_rshift_func_int64_t_s_s((~18446744073709551615UL), (0x95L < (safe_lshift_func_int32_t_s_s((safe_unary_minus_func_uint8_t_u(((l_2595 , l_2573[0][6]) & ((safe_mod_func_uint16_t_u_u(l_2573[2][1], l_2616)) <= (-8L))))), l_2505.f0)))))), 1L))); + return l_2617[3]; + } + } + if (l_2289) + goto lbl_2575; + l_2618 = l_2618; + } + l_2605 = l_2619[3][1]; + } + } + if ((+l_2621[4])) + { /* block id: 1032 */ + int8_t l_2622 = 0xB6L; + union U0 l_2623 = {0x41F4C952L}; + uint64_t *l_2637 = &g_1214; + int32_t *l_2638 = &g_135; + int16_t *l_2702 = &g_2095; + int16_t **l_2701 = &l_2702; + int16_t ** const *l_2700 = &l_2701; + int32_t l_2712 = 0L; + if ((((l_2622 , l_2623) , (*g_1702)) != (((safe_sub_func_uint64_t_u_u(((void*)0 == &g_2436[5][1]), ((*l_2637) = ((l_2622 , ((safe_rshift_func_int16_t_s_u((~65526UL), (safe_mod_func_int32_t_s_s((((*l_2618) , (safe_rshift_func_int8_t_s_u(((safe_mod_func_int16_t_s_s((l_2553 & 18446744073709551613UL), 0x42DAL)) | l_2317), g_2635))) ^ l_2636), 0x255149B8L)))) , l_2365)) | (*g_99))))) <= l_2286) , (void*)0))) + { /* block id: 1034 */ + int32_t l_2663 = (-4L); + union U0 l_2675 = {1UL}; + int32_t *l_2711[5][10][1] = {{{(void*)0},{&g_59},{&g_137},{&g_137},{&g_59},{(void*)0},{&l_2315},{(void*)0},{&g_137},{(void*)0}},{{&l_2315},{(void*)0},{&g_59},{&g_137},{&g_137},{&g_59},{(void*)0},{&l_2315},{(void*)0},{&g_137}},{{(void*)0},{&l_2315},{(void*)0},{&g_59},{&g_137},{&g_137},{&g_59},{(void*)0},{&l_2315},{(void*)0}},{{&g_137},{(void*)0},{&l_2315},{(void*)0},{&g_59},{&g_137},{&g_137},{&g_59},{(void*)0},{&l_2315}},{{(void*)0},{&g_137},{(void*)0},{&l_2315},{(void*)0},{&g_59},{&g_137},{&g_137},{&g_59},{(void*)0}}}; + int64_t l_2713 = 0xDD93ABD6062DCC83LL; + int i, j, k; + (**g_1701) = l_2638; + if ((safe_div_func_uint32_t_u_u((safe_add_func_int16_t_s_s(((((((func_49(((*g_1125) ^= l_2643), ((safe_mul_func_int32_t_s_s((safe_mod_func_uint64_t_u_u((safe_sub_func_uint8_t_u_u(l_2650, 5UL)), g_35)), (((((!((safe_unary_minus_func_uint16_t_u(l_2653)) & (safe_mul_func_uint64_t_u_u(((safe_sub_func_int8_t_s_s((safe_add_func_int8_t_s_s((g_2660 | (((l_2289 || (((safe_rshift_func_int8_t_s_s(((***g_1701) == (((0UL && 1UL) != l_2286) < 0L)), l_2663)) == (-6L)) , (*g_1019))) , l_2663) | 0xD2L)), l_2663)), l_2663)) , g_2288), l_2663)))) || (*l_2638)) | 0x83L) <= l_2653) , (*g_2339)))) , &g_56), &g_56, l_2638, l_2664) , &g_1977) == (void*)0) > g_3) , 1L) != 0x68L) || 0x46L), 0x1636L)), 1UL))) + { /* block id: 1037 */ + int16_t l_2671[2]; + union U0 ** const l_2690[9][2][1] = {{{(void*)0},{(void*)0}},{{&g_1092},{(void*)0}},{{&g_1092},{(void*)0}},{{(void*)0},{(void*)0}},{{&g_1092},{(void*)0}},{{&g_1092},{(void*)0}},{{(void*)0},{(void*)0}},{{&g_1092},{(void*)0}},{{&g_1092},{(void*)0}}}; + int32_t l_2699[3][6][2] = {{{0L,0x4193C333L},{0L,0L},{0L,0x4193C333L},{0L,0L},{0L,0x4193C333L},{0L,0L}},{{0L,0x4193C333L},{0L,0L},{0L,0x4193C333L},{0L,0L},{0L,0x4193C333L},{0L,0L}},{{0L,0x4193C333L},{0L,0L},{0L,0x4193C333L},{0L,0L},{0L,0x4193C333L},{0L,0L}}}; + int i, j, k; + for (i = 0; i < 2; i++) + l_2671[i] = 1L; + (*l_2638) = (safe_rshift_func_uint8_t_u_u((safe_add_func_int32_t_s_s((safe_add_func_uint32_t_u_u((((void*)0 != &g_2240) ^ 0x660CD143L), (0x62B0L || ((*g_456) = (l_2671[1] < (safe_mul_func_uint16_t_u_u((safe_unary_minus_func_uint32_t_u(((*g_896) = ((*l_2638) > 0x14A8DA90L)))), (((l_2675 , ((safe_mod_func_uint16_t_u_u((safe_div_func_int16_t_s_s(((((safe_sub_func_uint64_t_u_u(l_2671[1], g_1137)) > l_2671[1]) || 1L) && (*l_2638)), 65533UL)), 0x7F5AL)) < 0x57CE6A74L)) <= 1L) | l_2663)))))))), (**l_2664))), (*g_1019))); + (*g_1702) = func_81((safe_sub_func_uint32_t_u_u((safe_sub_func_int32_t_s_s((((((safe_mul_func_uint8_t_u_u((l_2671[1] && (((***g_586) , (safe_lshift_func_uint16_t_u_u(((**g_1976) ^ (l_2690[5][1][0] == l_2691)), 9))) | (safe_lshift_func_uint64_t_u_s((((0x4AL & (0xEEF51592L < (safe_lshift_func_int16_t_s_s((((((((safe_mul_func_uint64_t_u_u((g_2698 != (void*)0), (*g_1125))) && (*g_1703)) >= g_35) != 0xF746L) | (**l_2664)) & l_2675.f0) , l_2675.f0), 8)))) ^ (*l_2638)) & l_2699[2][4][1]), l_2699[1][2][1])))), (*l_2638))) <= 4L) , l_2675.f0) || (*g_2339)) != 1L), (**l_2664))), (*g_896))), l_2699[0][4][1]); + (*g_1702) = &l_2699[1][1][1]; + } + else + { /* block id: 1043 */ + int16_t ** const **l_2703 = &l_2700; + (*g_1702) = (**g_1701); + (*l_2703) = l_2700; + (**l_2664) |= l_2663; + for (l_2650 = (-28); (l_2650 < 14); ++l_2650) + { /* block id: 1049 */ + (*g_2706) = ((*l_2618) , &l_2700); + } + } + ++g_2714; + } + else + { /* block id: 1054 */ + int32_t *l_2717[3]; + int i; + for (i = 0; i < 3; i++) + l_2717[i] = &g_3; + g_2718--; + (**l_2664) = (safe_div_func_int16_t_s_s((safe_mul_func_uint32_t_u_u(((((*l_2638) > (!((*l_2638) ^ (safe_mul_func_uint32_t_u_u((****g_1532), (safe_sub_func_int16_t_s_s((((safe_div_func_uint32_t_u_u((**l_2664), (+(+(*g_1125))))) | (((safe_lshift_func_int16_t_s_u((*l_2638), 10)) , (void*)0) == l_2736)) , (((~(((*l_2638) && 0x0DL) != (****g_1532))) , (-2L)) < 1L)), (*l_2638)))))))) != (*l_2638)) , 0xEFB406AFL), (-1L))), (*g_1977))); + } + } + else + { /* block id: 1058 */ + int16_t l_2746 = 0x4E95L; + uint8_t *l_2747 = &l_2410; + int32_t l_2750 = 1L; + uint64_t *l_2751 = &l_2289; + int32_t l_2814 = 0x4FAD335AL; + int32_t l_2816[1][5][10] = {{{0xAB72BEF7L,0xC4A12C2BL,(-2L),8L,0x60FD40EFL,0x10AB9A36L,1L,(-3L),(-3L),1L},{(-1L),0xAB72BEF7L,8L,8L,0xAB72BEF7L,(-1L),7L,0x10AB9A36L,(-3L),0xA9FB95CBL},{0xA9FB95CBL,(-3L),(-3L),(-1L),0x8E4A1930L,(-10L),(-3L),(-10L),0x8E4A1930L,(-1L)},{1L,(-10L),1L,0xAB72BEF7L,(-2L),(-3L),(-1L),8L,(-3L),(-6L)},{(-3L),(-1L),8L,(-3L),(-6L),(-6L),(-3L),8L,(-1L),(-3L)}}}; + int8_t l_2819 = 0x5DL; + int32_t *l_2823 = (void*)0; + int i, j, k; + (**l_2664) = (((*g_2710) = ((((***g_1701) != (safe_add_func_uint64_t_u_u(((*l_2751) = ((safe_sub_func_uint64_t_u_u(((safe_mod_func_uint8_t_u_u(((*l_2747) = (safe_lshift_func_int8_t_s_u(((**l_2664) >= 0x05A9L), ((*g_1019) = ((**l_2664) | (l_2746 = ((*g_99) = (-1L)))))))), 0x5AL)) & (((0x53L > (**l_2664)) , (l_2748 == &g_1552)) | 18446744073709551608UL)), (*g_1125))) & l_2750)), l_2750))) < (**l_2664)) != 0xE9L)) == (**l_2664)); + (**l_2664) = ((l_2750 ^= (-5L)) >= l_2746); + for (g_1665.f0 = 29; (g_1665.f0 >= 23); --g_1665.f0) + { /* block id: 1070 */ + int16_t l_2773 = 0xA76DL; + union U1 l_2796 = {1UL}; + int32_t *l_2815[7]; + int16_t l_2817 = 0x68B6L; + uint32_t l_2820 = 0xECBD9BB5L; + int i; + for (i = 0; i < 7; i++) + l_2815[i] = &l_2621[4]; + (**l_2664) = ((**l_2691) , (*g_2339)); + (*g_56) = ((((*g_1125) > (((safe_add_func_uint16_t_u_u(((((**g_653) , (safe_mod_func_int64_t_s_s((l_2746 >= ((safe_mul_func_uint16_t_u_u(l_2750, ((**l_2664) || ((safe_lshift_func_uint8_t_u_u((safe_rshift_func_int8_t_s_u((((**l_2664) , (safe_mul_func_int32_t_s_s((*g_56), ((safe_rshift_func_uint16_t_u_u(((****g_2153) , ((safe_rshift_func_uint8_t_u_u((safe_rshift_func_uint64_t_u_s((((**l_2664) , 18446744073709551606UL) , (**l_2664)), 28)), l_2746)) & l_2772)), 12)) & l_2773)))) < l_2773), 2)), (**l_2664))) ^ l_2746)))) | 0xA83BL)), 0x5B5D9E4A20BBAF5DLL))) < (**l_2664)) , (**l_2664)), g_2150)) <= 0xA1100970D8364CFFLL) , 0x50D26EF66CDA5210LL)) || l_2746) & g_2774[1][0]); + for (g_137 = (-23); (g_137 == 1); g_137 = safe_add_func_int8_t_s_s(g_137, 5)) + { /* block id: 1075 */ + union U1 *l_2797 = &l_2796; + int32_t l_2806 = (-1L); + uint16_t *l_2807[2]; + union U0 **l_2813 = &g_1092; + int i; + for (i = 0; i < 2; i++) + l_2807[i] = (void*)0; + } + l_2820--; + } + (*l_2664) = l_2823; + } + return l_2824[0]; +} + + +/* ------------------------------------------ */ +/* + * reads : g_3 g_55 g_896 g_118.f0 g_1009 g_1019 g_441 g_59 g_135 g_214 g_35 g_456 g_56 g_1214 g_417 g_267 g_1236 g_1125 g_100 g_143 g_895 g_878 g_137 g_1301 g_207 g_1328 g_431 g_99 g_529 g_129 g_130 g_852 g_1702 g_1703 g_122.f2 g_2095 g_1999 g_852.f0 g_2150 g_2152 g_307 g_145 g_1689 g_305 g_122.f1 g_1092 g_118 g_1056 g_2219 g_2220 g_935 g_1701 + * writes: g_852.f3 g_59 g_135 g_118.f0 g_35 g_122.f2 g_267 g_852 g_933 g_143 g_1214 g_417 g_137 g_441 g_100 g_935 g_130 g_456 g_2095 g_1703 g_122.f1 g_307 g_2240 g_305 g_122.f0 g_1009 + */ +static int64_t func_27(union U1 p_28) +{ /* block id: 5 */ + uint32_t l_37[2]; + int32_t *l_57[2]; + uint8_t * const *l_1256 = &g_1019; + union U0 **l_1279 = &g_1092; + union U1 l_1342 = {9UL}; + int32_t l_1395 = 0xF7212BAEL; + int32_t ** const *l_1521[6] = {(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0}; + uint8_t *****l_1534 = &g_1515; + int16_t l_1556 = 0x5C1BL; + int8_t * const *l_1568 = &g_130[0][1]; + int8_t * const **l_1567 = &l_1568; + int8_t * const *** const l_1566 = &l_1567; + int32_t l_1597 = 1L; + int32_t l_1598 = 0x8E47819EL; + uint32_t l_1633[8][2] = {{0xC4555C99L,0x6CF811A0L},{0xA28A8EE4L,0x6CF811A0L},{0xC4555C99L,4294967295UL},{4294967295UL,0xC4555C99L},{0x6CF811A0L,0xA28A8EE4L},{0x6CF811A0L,0xC4555C99L},{4294967295UL,4294967295UL},{0xC4555C99L,0x6CF811A0L}}; + uint16_t l_1648[2][2][3]; + int8_t ****l_1725 = &g_529; + int8_t *****l_1724 = &l_1725; + union U1 * const *l_1818 = (void*)0; + int32_t l_1823[10][6][4] = {{{0x79B7B90FL,1L,(-1L),(-1L)},{0xCFB9A36DL,(-1L),(-2L),(-1L)},{(-9L),1L,(-1L),0x79B7B90FL},{4L,(-1L),0xCA467580L,0x79B7B90FL},{(-1L),1L,1L,(-1L)},{0xBA9F5FECL,(-1L),1L,(-1L)}},{{0x8182590BL,1L,0xC2C2D651L,0x79B7B90FL},{1L,(-1L),(-5L),0x79B7B90FL},{0x79B7B90FL,1L,(-1L),(-1L)},{0xCFB9A36DL,(-1L),(-2L),(-1L)},{(-9L),1L,(-1L),0x79B7B90FL},{4L,(-1L),0xCA467580L,0x79B7B90FL}},{{(-1L),1L,1L,(-1L)},{0xBA9F5FECL,(-1L),1L,(-1L)},{0x8182590BL,1L,0xC2C2D651L,0x79B7B90FL},{1L,(-1L),(-5L),0x79B7B90FL},{0x79B7B90FL,1L,(-1L),(-1L)},{0xCFB9A36DL,(-1L),(-2L),(-1L)}},{{(-9L),1L,(-1L),0x79B7B90FL},{4L,(-1L),0xCA467580L,0x79B7B90FL},{(-1L),1L,1L,(-1L)},{0xBA9F5FECL,(-1L),1L,(-1L)},{0x8182590BL,1L,0xC2C2D651L,0x79B7B90FL},{1L,(-1L),(-5L),0x79B7B90FL}},{{0x79B7B90FL,1L,(-1L),(-1L)},{0xCFB9A36DL,(-1L),(-2L),(-1L)},{(-9L),1L,(-1L),0x79B7B90FL},{4L,(-1L),0xCA467580L,0x79B7B90FL},{(-1L),1L,1L,(-1L)},{0xBA9F5FECL,(-1L),1L,(-1L)}},{{0x8182590BL,1L,0xC2C2D651L,0x79B7B90FL},{1L,(-1L),(-5L),0x79B7B90FL},{0x79B7B90FL,1L,(-1L),(-1L)},{0xCFB9A36DL,(-1L),(-2L),(-1L)},{(-9L),1L,(-1L),0x79B7B90FL},{4L,(-1L),0xCA467580L,0x79B7B90FL}},{{(-1L),1L,1L,(-1L)},{0xBA9F5FECL,(-1L),1L,(-1L)},{0x8182590BL,1L,0xC2C2D651L,0x79B7B90FL},{1L,(-1L),(-5L),0x79B7B90FL},{0x79B7B90FL,1L,(-1L),(-1L)},{0xCFB9A36DL,(-1L),(-2L),(-1L)}},{{(-9L),1L,(-1L),0x79B7B90FL},{4L,(-1L),0xCA467580L,0x79B7B90FL},{(-1L),1L,1L,(-1L)},{0xBA9F5FECL,(-1L),1L,(-1L)},{0x8182590BL,1L,0xC2C2D651L,0x79B7B90FL},{1L,(-1L),(-5L),0x79B7B90FL}},{{0x79B7B90FL,1L,(-1L),(-1L)},{0xCFB9A36DL,(-1L),(-2L),(-1L)},{(-9L),1L,(-1L),0x79B7B90FL},{4L,(-1L),0xCA467580L,0x79B7B90FL},{(-1L),1L,1L,(-1L)},{0xBA9F5FECL,(-1L),1L,(-1L)}},{{0x8182590BL,1L,0xC2C2D651L,0x79B7B90FL},{1L,(-1L),(-5L),0x79B7B90FL},{0x79B7B90FL,1L,(-1L),(-1L)},{0xCFB9A36DL,(-1L),(-2L),(-1L)},{(-9L),1L,(-1L),0x79B7B90FL},{4L,(-1L),0xCA467580L,0x79B7B90FL}}}; + int32_t l_1852 = 3L; + int32_t l_1853 = 4L; + int64_t l_1950 = 0x58A1E20F5679037ELL; + uint32_t ***l_1970 = &g_895; + uint32_t ****l_1969 = &l_1970; + uint32_t *****l_1968[7] = {(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0}; + uint32_t l_2008[6]; + int8_t l_2099 = 0x51L; + int32_t ***l_2146[10] = {&g_55[0][0][2],&g_55[0][0][2],&g_55[0][0][1],&g_55[0][0][2],&g_55[0][0][2],&g_55[0][0][1],&g_55[0][0][2],&g_55[0][0][2],&g_55[0][0][1],&g_55[0][0][2]}; + int32_t ****l_2145[8][4][5] = {{{&l_2146[4],&l_2146[9],(void*)0,&l_2146[8],&l_2146[9]},{&l_2146[8],&l_2146[8],&l_2146[4],&l_2146[8],&l_2146[8]},{(void*)0,&l_2146[8],&l_2146[8],&l_2146[8],&l_2146[8]},{&l_2146[8],&l_2146[8],&l_2146[8],&l_2146[9],&l_2146[8]}},{{&l_2146[8],&l_2146[8],&l_2146[8],&l_2146[8],&l_2146[8]},{(void*)0,&l_2146[8],&l_2146[8],&l_2146[9],&l_2146[3]},{&l_2146[8],&l_2146[8],&l_2146[8],&l_2146[8],&l_2146[8]},{&l_2146[4],&l_2146[4],&l_2146[8],&l_2146[8],&l_2146[8]}},{{&l_2146[9],&l_2146[8],&l_2146[8],&l_2146[8],&l_2146[3]},{&l_2146[8],&l_2146[8],&l_2146[4],&l_2146[7],&l_2146[8]},{&l_2146[7],&l_2146[8],(void*)0,(void*)0,&l_2146[8]},{&l_2146[3],&l_2146[4],&l_2146[9],(void*)0,&l_2146[8]}},{{&l_2146[8],&l_2146[8],&l_2146[8],&l_2146[7],&l_2146[8]},{&l_2146[8],&l_2146[8],&l_2146[8],&l_2146[8],&l_2146[9]},{&l_2146[8],&l_2146[8],&l_2146[9],&l_2146[8],&l_2146[8]},{&l_2146[8],&l_2146[8],&l_2146[8],(void*)0,&l_2146[8]}},{{&l_2146[8],&l_2146[3],(void*)0,&l_2146[4],&l_2146[8]},{&l_2146[8],&l_2146[8],&l_2146[8],&l_2146[8],&l_2146[8]},{&l_2146[8],&l_2146[4],&l_2146[4],&l_2146[8],&l_2146[8]},{&l_2146[8],&l_2146[4],&l_2146[9],&l_2146[8],&l_2146[8]}},{{&l_2146[8],&l_2146[8],&l_2146[8],&l_2146[8],&l_2146[8]},{&l_2146[9],&l_2146[3],&l_2146[7],&l_2146[8],&l_2146[8]},{&l_2146[3],&l_2146[8],&l_2146[3],&l_2146[8],&l_2146[8]},{&l_2146[3],&l_2146[9],&l_2146[8],&l_2146[8],(void*)0}},{{&l_2146[9],&l_2146[7],&l_2146[8],&l_2146[4],&l_2146[8]},{&l_2146[8],&l_2146[8],&l_2146[8],(void*)0,&l_2146[8]},{&l_2146[8],&l_2146[8],&l_2146[3],&l_2146[9],&l_2146[8]},{&l_2146[8],&l_2146[8],&l_2146[7],&l_2146[8],&l_2146[8]}},{{&l_2146[8],&l_2146[8],&l_2146[8],&l_2146[8],(void*)0},{&l_2146[8],&l_2146[8],&l_2146[9],&l_2146[9],&l_2146[8]},{&l_2146[8],&l_2146[8],&l_2146[4],&l_2146[9],&l_2146[8]},{&l_2146[8],&l_2146[8],&l_2146[8],&l_2146[8],&l_2146[8]}}}; + int16_t *l_2217 = &g_2095; + int16_t **l_2216 = &l_2217; + union U0 ***l_2230 = &l_1279; + union U0 ****l_2229 = &l_2230; + uint64_t l_2241 = 0xF0A6BB719D3565F0LL; + int i, j, k; + for (i = 0; i < 2; i++) + l_37[i] = 1UL; + for (i = 0; i < 2; i++) + l_57[i] = (void*)0; + for (i = 0; i < 2; i++) + { + for (j = 0; j < 2; j++) + { + for (k = 0; k < 3; k++) + l_1648[i][j][k] = 0x1212L; + } + } + for (i = 0; i < 6; i++) + l_2008[i] = 0x8B1129BBL; + if (p_28.f0) + { /* block id: 6 */ + uint16_t *l_34 = &g_35; + const int32_t *l_1136[3]; + int32_t l_1145 = (-1L); + int32_t l_1167[5][3][10] = {{{0x16E27C70L,1L,0x16E27C70L,0xE5C47C3EL,4L,0xE5C47C3EL,0x16E27C70L,1L,0x16E27C70L,0xE5C47C3EL},{0xA94E1FDDL,1L,0xD77F7C48L,1L,0xA94E1FDDL,(-1L),0xA94E1FDDL,1L,0xD77F7C48L,1L},{4L,0xE5C47C3EL,0x16E27C70L,1L,0x16E27C70L,0xE5C47C3EL,4L,0xE5C47C3EL,0x16E27C70L,1L}},{{(-6L),1L,(-6L),0xE5C47C3EL,0xA94E1FDDL,0xE5C47C3EL,(-6L),1L,(-6L),0xE5C47C3EL},{4L,1L,0x134BC113L,1L,4L,(-1L),4L,1L,0x134BC113L,1L},{0xA94E1FDDL,0xE5C47C3EL,(-6L),1L,(-6L),0xE5C47C3EL,0xA94E1FDDL,0xE5C47C3EL,(-6L),1L}},{{0x16E27C70L,1L,0x16E27C70L,0xE5C47C3EL,4L,0xE5C47C3EL,0x16E27C70L,1L,0x16E27C70L,0xE5C47C3EL},{0xA94E1FDDL,1L,0xD77F7C48L,1L,0xA94E1FDDL,(-1L),0xA94E1FDDL,1L,0xD77F7C48L,1L},{4L,0xE5C47C3EL,0x16E27C70L,1L,0x16E27C70L,0xE5C47C3EL,4L,0xE5C47C3EL,0x16E27C70L,1L}},{{(-6L),1L,(-6L),0xE5C47C3EL,0xA94E1FDDL,0xE5C47C3EL,(-6L),1L,(-6L),0xE5C47C3EL},{4L,1L,0x134BC113L,1L,4L,1L,0x16E27C70L,0xE5C47C3EL,4L,0xE5C47C3EL},{(-6L),(-1L),0xD77F7C48L,0xE5C47C3EL,0xD77F7C48L,(-1L),(-6L),(-1L),0xD77F7C48L,0xE5C47C3EL}},{{0x134BC113L,0xE5C47C3EL,0x134BC113L,(-1L),0x16E27C70L,(-1L),0x134BC113L,0xE5C47C3EL,0x134BC113L,(-1L)},{(-6L),0xE5C47C3EL,0xA94E1FDDL,0xE5C47C3EL,(-6L),1L,(-6L),0xE5C47C3EL,0xA94E1FDDL,0xE5C47C3EL},{0x16E27C70L,(-1L),0x134BC113L,0xE5C47C3EL,0x134BC113L,(-1L),0x16E27C70L,(-1L),0x134BC113L,0xE5C47C3EL}}}; + int32_t *l_1187 = &g_137; + union U1 l_1235 = {0UL}; + uint32_t l_1287 = 0x78DE3910L; + int32_t l_1288 = 6L; + uint8_t l_1300 = 1UL; + union U0 * const * const l_1316[5][3][1] = {{{&g_1092},{&g_1092},{&g_1092}},{{&g_1092},{&g_1092},{&g_1092}},{{&g_1092},{&g_1092},{&g_1092}},{{&g_1092},{&g_1092},{&g_1092}},{{&g_1092},{&g_1092},{&g_1092}}}; + int16_t l_1317[4]; + int32_t ***l_1341 = (void*)0; + int8_t *l_1343 = (void*)0; + int8_t *l_1344 = &g_935; + union U0 ***l_1376 = (void*)0; + union U0 ****l_1375[2]; + uint32_t l_1377 = 1UL; + uint64_t l_1378 = 0x14BBF3FED2DCBED7LL; + int32_t *l_1381 = &l_1167[0][1][8]; + int8_t l_1439 = 0x0DL; + int32_t l_1495[6][9] = {{0L,0x7EEEE06CL,0x2B18486AL,0x7EEEE06CL,0L,0x774E0949L,1L,(-8L),(-1L)},{0xB78CE126L,0x473DE67AL,(-1L),1L,0xED5CB4D3L,1L,(-1L),0x473DE67AL,0xB78CE126L},{1L,0L,(-1L),0L,(-8L),0x774E0949L,0xDB0CD044L,0x774E0949L,(-8L)},{0xD432C156L,0L,0L,0xD432C156L,1L,0x2182AF7FL,0x9A9E8CE8L,0xA5A3DB4AL,0xDF3EFC9CL},{1L,(-8L),0xDB0CD044L,0L,0L,0xDB0CD044L,(-8L),1L,0x2B18486AL},{0xB78CE126L,1L,0xDF3EFC9CL,0xD8FCE3FCL,1L,0xA5A3DB4AL,0xA5A3DB4AL,1L,0xD8FCE3FCL}}; + const uint16_t l_1594 = 0x52C1L; + int16_t l_1606 = 6L; + const int8_t l_1722 = 0xFDL; + int8_t *****l_1726 = &l_1725; + const int64_t l_1755[1][6] = {{0xEBE5916BA4CCF272LL,(-1L),0xEBE5916BA4CCF272LL,0xEBE5916BA4CCF272LL,(-1L),0xEBE5916BA4CCF272LL}}; + const int32_t ***l_1820[7]; + int8_t l_1875 = 0x31L; + uint32_t ** const *l_1893[7] = {&g_895,&g_895,&g_895,&g_895,&g_895,&g_895,&g_895}; + uint16_t l_1911 = 3UL; + union U1 * const **l_1918[10][4][6]; + int64_t l_1926 = 5L; + uint32_t l_2065 = 0xA5854404L; + int16_t l_2067 = (-1L); + int i, j, k; + for (i = 0; i < 3; i++) + l_1136[i] = &g_1137; + for (i = 0; i < 4; i++) + l_1317[i] = 3L; + for (i = 0; i < 2; i++) + l_1375[i] = &l_1376; + for (i = 0; i < 7; i++) + l_1820[i] = &g_1702; + for (i = 0; i < 10; i++) + { + for (j = 0; j < 4; j++) + { + for (k = 0; k < 6; k++) + l_1918[i][j][k] = &l_1818; + } + } + for (p_28.f3 = (-26); (p_28.f3 == 35); p_28.f3 = safe_add_func_int64_t_s_s(p_28.f3, 9)) + { /* block id: 9 */ + uint16_t l_1144 = 6UL; + int32_t l_1154 = 0x45B6BBFDL; + int32_t l_1155 = 0x5F71859AL; + int32_t l_1164 = 0xB86F3B52L; + int32_t l_1168 = 0xDE0953CFL; + int32_t l_1172 = (-5L); + int32_t l_1173 = (-1L); + int32_t l_1174 = 0xA584BC19L; + int32_t l_1175 = (-10L); + int32_t l_1176 = 0xA46859FDL; + int32_t l_1179 = 0x12282C6DL; + int32_t l_1180 = (-3L); + uint32_t l_1181 = 0UL; + const volatile union U0 * volatile * const *l_1186 = (void*)0; + int32_t ***l_1207 = &g_55[0][4][2]; + uint8_t *** const l_1297 = &g_1018[2][4]; + uint64_t *l_1304 = &g_417; + if ((safe_rshift_func_uint16_t_u_s(((void*)0 != l_34), (+(l_37[1] > (func_40(p_28.f3) ^ ((func_40(g_3) , ((((((safe_sub_func_int64_t_s_s((safe_mul_func_uint16_t_u_u((func_49((&g_3 == (void*)0), g_55[0][0][1], &g_56, l_57[1], &l_57[1]) , 4UL), 65528UL)), 0x65F7C8463309AAA9LL)) && 1L) || 1L) > 0x9DL) >= 0L) >= 0xE2D1L)) && 0L))))))) + { /* block id: 470 */ + uint32_t *l_1138 = &g_118.f0; + uint32_t *l_1139 = &g_852[0].f3; + int8_t *** const **l_1152 = (void*)0; + uint32_t *l_1153[9][1][7] = {{{&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0}},{{&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0}},{{&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0}},{{&g_118.f0,&g_118.f0,&g_122.f3,&g_118.f0,&g_118.f0,&g_122.f3,&g_118.f0}},{{&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0}},{{&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0}},{{&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0}},{{&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0}},{{&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0,&g_118.f0}}}; + int32_t l_1159 = 0xE6263C60L; + int32_t l_1160 = 0x0F8C9927L; + int32_t l_1170 = 0x1D8153EBL; + int32_t l_1171[5][3][8] = {{{0x5CB7EDBCL,0x5CB7EDBCL,1L,0L,1L,0x5CB7EDBCL,(-7L),(-7L)},{(-7L),0xCC957628L,1L,0xAD12BBE4L,0xAC91F44DL,0x29F756ABL,0xB14469CAL,0x07A64DCFL},{(-1L),4L,(-1L),0xEE16AE81L,0xAC91F44DL,0xACBFCA3DL,0xAD12BBE4L,0L}},{{(-7L),(-1L),0x09D359BEL,0x07A64DCFL,1L,(-1L),3L,4L},{(-7L),0xA03FCE3FL,(-7L),(-1L),3L,0x5FFF7664L,0xACBFCA3DL,0xF5F42886L},{1L,3L,6L,0xAC91F44DL,0x4AE2E6FCL,0x33C346B6L,0x5FFF7664L,0xFD4C2B3CL}},{{1L,0xF5F42886L,1L,1L,1L,1L,0xF5F42886L,1L},{0xF5F42886L,0x29F756ABL,1L,0xD0C4866BL,0xFD4C2B3CL,0x07A64DCFL,0x9992D194L,0x09D359BEL},{0x5CB7EDBCL,0xCC957628L,0xAD12BBE4L,1L,0xD0C4866BL,0x07A64DCFL,6L,0xEE16AE81L}},{{(-1L),0x29F756ABL,0x5FFF7664L,4L,0xCC957628L,1L,1L,0L},{0xEE16AE81L,0xF5F42886L,(-9L),0x5CB7EDBCL,0xA03FCE3FL,0x33C346B6L,3L,0x29F756ABL},{(-9L),3L,0xF5F42886L,8L,(-1L),0x5FFF7664L,0x615DE146L,(-7L)}},{{(-4L),0xA03FCE3FL,3L,(-1L),0x4AE2E6FCL,(-1L),3L,0xA03FCE3FL},{0x291E75CBL,(-1L),8L,1L,6L,0xACBFCA3DL,(-7L),0x291E75CBL},{(-1L),4L,1L,0xCC957628L,0x291E75CBL,0x29F756ABL,(-7L),0x9992D194L}}}; + union U1 l_1229 = {0xA199L}; + int64_t l_1242 = 0x46214D284E96FF49LL; + int i, j, k; + l_1155 = ((safe_mod_func_int8_t_s_s(((safe_rshift_func_uint8_t_u_s(((safe_div_func_int8_t_s_s((safe_lshift_func_int32_t_s_u((l_1136[2] == l_57[1]), ((*l_1139) = (*g_896)))), (safe_lshift_func_uint64_t_u_u((safe_add_func_uint64_t_u_u((l_1144 | l_1145), (safe_div_func_uint64_t_u_u((safe_mul_func_uint8_t_u_u((safe_mul_func_uint64_t_u_u(p_28.f3, ((((l_1152 = &g_528[6]) != (void*)0) == (((l_1154 &= ((g_1009[4][2][2] , &g_1018[5][3]) != &g_1018[3][2])) != 1L) , l_1145)) && 0xC6L))), (*g_1019))), 0x648C6FCA1396C5F2LL)))), 31)))) , p_28.f3), p_28.f3)) ^ 0x1AL), l_1144)) & l_1145); + for (g_59 = 0; (g_59 >= 0); g_59 -= 1) + { /* block id: 477 */ + uint32_t l_1156 = 7UL; + int32_t l_1161 = 1L; + int32_t **l_1162 = (void*)0; + int32_t **l_1163 = &l_57[1]; + int32_t l_1165 = (-2L); + int32_t l_1166 = 0x0DE7B344L; + int32_t l_1169 = 0xDC1D48E2L; + int32_t l_1177 = 0L; + int32_t l_1178[6][3] = {{5L,5L,5L},{1L,1L,1L},{5L,5L,5L},{1L,1L,1L},{5L,5L,5L},{1L,1L,1L}}; + int i, j; + l_1161 = (l_1160 = ((l_1159 = ((l_1156 > (~(p_28.f3 ^ (+1L)))) && (&g_1019 == &g_1019))) > p_28.f3)); + (*l_1163) = &l_1160; + for (g_135 = 0; (g_135 <= 2); g_135 += 1) + { /* block id: 484 */ + int i, j; + return g_214[g_135][(g_135 + 2)]; + } + --l_1181; + for (g_135 = 0; (g_135 <= 0); g_135 += 1) + { /* block id: 490 */ + const volatile union U0 * volatile * const *l_1185 = (void*)0; + const volatile union U0 * volatile * const **l_1184[10]; + int i; + for (i = 0; i < 10; i++) + l_1184[i] = &l_1185; + l_1186 = &g_587; + l_1187 = (void*)0; + } + } + if ((!(++(*l_1138)))) + { /* block id: 496 */ + uint64_t l_1201 = 0x632F0936F80B9AECLL; + int32_t l_1202 = 0xBDEA76F6L; + int32_t ***l_1209 = &g_55[0][3][2]; + int32_t ****l_1208 = &l_1209; + int16_t l_1215 = 0x9C81L; + l_1145 = ((((((((safe_sub_func_uint8_t_u_u((safe_mod_func_uint64_t_u_u((safe_lshift_func_uint64_t_u_u((safe_mul_func_uint8_t_u_u((safe_add_func_int32_t_s_s((l_1167[0][1][8] = l_1201), ((((*g_456) = ((*l_34)++)) | ((((safe_mod_func_int32_t_s_s((l_1207 == ((*l_1208) = &g_55[0][0][1])), (p_28.f3 && (safe_sub_func_int32_t_s_s(((*l_1207) != (((safe_add_func_int64_t_s_s((***l_1207), g_1214)) ^ ((l_1215 < (0UL <= l_1171[1][2][6])) != 2L)) , (*l_1207))), 4294967289UL))))) != p_28.f3) , p_28.f3) == p_28.f3)) == (*g_56)))), 0xFFL)), 6)), 0xA770019C8FED1E3ELL)), 1UL)) ^ 0xAA2288C350658371LL) , p_28.f3) & p_28.f3) >= 0x9234CF6CB7662203LL) >= g_417) ^ 0xC9BCL) & 0x3936L); + } + else + { /* block id: 502 */ + const uint32_t l_1250 = 4294967287UL; + int32_t l_1260 = 0L; + for (g_267 = 19; (g_267 < (-25)); g_267 = safe_sub_func_uint8_t_u_u(g_267, 9)) + { /* block id: 505 */ + uint16_t **l_1234 = &g_456; + uint8_t * const *l_1241 = &g_1019; + uint8_t * const **l_1240[6][10][4] = {{{&l_1241,&l_1241,(void*)0,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,&l_1241,(void*)0,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,&l_1241,(void*)0,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,&l_1241,(void*)0,&l_1241}},{{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,&l_1241,(void*)0,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{(void*)0,&l_1241,(void*)0,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,(void*)0,(void*)0,&l_1241},{(void*)0,&l_1241,(void*)0,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,(void*)0,(void*)0,&l_1241}},{{(void*)0,&l_1241,&l_1241,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,(void*)0,&l_1241,&l_1241},{(void*)0,&l_1241,(void*)0,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,(void*)0,(void*)0,&l_1241},{(void*)0,&l_1241,(void*)0,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,(void*)0,(void*)0,&l_1241},{(void*)0,&l_1241,&l_1241,&l_1241}},{{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,(void*)0,&l_1241,&l_1241},{(void*)0,&l_1241,(void*)0,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,(void*)0,(void*)0,&l_1241},{(void*)0,&l_1241,(void*)0,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,(void*)0,(void*)0,&l_1241},{(void*)0,&l_1241,&l_1241,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241}},{{&l_1241,(void*)0,&l_1241,&l_1241},{(void*)0,&l_1241,(void*)0,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,(void*)0,(void*)0,&l_1241},{(void*)0,&l_1241,(void*)0,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,(void*)0,(void*)0,&l_1241},{(void*)0,&l_1241,&l_1241,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,(void*)0,&l_1241,&l_1241}},{{(void*)0,&l_1241,(void*)0,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,(void*)0,(void*)0,&l_1241},{(void*)0,&l_1241,(void*)0,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,(void*)0,(void*)0,&l_1241},{(void*)0,&l_1241,&l_1241,&l_1241},{&l_1241,&l_1241,&l_1241,&l_1241},{&l_1241,(void*)0,&l_1241,&l_1241},{(void*)0,&l_1241,(void*)0,&l_1241}}}; + uint8_t * const ***l_1239 = &l_1240[3][0][3]; + int32_t l_1243 = 0xFE977848L; + int8_t *l_1257 = &g_933; + int16_t *l_1258 = (void*)0; + int16_t *l_1259 = &g_143; + uint64_t *l_1263 = &g_1214; + int8_t l_1276[2]; + int32_t l_1286 = 0L; + int i, j, k; + for (i = 0; i < 2; i++) + l_1276[i] = (-5L); + l_1167[4][2][1] = ((safe_rshift_func_int64_t_s_u((p_28.f3 , ((((safe_rshift_func_int64_t_s_u(((safe_mod_func_uint64_t_u_u((safe_add_func_uint32_t_u_u((safe_mul_func_uint32_t_u_u(l_1170, (~((g_852[0] = l_1229) , p_28.f3)))), ((safe_rshift_func_uint16_t_u_s(p_28.f3, 0)) >= (((safe_lshift_func_uint16_t_u_s((&g_456 == l_1234), (0xA26892A924B8E267LL == ((l_1235 , g_1236[3][6][2]) != l_1239)))) <= p_28.f3) > l_1229.f0)))), 18446744073709551615UL)) < (*g_1125)), 39)) , 0x8D78L) & l_1242) <= l_1243)), 50)) >= (*g_56)); + l_1260 |= ((safe_div_func_uint32_t_u_u((((*l_1259) |= (safe_mul_func_int8_t_s_s((0L <= (g_100 != (safe_mul_func_uint8_t_u_u(l_1250, (p_28.f3 == l_1243))))), ((*l_1257) = ((-4L) || ((l_1235 , (safe_mul_func_uint32_t_u_u((safe_add_func_uint16_t_u_u(((*l_34) |= (safe_unary_minus_func_uint16_t_u((l_1235 , ((p_28 , (void*)0) == l_1256))))), 6UL)), p_28.f3))) >= p_28.f3)))))) >= (***l_1207)), p_28.f3)) ^ (*g_1019)); + l_1288 &= ((safe_add_func_uint64_t_u_u(8UL, ((*l_1263)++))) & ((safe_div_func_int32_t_s_s((safe_div_func_int16_t_s_s(((*l_1259) = (safe_lshift_func_uint64_t_u_u((safe_rshift_func_int16_t_s_s(((l_1171[1][1][2] = (p_28.f3 > (((safe_sub_func_uint64_t_u_u((l_1243 = l_1276[0]), (safe_rshift_func_uint32_t_u_u(l_1250, 28)))) , &g_1092) != l_1279))) , (l_1286 = (safe_sub_func_uint64_t_u_u(l_1276[0], (g_852[0].f1 = ((l_1243 |= ((***l_1207) <= ((safe_mod_func_uint64_t_u_u((((safe_lshift_func_uint32_t_u_u((*g_896), (**g_895))) || (-2L)) ^ 7L), p_28.f3)) < (-6L)))) ^ g_214[1][3])))))), l_1287)), 24))), 0xA7D6L)), p_28.f3)) && (**g_895))); + l_1172 = 1L; + } + if (p_28.f3) + break; + l_1300 = (safe_add_func_int32_t_s_s((p_28 , ((((safe_mul_func_uint16_t_u_u((1UL ^ ((safe_lshift_func_uint16_t_u_u(((safe_mod_func_uint64_t_u_u((l_1297 == (void*)0), (*g_1125))) , ((*g_456) = (4294967295UL != ((safe_mod_func_int16_t_s_s(p_28.f3, ((&g_456 != ((p_28.f3 == 1L) , &l_34)) & p_28.f3))) | (**g_895))))), p_28.f3)) < g_878)), (***l_1207))) <= p_28.f3) <= (***l_1207)) ^ 1UL)), p_28.f3)); + } + l_1145 ^= ((*g_896) || ((&g_214[2][3] == (void*)0) >= p_28.f3)); + } + else + { /* block id: 527 */ + int32_t l_1311[9][7] = {{0x117D6E7CL,0x821D7BA4L,6L,0xA0688267L,0L,0x117D6E7CL,(-8L)},{(-8L),0x06AD7DD3L,0x1373CAC2L,(-4L),0x1373CAC2L,0x06AD7DD3L,(-8L)},{(-4L),0x524FF6D5L,0x1373CAC2L,0x94F6AB6AL,1L,0x06AD7DD3L,(-4L)},{(-8L),0x524FF6D5L,(-1L),(-4L),1L,0x117D6E7CL,(-8L)},{(-8L),0x06AD7DD3L,0x1373CAC2L,(-4L),0x1373CAC2L,0x06AD7DD3L,(-8L)},{(-4L),0x524FF6D5L,0x1373CAC2L,0x94F6AB6AL,1L,0x06AD7DD3L,(-4L)},{(-8L),0x524FF6D5L,(-1L),(-4L),1L,0x117D6E7CL,(-8L)},{(-8L),0x06AD7DD3L,0x1373CAC2L,(-4L),0x1373CAC2L,0x06AD7DD3L,(-8L)},{(-4L),0x524FF6D5L,0x1373CAC2L,0x94F6AB6AL,1L,0x06AD7DD3L,(-4L)}}; + uint16_t *l_1312[10] = {&g_307[5][3],&g_307[5][3],&g_307[5][3],&g_307[5][3],&g_307[5][3],&g_307[5][3],&g_307[5][3],&g_307[5][3],&g_307[5][3],&g_307[5][3]}; + int32_t l_1313 = (-3L); + int i, j; + if ((*l_1187)) + break; + l_1180 &= (((g_1301[1][6] != &g_1302) || ((void*)0 != l_1304)) , ((((g_207 ^ ((*l_1304) = (l_1311[6][0] = (((p_28.f3 ^ (safe_mul_func_uint32_t_u_u((*l_1187), p_28.f3))) ^ (safe_add_func_int8_t_s_s((((l_1173 = ((safe_add_func_int8_t_s_s(((l_1313 ^= ((*l_34) |= (((((*g_896) |= p_28.f3) ^ l_1311[5][3]) && l_1311[7][1]) , p_28.f3))) != 65535UL), (***l_1207))) <= p_28.f3)) && p_28.f3) ^ p_28.f3), p_28.f3))) , p_28.f3)))) ^ p_28.f3) , p_28.f3) == (***l_1207))); + (*l_1187) = l_1311[3][2]; + if ((*g_56)) + break; + } + return (*g_1125); + } + if ((safe_rshift_func_int64_t_s_u(((((0xBD6A37E4L == (l_1317[3] &= (l_1316[3][0][0] == l_1316[1][2][0]))) , ((*l_1344) = ((*g_99) = (((**l_1256) |= (safe_lshift_func_uint32_t_u_s(((safe_rshift_func_int64_t_s_s((-6L), (safe_rshift_func_uint8_t_u_s(l_1167[4][0][0], 7)))) && (--(*l_34))), 25))) , (((p_28.f3 , (safe_mod_func_int64_t_s_s((g_1328[1][1][1] != l_1341), ((l_1342 , g_431) , (-1L))))) >= 0x72991BC3EC4EE965LL) != p_28.f3))))) > p_28.f3) > p_28.f3), g_137))) + { /* block id: 546 */ + int32_t *l_1345[8]; + int8_t *l_1347 = &g_100; + uint16_t l_1366 = 1UL; + int i; + for (i = 0; i < 8; i++) + l_1345[i] = &g_137; + } + else + { /* block id: 577 */ + int16_t l_1387 = 0xDBF6L; + int32_t *l_1389 = &l_1288; + int32_t ** const l_1388[9] = {(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0}; + int8_t * const l_1390 = &g_935; + int8_t l_1394 = 3L; + int32_t l_1396 = 0x525A54E1L; + union U0 **l_1397 = &g_1092; + int i; + for (p_28.f2 = 1; (p_28.f2 >= 17); p_28.f2 = safe_add_func_int8_t_s_s(p_28.f2, 8)) + { /* block id: 580 */ + int16_t l_1384 = (-10L); + return l_1384; + } + l_1396 |= (((((*l_34) = (((0x513B6B40EDF27700LL >= ((safe_rshift_func_int8_t_s_u((0x13B16DFCL != ((((l_1387 , (((((p_28.f2 == (l_1388[8] == &g_1330[2][8][0])) , (((**g_529) = (**g_529)) != l_1390)) , (((l_1145 = ((((((*l_1381) |= (safe_rshift_func_uint64_t_u_u((+(p_28.f2 ^ p_28.f2)), g_1009[7][2][1]))) , (void*)0) == (void*)0) < p_28.f2) != p_28.f2)) <= 0x3A595E87L) && l_1387)) , g_852[0]) , g_417)) , l_1394) <= l_1395) , p_28.f2)), 0)) <= p_28.f2)) > p_28.f2) , 0x9DA6L)) , 1L) > p_28.f2) > p_28.f2); + l_1397 = l_1279; + } + for (g_135 = 0; (g_135 > 25); g_135++) + { /* block id: 592 */ + int64_t l_1421 = (-1L); + int16_t l_1426 = (-4L); + uint64_t *l_1427 = (void*)0; + int32_t l_1428 = (-1L); + int32_t **l_1429[10][5] = {{&l_57[0],&l_57[0],&l_57[0],&l_57[0],&l_57[0]},{(void*)0,&l_1381,(void*)0,&l_1381,(void*)0},{&l_57[0],&l_57[0],&l_57[0],&l_57[0],&l_57[0]},{(void*)0,&l_1381,(void*)0,&l_1381,(void*)0},{&l_57[0],&l_57[0],&l_57[0],&l_57[0],&l_57[0]},{(void*)0,&l_1381,(void*)0,&l_1381,(void*)0},{&l_57[0],&l_57[0],&l_57[0],&l_57[0],&l_57[0]},{(void*)0,&l_1381,(void*)0,&l_1381,(void*)0},{&l_57[0],&l_57[0],&l_57[0],&l_57[0],&l_57[0]},{(void*)0,&l_1381,(void*)0,&l_1381,(void*)0}}; + uint8_t *l_1430 = (void*)0; + uint8_t *l_1431 = &l_1300; + uint8_t *l_1432 = &g_1433; + union U0 l_1475 = {2UL}; + const uint32_t l_1480 = 4294967295UL; + uint32_t *l_1513 = &l_37[1]; + int32_t **l_1529 = &g_56; + uint16_t **l_1555 = &l_34; + uint16_t *** const l_1554 = &l_1555; + union U0 **l_1558 = &g_1092; + int32_t l_1632 = 0xDA93520FL; + int8_t l_1690[4]; + uint32_t l_1761 = 0x04651E1AL; + int16_t *l_1785 = (void*)0; + uint32_t * const **l_1807 = (void*)0; + union U1 *l_1814 = &g_852[0]; + union U1 **l_1813[3]; + int32_t l_1828[8][3][5] = {{{(-1L),6L,(-7L),0x02D4B8C1L,(-7L)},{0x7E050F62L,0x7E050F62L,0xF2296631L,1L,0L},{6L,6L,3L,0x12BD2E0BL,0x99613C26L}},{{0x9B030DA8L,0x7E050F62L,0L,1L,1L},{0xC4A1157FL,6L,1L,0xA4339C8DL,3L},{(-5L),0x7E050F62L,0xB3B41C8BL,0x238E52E3L,0xB3B41C8BL}},{{6L,6L,0x99613C26L,1L,0x2167B720L},{0xE46E4152L,0x7E050F62L,0xE5B76DE3L,0x24CD8831L,0xF2296631L},{0xD0240CB2L,6L,0x2167B720L,(-9L),1L}},{{(-1L),0x7E050F62L,1L,5L,0xE5B76DE3L},{(-1L),6L,(-7L),0x02D4B8C1L,(-7L)},{0x7E050F62L,0x7E050F62L,0xF2296631L,1L,0L}},{{6L,6L,3L,2L,0x4038DB89L},{1L,0xF2296631L,(-1L),0L,0x44733A34L},{0x2167B720L,0x99613C26L,0xAC160366L,0x4BBBC186L,(-5L)}},{{0xE5B76DE3L,0xF2296631L,(-1L),(-2L),(-1L)},{0x99613C26L,0x99613C26L,0x4038DB89L,0x8EF58579L,4L},{0xB3B41C8BL,0xF2296631L,0x23547353L,0xE81B0DD0L,1L}},{{1L,0x99613C26L,4L,0x1121AFC8L,0xAC160366L},{0L,0xF2296631L,0x44733A34L,0xEB873E0AL,0x23547353L},{3L,0x99613C26L,(-1L),(-1L),(-1L)}},{{0xF2296631L,0xF2296631L,1L,0xBD5EF08AL,(-1L)},{(-7L),0x99613C26L,(-5L),2L,0x4038DB89L},{1L,0xF2296631L,(-1L),0L,0x44733A34L}}}; + int64_t l_1854 = 0xADF24D625A36C360LL; + int32_t l_1873 = 0xFEA54D9AL; + uint32_t ***l_1898[9] = {&g_895,&g_895,&g_895,&g_895,&g_895,&g_895,&g_895,&g_895,&g_895}; + int8_t **l_1908 = (void*)0; + int32_t l_1920 = 0x1FADB910L; + int16_t l_2003 = 1L; + uint32_t l_2036 = 0UL; + int i, j, k; + for (i = 0; i < 4; i++) + l_1690[i] = 0xEEL; + for (i = 0; i < 3; i++) + l_1813[i] = &l_1814; + } + } + else + { /* block id: 824 */ + union U1 l_2074 = {1UL}; + int32_t l_2077 = 3L; + int32_t l_2080[2][9][10] = {{{7L,0xE6CAC280L,0L,0xE6CAC280L,7L,0x4ACF1F08L,7L,0xE6CAC280L,0L,0xE6CAC280L},{(-3L),0xFBE26421L,0xCE82E6B6L,0xE6CAC280L,0xCE82E6B6L,0xFBE26421L,(-3L),0xFBE26421L,0xCE82E6B6L,0xE6CAC280L},{4L,0xE6CAC280L,4L,0xFBE26421L,7L,0xFBE26421L,4L,0xE6CAC280L,4L,0xFBE26421L},{(-3L),0xE6CAC280L,0xCF02BBBAL,0xE6CAC280L,(-3L),0x4ACF1F08L,(-3L),0xE6CAC280L,0xCF02BBBAL,0xE6CAC280L},{7L,0xFBE26421L,4L,0xE6CAC280L,4L,0xFBE26421L,7L,0xFBE26421L,4L,0xE6CAC280L},{0xCE82E6B6L,0xE6CAC280L,0xCE82E6B6L,0xFBE26421L,(-3L),0xFBE26421L,0xCE82E6B6L,0xE6CAC280L,0xCE82E6B6L,0xFBE26421L},{7L,0xE6CAC280L,0L,0xE6CAC280L,7L,0x4ACF1F08L,7L,0xE6CAC280L,0L,0xE6CAC280L},{(-3L),0xFBE26421L,0xCE82E6B6L,0xE6CAC280L,0xCE82E6B6L,0xFBE26421L,(-3L),0xFBE26421L,0xCE82E6B6L,0xE6CAC280L},{4L,0xE6CAC280L,4L,0xFBE26421L,7L,0xFBE26421L,4L,0xE6CAC280L,4L,0xFBE26421L}},{{(-3L),0xE6CAC280L,0xCF02BBBAL,0xE6CAC280L,(-3L),0x4ACF1F08L,(-3L),0xE6CAC280L,0xCF02BBBAL,0xE6CAC280L},{7L,0xFBE26421L,4L,0xE6CAC280L,4L,0xFBE26421L,7L,0xFBE26421L,4L,0xE6CAC280L},{0xCE82E6B6L,0xE6CAC280L,0xCE82E6B6L,0xFBE26421L,(-3L),0xFBE26421L,0xCE82E6B6L,0xE6CAC280L,0xCE82E6B6L,0xFBE26421L},{7L,0xE6CAC280L,0L,0xE6CAC280L,7L,0xE6CAC280L,4L,0xFBE26421L,7L,0xFBE26421L},{0xCE82E6B6L,0x4ACF1F08L,0xCF02BBBAL,0xFBE26421L,0xCF02BBBAL,0x4ACF1F08L,0xCE82E6B6L,0x4ACF1F08L,0xCF02BBBAL,0xFBE26421L},{0L,0xFBE26421L,0L,0x4ACF1F08L,4L,0x4ACF1F08L,0L,0xFBE26421L,0L,0x4ACF1F08L},{0xCE82E6B6L,0xFBE26421L,(-3L),0xFBE26421L,0xCE82E6B6L,0xE6CAC280L,0xCE82E6B6L,0xFBE26421L,(-3L),0xFBE26421L},{4L,0x4ACF1F08L,0L,0xFBE26421L,0L,0x4ACF1F08L,4L,0x4ACF1F08L,0L,0xFBE26421L},{0xCF02BBBAL,0xFBE26421L,0xCF02BBBAL,0x4ACF1F08L,0xCE82E6B6L,0x4ACF1F08L,0xCF02BBBAL,0xFBE26421L,0xCF02BBBAL,0x4ACF1F08L}}}; + uint16_t *l_2087[9][4][1] = {{{(void*)0},{&g_1999},{(void*)0},{&g_852[0].f0}},{{&g_1009[1][1][5]},{&l_1648[0][1][1]},{(void*)0},{&l_1342.f0}},{{&l_1342.f0},{(void*)0},{&l_1648[0][1][1]},{&g_1009[1][1][5]}},{{&g_852[0].f0},{(void*)0},{&g_1999},{(void*)0}},{{&g_852[0].f0},{&g_1009[1][1][5]},{&l_1648[0][1][1]},{(void*)0}},{{&l_1342.f0},{&l_1342.f0},{(void*)0},{&l_1648[0][1][1]}},{{&g_1009[1][1][5]},{&g_852[0].f0},{(void*)0},{&g_1999}},{{(void*)0},{&g_852[0].f0},{&g_1009[1][1][5]},{&l_1648[0][1][1]}},{{(void*)0},{&l_1342.f0},{&l_1342.f0},{(void*)0}}}; + int64_t l_2098[6][7][6] = {{{(-8L),0x576DBCE621845174LL,0x9FECAE66D53FF29BLL,0x55EFF736B83CBF98LL,0xC3E1C0F5CD37EED9LL,(-1L)},{0L,(-1L),0xC3E1C0F5CD37EED9LL,0xC3E1C0F5CD37EED9LL,(-1L),0L},{0L,4L,0x2EE7924C7FE0DA3ELL,0xAC97E384A0763003LL,(-1L),0xC5C2C2A5D08E1602LL},{(-1L),6L,(-1L),1L,(-8L),0L},{(-1L),(-1L),1L,0xAC97E384A0763003LL,0x459DD4E47D8D5F47LL,0xA4F668F5EA8753F9LL},{0L,(-1L),0x3E48A03BE349DC22LL,0xC3E1C0F5CD37EED9LL,0x2EE7924C7FE0DA3ELL,0xCCCA6D4B025213F2LL},{0L,0xAC97E384A0763003LL,1L,0x55EFF736B83CBF98LL,0x0E766CE927676853LL,(-1L)}},{{(-8L),1L,0x1C1F23E86A7076A9LL,0L,0x0D2DF2AE959BA218LL,0x0E766CE927676853LL},{0xC3E1C0F5CD37EED9LL,(-1L),6L,0L,6L,(-1L)},{0x1C1F23E86A7076A9LL,0x459DD4E47D8D5F47LL,1L,1L,0x87CC6D150623D112LL,(-1L)},{0x459DD4E47D8D5F47LL,0x4DE3D6FAAAC8BFA8LL,(-1L),0x0E766CE927676853LL,0L,0xA497F8BEAF9BD2BALL},{0x30ACE435F12FFCF0LL,0x4DE3D6FAAAC8BFA8LL,0xA4F668F5EA8753F9LL,0xB1F3B5B8A812C160LL,0x87CC6D150623D112LL,(-1L)},{(-1L),0x459DD4E47D8D5F47LL,0x076618914937BC82LL,0x9FECAE66D53FF29BLL,6L,0x3E48A03BE349DC22LL},{0xF724EC31BDD01534LL,(-1L),4L,0x1C1F23E86A7076A9LL,0x0D2DF2AE959BA218LL,0L}},{{0L,1L,0xC5C2C2A5D08E1602LL,0x108A8C04863AE15DLL,0x0E766CE927676853LL,0xAC97E384A0763003LL},{(-1L),0xAC97E384A0763003LL,(-8L),0x2EE7924C7FE0DA3ELL,0x2EE7924C7FE0DA3ELL,(-8L)},{(-1L),(-1L),0x108A8C04863AE15DLL,0x30ACE435F12FFCF0LL,0L,0x459DD4E47D8D5F47LL},{(-1L),(-1L),(-1L),0x1C1F23E86A7076A9LL,0L,0L},{0x20777C8D9E650ED9LL,(-1L),(-1L),1L,0xAC97E384A0763003LL,0x459DD4E47D8D5F47LL},{0x0D2DF2AE959BA218LL,1L,0L,0xF724EC31BDD01534LL,5L,0L},{0xF724EC31BDD01534LL,5L,0L,0xB1F3B5B8A812C160LL,6L,0x87CC6D150623D112LL}},{{(-9L),0x9FECAE66D53FF29BLL,0x108A8C04863AE15DLL,(-1L),0x2EE7924C7FE0DA3ELL,0xA497F8BEAF9BD2BALL},{0x2EE7924C7FE0DA3ELL,0x3E48A03BE349DC22LL,1L,0xCCCA6D4B025213F2LL,0x9FECAE66D53FF29BLL,0xCCCA6D4B025213F2LL},{4L,0xA497F8BEAF9BD2BALL,4L,(-1L),0x076618914937BC82LL,5L},{0xCCCA6D4B025213F2LL,0x4DE3D6FAAAC8BFA8LL,(-9L),0xAC97E384A0763003LL,0xC3E1C0F5CD37EED9LL,0xF724EC31BDD01534LL},{0x0E766CE927676853LL,0x55EFF736B83CBF98LL,1L,0xAC97E384A0763003LL,0L,(-1L)},{0xCCCA6D4B025213F2LL,(-8L),0x55EFF736B83CBF98LL,(-1L),0xB1F3B5B8A812C160LL,0x076618914937BC82LL},{4L,(-1L),(-1L),0xCCCA6D4B025213F2LL,(-1L),(-8L)}},{{0x2EE7924C7FE0DA3ELL,1L,0xC3E1C0F5CD37EED9LL,(-1L),(-1L),0x3E48A03BE349DC22LL},{(-9L),0x20777C8D9E650ED9LL,0x459DD4E47D8D5F47LL,0xB1F3B5B8A812C160LL,0x30ACE435F12FFCF0LL,0x30ACE435F12FFCF0LL},{0xF724EC31BDD01534LL,0xCCCA6D4B025213F2LL,0xCCCA6D4B025213F2LL,0xF724EC31BDD01534LL,1L,(-9L)},{0x0D2DF2AE959BA218LL,0xC3E1C0F5CD37EED9LL,0L,1L,0x87CC6D150623D112LL,0x0E766CE927676853LL},{0x20777C8D9E650ED9LL,(-1L),5L,0x1C1F23E86A7076A9LL,0x87CC6D150623D112LL,0x108A8C04863AE15DLL},{(-1L),0xC3E1C0F5CD37EED9LL,0x576DBCE621845174LL,(-1L),1L,(-1L)},{0xAC97E384A0763003LL,0xCCCA6D4B025213F2LL,6L,0x576DBCE621845174LL,0x30ACE435F12FFCF0LL,(-1L)}},{{0x076618914937BC82LL,0x20777C8D9E650ED9LL,(-1L),0L,(-1L),0x576DBCE621845174LL},{0xA497F8BEAF9BD2BALL,1L,0xB1F3B5B8A812C160LL,0xC3E1C0F5CD37EED9LL,(-1L),0x0D2DF2AE959BA218LL},{0xB1F3B5B8A812C160LL,(-1L),0L,(-1L),0xB1F3B5B8A812C160LL,0x9FECAE66D53FF29BLL},{(-1L),(-8L),(-1L),(-1L),0L,1L},{(-1L),0x55EFF736B83CBF98LL,0x20777C8D9E650ED9LL,(-8L),0xC3E1C0F5CD37EED9LL,1L},{0L,0x4DE3D6FAAAC8BFA8LL,(-1L),0x459DD4E47D8D5F47LL,0x076618914937BC82LL,0x9FECAE66D53FF29BLL},{0xC3E1C0F5CD37EED9LL,0xA497F8BEAF9BD2BALL,0L,0x2EE7924C7FE0DA3ELL,0x9FECAE66D53FF29BLL,0x0D2DF2AE959BA218LL}}}; + int32_t l_2100 = 5L; + uint8_t *** const l_2107 = (void*)0; + uint8_t *** const *l_2106 = &l_2107; + uint8_t *** const ** const l_2105[2] = {&l_2106,&l_2106}; + int16_t *l_2140 = &g_143; + int16_t **l_2139 = &l_2140; + uint32_t **** const *l_2148[2][10][1]; + const int64_t l_2151 = 0L; + uint16_t l_2215 = 0UL; + int32_t **l_2222 = (void*)0; + uint32_t **l_2259 = (void*)0; + int i, j, k; + for (i = 0; i < 2; i++) + { + for (j = 0; j < 10; j++) + { + for (k = 0; k < 1; k++) + l_2148[i][j][k] = &l_1969; + } + } + if ((safe_add_func_uint8_t_u_u((l_2074 , (safe_mul_func_uint32_t_u_u((**g_895), (l_2077 = (0xFDB9L | p_28.f0))))), (safe_mod_func_uint8_t_u_u(0xB5L, (l_2080[0][6][6] |= 0x01L)))))) + { /* block id: 827 */ + uint16_t *l_2088 = &g_35; + int32_t l_2092 = (-1L); + uint8_t *l_2097[2]; + uint8_t *****l_2104 = &g_1515; + uint16_t l_2119 = 0xA2E9L; + int i; + for (i = 0; i < 2; i++) + l_2097[i] = &g_441; + if ((**g_1702)) + { /* block id: 828 */ + for (g_122.f2 = 0; (g_122.f2 <= 3); g_122.f2 += 1) + { /* block id: 831 */ + return (*g_1125); + } + } + else + { /* block id: 834 */ + uint16_t **l_2089 = &g_456; + uint8_t *l_2096 = &g_441; + int32_t l_2112 = (-1L); + int16_t *l_2118[10][7] = {{&g_143,(void*)0,&g_2095,&l_1556,&g_2095,&g_2095,&l_1556},{&l_1556,&g_143,&l_1556,&g_2095,&g_2095,&g_143,(void*)0},{&l_1556,&l_1556,&l_1556,(void*)0,(void*)0,&g_143,&g_143},{&g_143,&g_2095,&l_1556,&l_1556,&g_2095,&g_143,&g_2095},{&g_2095,&l_1556,(void*)0,&l_1556,&g_2095,&g_2095,&g_2095},{&g_143,&l_1556,&g_2095,&g_143,&l_1556,&g_143,&g_2095},{&g_143,&g_143,(void*)0,&g_2095,&l_1556,&g_2095,&g_2095},{&g_2095,(void*)0,&g_2095,&g_143,&g_2095,&g_143,&g_143},{&l_1556,&l_1556,&g_143,&l_1556,&l_1556,&g_143,&g_2095},{&g_2095,(void*)0,&g_143,&g_2095,&l_1556,&l_1556,&l_1556}}; + int i, j; +lbl_2120: + l_2100 |= (l_2099 = (safe_div_func_int8_t_s_s(p_28.f0, (4294967295UL || (safe_sub_func_uint8_t_u_u((safe_sub_func_uint32_t_u_u((l_2087[0][0][0] != ((*l_2089) = l_2088)), (l_2080[0][6][6] ^= (safe_sub_func_uint64_t_u_u((l_2092 , (((safe_add_func_int32_t_s_s((l_2092 ^= 0xD1ED0FE3L), ((g_2095 ^= 0L) , ((((l_2077 , p_28.f0) != (*g_56)) , l_2096) != l_2097[0])))) , g_1999) || 9L)), 1UL))))), l_2098[0][1][5])))))); + if ((((p_28.f0 , ((safe_mul_func_int32_t_s_s(p_28.f0, (l_2112 = ((safe_unary_minus_func_int8_t_s(((l_2104 = l_2104) == l_2105[1]))) < (safe_lshift_func_uint8_t_u_s((safe_add_func_uint16_t_u_u((((l_2112 ^ (l_2119 &= (l_2112 <= ((safe_div_func_uint32_t_u_u((((0x65L == (((~(g_2095 = (0x42412131L <= ((safe_rshift_func_int32_t_s_u(p_28.f0, (**g_895))) < p_28.f0)))) & l_2112) , p_28.f0)) | l_2112) > p_28.f0), p_28.f0)) != 0x6E0DL)))) < (-1L)) | 5UL), 0UL)), 1)))))) , g_852[0].f0)) & (*g_1125)) || p_28.f0)) + { /* block id: 845 */ + if (g_143) + goto lbl_2120; + } + else + { /* block id: 847 */ + return p_28.f0; + } + } + (*g_1702) = (void*)0; + } + else + { /* block id: 852 */ + uint16_t l_2121[4] = {9UL,9UL,9UL,9UL}; + int32_t ***l_2144 = &g_55[0][0][1]; + int32_t ****l_2143[4]; + uint32_t ***** const l_2147 = &l_1969; + uint8_t l_2149 = 255UL; + uint64_t *l_2174 = &g_122.f1; + union U1 ***l_2186 = (void*)0; + uint64_t *l_2187 = &g_1214; + uint64_t *l_2188[2][8] = {{&g_417,(void*)0,(void*)0,&g_417,(void*)0,(void*)0,&g_417,(void*)0},{&g_417,&g_417,&g_417,&g_417,&g_417,&g_417,&g_417,&g_417}}; + int32_t * const *l_2223 = &g_2220; + union U0 ***l_2228[2]; + union U0 ****l_2227 = &l_2228[0]; + union U0 ****l_2233[1][9] = {{&l_2228[0],(void*)0,&l_2228[0],&l_2228[0],(void*)0,&l_2228[0],&l_2228[0],(void*)0,&l_2228[0]}}; + const uint16_t l_2262 = 0x465DL; + int i, j; + for (i = 0; i < 4; i++) + l_2143[i] = &l_2144; + for (i = 0; i < 2; i++) + l_2228[i] = &l_1279; + ++l_2121[2]; + l_2077 = (!(safe_lshift_func_uint8_t_u_s(((safe_add_func_int8_t_s_s(((safe_rshift_func_int64_t_s_s(0x299A59A0425FB873LL, 13)) == (safe_rshift_func_uint64_t_u_u(p_28.f0, 5))), (((safe_mul_func_int16_t_s_s((g_2095 &= g_878), (safe_div_func_int8_t_s_s(((safe_mul_func_int8_t_s_s((p_28.f0 >= ((&g_1977 != l_2139) | ((((((*g_99) &= p_28.f0) > ((safe_mul_func_uint16_t_u_u(((((l_2145[0][2][0] = l_2143[2]) == &g_1302) , p_28.f0) | (***l_2144)), 65535UL)) , 4UL)) , l_2147) != l_2148[1][4][0]) | l_2149))), g_2150)) , p_28.f0), l_2080[0][6][6])))) | 0x7186L) , 6UL))) , p_28.f0), l_2151))); + if (((g_2095 &= ((*g_1019) == (((((void*)0 != g_2152) != (safe_lshift_func_int32_t_s_u((safe_mul_func_int16_t_s_s(((((safe_sub_func_int16_t_s_s((safe_add_func_uint64_t_u_u((safe_sub_func_uint32_t_u_u((((****l_1969) = ((&g_1533 == ((safe_add_func_uint8_t_u_u((safe_add_func_int64_t_s_s((4294967293UL ^ 0xE3C48971L), ((*l_2174) = p_28.f0))), ((-5L) ^ (((safe_mod_func_uint64_t_u_u(((l_2080[0][6][6] = (!(safe_rshift_func_uint64_t_u_u(((*l_2187) = (safe_div_func_uint64_t_u_u((((safe_rshift_func_uint16_t_u_u((++g_307[8][1]), 1)) ^ (&l_1818 == l_2186)) && g_441), 0x86CB52F506A54EE8LL))), g_145)))) | p_28.f0), g_1689[2])) <= 0xB776L) >= l_2100)))) , &g_1533)) >= 0L)) & p_28.f0), 0x72D30A93L)), p_28.f0)), g_143)) , p_28.f0) , l_2100) >= p_28.f0), (***l_2144))), p_28.f0))) | g_305) , p_28.f0))) == p_28.f0)) + { /* block id: 864 */ + uint8_t l_2206 = 0x66L; + const int8_t *l_2210 = &g_933; + const int8_t **l_2209 = &l_2210; + const int8_t ***l_2208 = &l_2209; + const int8_t ****l_2207[8]; + int32_t *l_2218[8][9] = {{&g_1689[3],&g_2150,&g_2150,&g_1689[3],&l_1597,&g_1689[3],(void*)0,&l_1598,&l_1598},{&g_1689[3],&l_1597,&g_1689[3],&l_1823[6][0][0],&l_1597,&l_1597,&l_1597,&l_1823[6][0][0],&g_1689[3]},{&l_1598,&l_1598,&g_1689[3],&g_2150,&l_1597,&l_1598,&l_1597,(void*)0,&g_1689[3]},{(void*)0,&l_1395,(void*)0,&l_1823[6][0][0],(void*)0,&l_1823[6][0][0],(void*)0,&l_1395,(void*)0},{&l_1597,&l_1597,&g_1689[3],&g_1689[3],&l_1598,(void*)0,&g_2150,&l_1598,&l_1598},{&l_1597,&l_1395,&g_1689[3],(void*)0,&g_1689[3],&l_1395,&l_1597,(void*)0,&l_1597},{&l_1597,&l_1598,&g_2150,&l_1597,&g_1689[3],&l_1598,&g_1689[3],&g_1689[3],&l_1598},{(void*)0,&l_1597,&l_1823[3][5][1],&l_1597,(void*)0,(void*)0,&l_1823[3][5][1],(void*)0,(void*)0}}; + union U0 ****l_2232 = &l_2228[1]; + int32_t l_2242 = 0x9BA6DCB1L; + int i, j; + for (i = 0; i < 8; i++) + l_2207[i] = &l_2208; + if (((safe_div_func_int16_t_s_s(g_2150, (safe_div_func_int32_t_s_s(0x5D228C8CL, ((!((((safe_add_func_int16_t_s_s((safe_lshift_func_uint16_t_u_s((safe_lshift_func_uint8_t_u_u((safe_mul_func_int16_t_s_s(l_2098[0][1][5], ((((safe_rshift_func_int8_t_s_s(((((*l_2174) &= (p_28.f0 >= l_2206)) & ((g_2150 > ((((**l_1256) &= (l_2207[3] == (((safe_div_func_int16_t_s_s(((((safe_rshift_func_int8_t_s_s(((*g_99) = (p_28.f0 ^ 1L)), 6)) , (*g_1092)) , 0L) <= p_28.f0), p_28.f0)) ^ 1L) , (void*)0))) , 1UL) == 6L)) < 0xA4C7FA1D57542781LL)) < 4294967295UL), 2)) && l_2215) & p_28.f0) || 0x22CCL))), p_28.f0)), g_1056[0])), l_2074.f0)) , (void*)0) != l_2216) ^ 0xE15C8DD5L)) , p_28.f0))))) >= (-10L))) + { /* block id: 868 */ + l_2077 |= l_2206; + return p_28.f0; + } + else + { /* block id: 871 */ + int32_t ***l_2221[8][3] = {{&g_2219,(void*)0,(void*)0},{&g_2219,(void*)0,&g_2219},{&g_2219,&g_2219,(void*)0},{&g_2219,(void*)0,&g_2219},{&g_2219,(void*)0,(void*)0},{&g_2219,(void*)0,&g_2219},{&g_2219,&g_2219,(void*)0},{&g_2219,(void*)0,&g_2219}}; + int32_t l_2224[7][1]; + union U0 *****l_2231 = (void*)0; + int i, j; + for (i = 0; i < 7; i++) + { + for (j = 0; j < 1; j++) + l_2224[i][j] = 1L; + } + l_2224[5][0] = ((l_2218[1][0] != (((l_2222 = g_2219) != l_2223) , (*g_2219))) && 0x90A4L); + l_2242 ^= (safe_mod_func_uint64_t_u_u((l_2227 != (l_2233[0][1] = (g_1056[0] , (l_2232 = l_2229)))), (safe_div_func_int64_t_s_s((*g_1125), (safe_sub_func_int8_t_s_s(p_28.f0, (l_2206 , (safe_add_func_int64_t_s_s((((g_2240 = (void*)0) != ((*l_1724) = (void*)0)) , l_2241), l_2151))))))))); + } + } + else + { /* block id: 880 */ + const uint32_t **l_2260 = (void*)0; + const uint32_t ***l_2261 = &l_2260; + int32_t l_2263 = 0x7D5E08C8L; + (**g_1701) = func_81((((*g_1019) = (((safe_mul_func_uint8_t_u_u((0x64C31C25L >= ((!(safe_div_func_int64_t_s_s((safe_unary_minus_func_uint16_t_u((p_28.f0 ^ ((((safe_sub_func_uint16_t_u_u((safe_rshift_func_int32_t_s_u((((safe_div_func_int32_t_s_s((safe_div_func_int16_t_s_s(((((l_2259 == ((*l_2261) = l_2260)) , l_2262) || ((l_2263 ^= 0x9F6BL) != (((***l_2144) > ((65535UL > (l_2074 , 1L)) & 8L)) >= p_28.f0))) > 0x9BL), 0x0343L)), p_28.f0)) > (-9L)) > p_28.f0), p_28.f0)), g_122.f1)) , 0xDF5F46C1L) >= p_28.f0) >= p_28.f0)))), g_305))) & 0xC5C0L)), (***l_2144))) && 0x98C9EDF83F4F48EELL) , l_2263)) <= p_28.f0), p_28.f0); + } + } + for (g_267 = 3; (g_267 >= 0); g_267 -= 1) + { /* block id: 889 */ + union U0 **** const l_2274 = &l_2230; + int32_t l_2278 = 0x51B88579L; + int32_t l_2279 = 9L; + (**g_1701) = (void*)0; + l_2278 = (((safe_add_func_uint64_t_u_u(((l_2279 ^= (((safe_lshift_func_uint8_t_u_u((p_28.f0 , p_28.f0), (safe_lshift_func_uint16_t_u_s((--g_1009[9][3][3]), (((((safe_mod_func_uint64_t_u_u(((l_2077 ^ (l_2274 == (void*)0)) || (!((!(0xA3772BF5L | (p_28 , 0x44C0915FL))) ^ (((safe_unary_minus_func_int8_t_s(((&g_1977 != (void*)0) >= l_2077))) == 0x53EC00BEL) || l_2278)))), 0x3636E33FDBF33FCBLL)) | p_28.f0) ^ 4UL) ^ p_28.f0) ^ 7UL))))) != p_28.f0) >= 1UL)) & 0x0AE68E36L), l_2278)) , g_207) <= p_28.f0); + return (*g_1125); + } + for (g_137 = 0; (g_137 > (-22)); --g_137) + { /* block id: 898 */ + int32_t l_2282 = 0x8F759302L; + return l_2282; + } + (*g_1702) = (void*)0; + } + return (*g_1125); +} + + +/* ------------------------------------------ */ +/* + * reads : + * writes: + */ +static int32_t func_40(uint8_t p_41) +{ /* block id: 10 */ + int32_t *l_43 = &g_3; + int32_t **l_42[10][1] = {{(void*)0},{&l_43},{&l_43},{(void*)0},{&l_43},{&l_43},{(void*)0},{&l_43},{&l_43},{(void*)0}}; + int32_t *l_44 = (void*)0; + int i, j; + l_44 = (void*)0; + return p_41; +} + + +/* ------------------------------------------ */ +/* + * reads : + * writes: + */ +static union U0 func_49(int64_t p_50, int32_t ** p_51, int32_t ** p_52, int32_t * p_53, int32_t ** p_54) +{ /* block id: 13 */ + int32_t *l_58 = &g_59; + int32_t *l_60 = &g_59; + int32_t *l_61 = &g_59; + int32_t *l_62 = &g_59; + int32_t *l_63 = (void*)0; + int32_t *l_64 = &g_59; + int32_t l_65 = 0L; + int32_t l_66 = 0xC7F2BAC4L; + int32_t *l_67 = &l_65; + int32_t l_68 = 0xA9A16D6AL; + int32_t l_69 = 0x9C74E37AL; + int32_t *l_70 = &l_65; + int32_t l_71[10][6] = {{(-8L),0x53D1EDBCL,0L,0x2DD2C990L,0x2DD2C990L,0L},{2L,2L,(-1L),0x2DD2C990L,0x53D1EDBCL,1L},{(-8L),(-1L),0x995E148CL,1L,0x995E148CL,(-1L)},{0x2DD2C990L,(-8L),0x995E148CL,0x08F18E0DL,1L,(-8L)},{0x2DD2C990L,(-1L),2L,2L,(-1L),0x2DD2C990L},{2L,(-1L),0x2DD2C990L,0x53D1EDBCL,1L,0L},{0L,0x5C6A8B5FL,0x08F18E0DL,0x5C6A8B5FL,0L,(-1L)},{0L,2L,0x5C6A8B5FL,0x53D1EDBCL,0x995E148CL,0x995E148CL},{2L,1L,1L,2L,0x08F18E0DL,0x995E148CL},{0x2DD2C990L,0x995E148CL,0x5C6A8B5FL,(-1L),0x53D1EDBCL,(-1L)}}; + int32_t *l_72 = &l_71[2][0]; + int32_t *l_73[5] = {(void*)0,(void*)0,(void*)0,(void*)0,(void*)0}; + int32_t l_74 = 0x743AFF46L; + int8_t l_75 = 0L; + uint8_t l_76 = 0UL; + uint16_t *l_86 = (void*)0; + int8_t *l_87[10] = {&l_75,&l_75,&l_75,&l_75,&l_75,&l_75,&l_75,&l_75,&l_75,&l_75}; + const int8_t l_95 = 0xC0L; + uint64_t l_561 = 0x8172D9ECA17E3086LL; + int32_t *l_1003 = &l_71[6][4]; + uint8_t **l_1021 = &g_1019; + int64_t l_1058 = 0xB00872DB421B2502LL; + int8_t ** const *l_1095 = &g_129; + int8_t ** const **l_1094 = &l_1095; + int8_t ** const ***l_1093[9][7] = {{&l_1094,&l_1094,&l_1094,&l_1094,&l_1094,(void*)0,&l_1094},{&l_1094,&l_1094,&l_1094,&l_1094,&l_1094,&l_1094,&l_1094},{&l_1094,&l_1094,&l_1094,&l_1094,&l_1094,&l_1094,&l_1094},{&l_1094,&l_1094,&l_1094,&l_1094,&l_1094,&l_1094,&l_1094},{&l_1094,&l_1094,&l_1094,&l_1094,&l_1094,&l_1094,&l_1094},{&l_1094,&l_1094,&l_1094,&l_1094,&l_1094,&l_1094,&l_1094},{&l_1094,&l_1094,&l_1094,&l_1094,&l_1094,(void*)0,&l_1094},{&l_1094,&l_1094,&l_1094,&l_1094,&l_1094,&l_1094,&l_1094},{&l_1094,&l_1094,&l_1094,&l_1094,&l_1094,&l_1094,&l_1094}}; + int64_t **l_1124[6] = {&g_712,&g_712,(void*)0,&g_712,&g_712,(void*)0}; + int32_t *l_1126 = &l_74; + union U0 l_1127[5] = {{0xEB0DAB1EL},{0xEB0DAB1EL},{0xEB0DAB1EL},{0xEB0DAB1EL},{0xEB0DAB1EL}}; + int i, j; + --l_76; + return l_1127[1]; +} + + +/* ------------------------------------------ */ +/* + * reads : g_35 g_896 g_118.f0 g_99 g_935 g_307 g_441 g_122.f0 g_267 g_305 g_852.f0 g_431 g_137 + * writes: g_35 g_305 g_441 g_852 g_100 g_933 g_935 g_122.f0 g_267 g_137 + */ +static int32_t * func_81(int8_t p_82, const uint16_t p_83) +{ /* block id: 353 */ + int32_t *l_899 = (void*)0; + int32_t **l_900 = &l_899; + int32_t l_901 = 4L; + uint32_t ***l_909 = (void*)0; + uint32_t ****l_908 = &l_909; + uint32_t ****l_912 = (void*)0; + int16_t *l_930 = &g_143; + int64_t l_936[4][10][3]; + int32_t *l_988 = &g_137; + int32_t *l_989[4]; + int i, j, k; + for (i = 0; i < 4; i++) + { + for (j = 0; j < 10; j++) + { + for (k = 0; k < 3; k++) + l_936[i][j][k] = 0x5EA390D7008F3867LL; + } + } + for (i = 0; i < 4; i++) + l_989[i] = (void*)0; + (*l_900) = l_899; + l_901 = (p_82 != p_82); + for (g_35 = 0; (g_35 >= 53); ++g_35) + { /* block id: 358 */ + uint32_t ****l_910[9] = {&l_909,&l_909,&l_909,&l_909,&l_909,&l_909,&l_909,&l_909,&l_909}; + uint32_t *****l_911[8][2] = {{(void*)0,(void*)0},{(void*)0,(void*)0},{(void*)0,(void*)0},{(void*)0,(void*)0},{(void*)0,(void*)0},{(void*)0,(void*)0},{(void*)0,(void*)0},{(void*)0,(void*)0}}; + int32_t *l_922 = &l_901; + int16_t *l_923 = (void*)0; + union U0 l_924 = {0xEA6E1561L}; + int16_t *l_929 = &g_143; + int16_t **l_928[10][2][3] = {{{(void*)0,&l_929,(void*)0},{&l_923,&l_923,&l_929}},{{(void*)0,&l_929,&l_923},{&l_923,&l_929,&l_929}},{{&l_923,(void*)0,&l_929},{&l_923,&l_923,&l_923}},{{&l_929,&l_923,&l_929},{&l_929,(void*)0,(void*)0}},{{&l_923,&l_923,&l_923},{&l_929,&l_923,&l_923}},{{(void*)0,(void*)0,&l_923},{(void*)0,&l_929,&l_923}},{{&l_929,&l_929,(void*)0},{&l_923,&l_929,&l_923}},{{&l_929,&l_923,(void*)0},{&l_929,(void*)0,&l_923}},{{&l_923,&l_923,&l_923},{&l_929,&l_923,&l_923}},{{&l_923,(void*)0,&l_929},{&l_923,&l_923,&l_929}}}; + int16_t l_931[3]; + int8_t *l_932 = &g_933; + int8_t *l_934 = &g_935; + int i, j, k; + for (i = 0; i < 3; i++) + l_931[i] = 0L; + for (g_305 = 0; (g_305 == 26); g_305++) + { /* block id: 361 */ + for (g_441 = 0; g_441 < 2; g_441 += 1) + { + union U1 tmp = {0x6248L}; + g_852[g_441] = tmp; + } + } + l_936[3][3][2] = (safe_lshift_func_int8_t_s_u(((l_908 == (l_912 = l_910[1])) == (safe_unary_minus_func_uint32_t_u((*g_896)))), (((safe_sub_func_int32_t_s_s((safe_div_func_int8_t_s_s(((*l_934) ^= ((*l_932) = ((safe_mod_func_uint16_t_u_u((safe_div_func_uint8_t_u_u((((*l_922) = 0xC24A8588L) && 0UL), ((p_83 & (((*g_99) = ((l_923 != (l_930 = ((l_924 , (!(safe_sub_func_int8_t_s_s(1L, p_82)))) , (void*)0))) != l_931[0])) == 255UL)) , 0xCDL))), p_83)) && 4294967295UL))), p_83)), (-1L))) >= g_307[0][3]) == p_83))); + } + for (g_441 = 0; (g_441 != 46); g_441++) + { /* block id: 374 */ + uint8_t l_947 = 1UL; + int32_t l_975 = 1L; + for (g_35 = 0; (g_35 < 45); g_35++) + { /* block id: 377 */ + int64_t *l_951 = &g_267; + int32_t l_952 = 0x100C7F77L; + uint16_t **l_953 = &g_456; + uint16_t ***l_954 = &l_953; + for (g_122.f0 = 0; (g_122.f0 != 0); g_122.f0 = safe_add_func_int32_t_s_s(g_122.f0, 8)) + { /* block id: 380 */ + if (p_83) + break; + } + if ((safe_rshift_func_uint8_t_u_u(((safe_rshift_func_uint16_t_u_u(((--l_947) == (((+(((((*l_951) ^= (-3L)) & l_952) , ((1UL >= (&g_456 != ((*l_954) = l_953))) < (safe_mul_func_int8_t_s_s(p_82, ((((safe_div_func_uint16_t_u_u((safe_mod_func_uint8_t_u_u(((safe_add_func_uint64_t_u_u((safe_rshift_func_uint64_t_u_u(((((safe_sub_func_uint16_t_u_u((safe_add_func_uint16_t_u_u(((safe_mul_func_uint16_t_u_u((safe_rshift_func_uint8_t_u_s((safe_rshift_func_uint8_t_u_u(((l_975 & (--g_305)) != l_975), 6)), 3)), (safe_sub_func_uint32_t_u_u((((safe_rshift_func_uint32_t_u_u(4294967295UL, (*g_896))) == l_952) <= 6L), l_952)))) , 1UL), g_852[0].f0)), g_431)) & l_952) > l_952) < l_975), g_118.f0)), p_83)) < l_952), l_952)), p_82)) > p_83) , p_83) || 9UL))))) > g_431)) , 0xBDF500BC7E5ED951LL) || p_82)), p_82)) , p_83), g_35))) + { /* block id: 387 */ + int32_t *l_982[5][6] = {{&l_975,&g_3,&g_878,&l_975,&g_135,&l_952},{&l_975,&g_135,&l_952,&g_3,&g_3,&l_952},{&g_145,&g_145,&g_878,&l_975,&g_3,&g_145},{&g_3,&g_135,&g_878,&l_975,&g_135,&g_878},{&g_145,&g_3,&g_878,&g_3,&g_145,&g_145}}; + int32_t *l_983 = &l_952; + int32_t *l_984 = (void*)0; + int i, j; + return l_984; + } + else + { /* block id: 389 */ + int32_t *l_987 = &g_137; + (*l_987) &= (g_441 | (safe_div_func_int32_t_s_s(l_947, l_975))); + } + } + return l_988; + } + return l_989[2]; +} + + +/* ------------------------------------------ */ +/* + * reads : g_135 g_586 g_100 g_99 g_417 g_529 g_129 g_56 g_214 g_118.f0 g_305 g_267 g_364 g_441 g_137 g_307 g_3 g_456 g_145 g_207 g_652 g_35 g_122.f2 g_431 g_143 g_852 g_852.f0 g_878 g_895 g_122.f3 + * writes: g_364 g_122.f3 g_100 g_118.f0 g_441 g_143 g_214 g_135 g_137 g_122.f2 g_267 g_712 g_417 g_431 g_35 g_878 + */ +static int32_t * func_88(int8_t p_89, uint8_t p_90, uint32_t p_91) +{ /* block id: 224 */ + int8_t l_562 = 0x39L; + int32_t l_563 = 8L; + uint8_t ***l_564 = (void*)0; + uint8_t *l_567 = &g_441; + uint8_t **l_566 = &l_567; + uint8_t ***l_565 = &l_566; + union U0 *l_584 = &g_118; + union U0 * const *l_583 = &l_584; + union U0 * const ** const l_582 = &l_583; + int32_t ***l_600[7] = {&g_55[0][1][0],&g_55[0][1][0],&g_55[0][0][2],&g_55[0][1][0],&g_55[0][1][0],&g_55[0][0][2],&g_55[0][1][0]}; + int8_t ** const * const *l_625 = (void*)0; + int8_t ** const * const **l_624[2][2][7] = {{{(void*)0,&l_625,&l_625,(void*)0,&l_625,&l_625,(void*)0},{&l_625,(void*)0,&l_625,&l_625,(void*)0,&l_625,&l_625}},{{(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,&l_625,&l_625,(void*)0,&l_625,&l_625,(void*)0}}}; + int32_t l_646[6] = {0x23ED612DL,1L,0x23ED612DL,0x23ED612DL,1L,0x23ED612DL}; + int16_t *l_734 = &g_143; + uint64_t l_737 = 1UL; + int32_t ** const l_782 = (void*)0; + int16_t l_797 = 0xA2F2L; + uint32_t l_844 = 0xE144C221L; + int32_t *l_857 = &g_135; + uint32_t *l_877 = (void*)0; + uint32_t **l_876 = &l_877; + uint32_t ***l_875 = &l_876; + int32_t *l_898 = &g_145; + int i, j, k; + l_563 = l_562; +lbl_760: + (*l_565) = (void*)0; + for (g_364 = 0; (g_364 <= 0); g_364 += 1) + { /* block id: 229 */ + union U0 l_585[1][8] = {{{0x6963784FL},{0xFB4B34CFL},{0x6963784FL},{0x6963784FL},{0xFB4B34CFL},{0x6963784FL},{0x6963784FL},{0xFB4B34CFL}}}; + int32_t l_601 = 0x693C9AFCL; + int8_t **l_623 = &g_99; + uint32_t ***l_651 = (void*)0; + int32_t *l_704 = &g_431; + int32_t l_801 = (-1L); + int32_t l_802[5][10][1] = {{{0xA3219000L},{0xDFC7D7BFL},{0xA3219000L},{0xA3219000L},{0xDFC7D7BFL},{0xA3219000L},{0xA3219000L},{0xDFC7D7BFL},{0xA3219000L},{0xA3219000L}},{{0xDFC7D7BFL},{0xA3219000L},{0xA3219000L},{0xDFC7D7BFL},{0xA3219000L},{0xA3219000L},{0xDFC7D7BFL},{0xA3219000L},{0xA3219000L},{0xDFC7D7BFL}},{{0xA3219000L},{0xA3219000L},{0xDFC7D7BFL},{0xA3219000L},{0xA3219000L},{0xDFC7D7BFL},{0xA3219000L},{0xA3219000L},{0xDFC7D7BFL},{0xA3219000L}},{{0xA3219000L},{0xDFC7D7BFL},{0xA3219000L},{0xA3219000L},{0xDFC7D7BFL},{0xA3219000L},{0xA3219000L},{0xDFC7D7BFL},{0xA3219000L},{0xA3219000L}},{{0xDFC7D7BFL},{0xA3219000L},{0xA3219000L},{0xDFC7D7BFL},{0xA3219000L},{0xA3219000L},{0xDFC7D7BFL},{0xA3219000L},{0xA3219000L},{0xDFC7D7BFL}}}; + uint8_t l_803[4][6] = {{248UL,248UL,1UL,248UL,248UL,1UL},{248UL,248UL,1UL,248UL,248UL,1UL},{248UL,248UL,1UL,248UL,248UL,1UL},{248UL,248UL,1UL,248UL,248UL,1UL}}; + uint32_t **l_897 = &g_896; + int i, j, k; + for (g_122.f3 = 0; (g_122.f3 <= 2); g_122.f3 += 1) + { /* block id: 232 */ + int32_t l_591 = 6L; + uint32_t *l_597[7] = {&g_122.f3,&g_122.f3,&g_122.f3,&g_122.f3,&g_122.f3,&g_122.f3,&g_122.f3}; + int i, j; + l_591 = (((((p_89 , p_91) && ((*g_99) = ((safe_sub_func_int8_t_s_s(l_562, (safe_lshift_func_uint32_t_u_s(((safe_unary_minus_func_int64_t_s(p_90)) & (safe_sub_func_int16_t_s_s((safe_div_func_uint64_t_u_u((safe_add_func_int64_t_s_s(g_135, (safe_lshift_func_int16_t_s_s(((safe_unary_minus_func_uint64_t_u(0x55D662D1E4E5A1CALL)) < (p_91 || (l_582 == (l_585[0][0] , g_586)))), g_100)))), l_585[0][0].f0)), p_91))), 31)))) < l_562))) == g_417) , (*g_529)) == (void*)0); + if (l_585[0][0].f0) + continue; + l_601 ^= ((((((((g_56 != (void*)0) , g_214[1][0]) && (((safe_sub_func_uint16_t_u_u(0x023EL, 0L)) > (safe_rshift_func_int16_t_s_s((l_591 ^= (safe_unary_minus_func_int64_t_s(((g_118.f0++) >= (0x04ADL < (l_563 = p_89)))))), 6))) > (l_600[2] == ((1UL != 18446744073709551615UL) , &g_280)))) != 1UL) || p_89) > 0x5A647AD6L) > (-1L)) , 0xB71DE1C6L); + l_601 = 0xB1BE82A2L; + for (p_91 = 0; (p_91 <= 2); p_91 += 1) + { /* block id: 243 */ + int32_t *l_602 = &l_563; + int32_t *l_603[5]; + int i; + for (i = 0; i < 5; i++) + l_603[i] = &g_3; + return l_603[4]; + } + } + for (g_441 = 0; (g_441 <= 2); g_441 += 1) + { /* block id: 249 */ + uint32_t l_608 = 5UL; + uint64_t l_614[5][2]; + int16_t *l_617 = (void*)0; + int16_t *l_618 = &g_143; + int8_t ****l_622 = (void*)0; + int8_t *****l_621 = &l_622; + int32_t *l_626 = &g_3; + int16_t l_680 = (-4L); + int32_t l_715 = 1L; + int8_t l_720 = 0x5FL; + const uint32_t l_741 = 0x2B2F754FL; + int32_t l_787 = (-4L); + int32_t l_839 = 7L; + int32_t l_840 = 0xD1D1FF97L; + int32_t l_842 = (-10L); + int32_t l_843[8] = {0L,0L,0L,0L,0L,0L,0L,0L}; + int i, j; + for (i = 0; i < 5; i++) + { + for (j = 0; j < 2; j++) + l_614[i][j] = 0x29970CCE6DB806D8LL; + } + if ((safe_add_func_uint16_t_u_u((g_305 > ((*g_456) = ((safe_add_func_uint64_t_u_u(((l_608 && (((safe_lshift_func_int64_t_s_s((!(((safe_sub_func_int8_t_s_s((p_89 = ((l_614[4][1] , p_91) < ((*l_618) = (safe_rshift_func_int64_t_s_u(p_91, 6))))), ((p_91 != ((((g_214[(g_364 + 2)][(g_441 + 1)] ^= g_267) , (safe_div_func_uint32_t_u_u((((l_621 == (func_110(l_623) , l_624[0][1][3])) , 0xF4L) & l_614[3][1]), l_585[0][0].f0))) > l_601) > p_91)) , l_585[0][0].f0))) <= p_90) >= 0x16D7272C0A078D2CLL)), g_307[3][1])) <= l_608) | (*g_56))) , l_601), l_601)) , 0xA7A1L))), l_585[0][0].f0))) + { /* block id: 254 */ + return l_626; + } + else + { /* block id: 256 */ + union U1 l_635 = {0x23FAL}; + int64_t *l_644 = (void*)0; + int64_t *l_645 = &g_267; + int32_t l_685[1]; + int32_t l_687 = 0x01471548L; + int32_t l_701 = 1L; + int8_t ** const ** const l_714 = (void*)0; + int64_t l_721 = (-8L); + int i; + for (i = 0; i < 1; i++) + l_685[i] = (-9L); + if ((((g_307[0][2] | ((((safe_mod_func_int8_t_s_s((safe_sub_func_int64_t_s_s(p_91, (((safe_mul_func_uint64_t_u_u((safe_add_func_int16_t_s_s((l_635 , 0xD428L), g_214[1][3])), ((p_90 && ((((((safe_mul_func_int64_t_s_s(((*l_645) &= ((safe_rshift_func_uint32_t_u_u((~(safe_mod_func_int32_t_s_s(((((!((void*)0 == &g_118)) <= p_89) , l_601) < g_417), g_145))), g_207)) & 0x0EDAL)), (-1L))) >= 0xBA7AL) == (*g_56)) , 0x6B3CL) & 0x8727L) || 0x6F42C5B4L)) | p_90))) || p_91) , g_305))), 0x94L)) , l_635.f0) , 0xBE5BL) < 0xA987L)) , (-6L)) , l_646[2])) + { /* block id: 258 */ + uint8_t l_647 = 8UL; + l_647 = p_90; + } + else + { /* block id: 260 */ + uint64_t l_660 = 0UL; + int32_t l_665 = (-5L); + const uint32_t l_700 = 0xBF20D7CDL; + uint32_t *l_702 = &l_585[0][0].f0; + uint64_t l_703 = 18446744073709551611UL; + uint64_t l_718 = 18446744073709551612UL; + union U1 l_719[10][3] = {{{0x931CL},{0x2D59L},{0x2D59L}},{{0UL},{0UL},{0UL}},{{0x931CL},{0x931CL},{0x2D59L}},{{65535UL},{0UL},{65535UL}},{{0x931CL},{0x2D59L},{0x2D59L}},{{0UL},{0UL},{0UL}},{{0x931CL},{0x931CL},{0x2D59L}},{{65535UL},{0UL},{65535UL}},{{0x931CL},{0x2D59L},{0x2D59L}},{{0UL},{0UL},{0UL}}}; + int32_t *l_744 = &g_145; + int i, j; + if (((((g_100 != (safe_rshift_func_int64_t_s_s((~p_90), (l_651 == g_652)))) == (((+((safe_lshift_func_uint8_t_u_s(((p_90 != g_35) < ((((func_110((*g_529)) , ((*l_626) , 0x3322L)) , l_660) , &g_417) == &g_417)), 3)) >= p_91)) , 0L) >= p_90)) || 18446744073709551613UL) , (*l_626))) + { /* block id: 261 */ + uint64_t *l_666 = &l_614[4][1]; + int32_t l_679 = 0x420019B2L; + uint32_t *l_683 = &l_585[0][0].f0; + int64_t *l_684[2]; + int32_t l_686 = 0xC55145E3L; + uint8_t *l_699 = (void*)0; + int i; + for (i = 0; i < 2; i++) + l_684[i] = (void*)0; + l_687 = ((safe_div_func_uint8_t_u_u((safe_sub_func_uint16_t_u_u((*g_456), (l_665 != (((*l_666)++) != (safe_mul_func_int16_t_s_s(((l_685[0] = (safe_div_func_int8_t_s_s((safe_rshift_func_int64_t_s_u((g_267 |= ((safe_add_func_uint16_t_u_u(p_90, 1UL)) != 0x93F7L)), (((safe_sub_func_uint32_t_u_u(((*l_683) = ((l_679 &= 0x00223285L) == (((((l_680 <= (-1L)) != ((((safe_rshift_func_uint8_t_u_s((g_307[1][1] , p_90), (*l_626))) > p_91) & (-1L)) <= 247UL)) > p_89) | p_91) > p_90))), p_90)) == p_89) >= g_122.f2))), p_91))) || p_89), p_89)))))), l_686)) , l_665); + if (p_89) + break; + l_703 ^= (safe_lshift_func_int16_t_s_u(((p_91 != 18446744073709551615UL) <= ((1UL == (safe_add_func_int16_t_s_s(g_135, ((*l_626) & (((*g_456) | ((((((safe_unary_minus_func_int32_t_s((((safe_mod_func_int16_t_s_s((safe_lshift_func_uint64_t_u_u((safe_mod_func_uint8_t_u_u((l_665 = g_417), (-1L))), 60)), (p_91 , l_700))) > l_701) <= g_118.f0))) , l_702) == (void*)0) | p_89) && 255UL) , l_700)) || (-1L)))))) , p_90)), 7)); + l_626 = &l_665; + } + else + { /* block id: 272 */ + uint32_t l_707 = 0x1B059608L; + int64_t **l_711[3][10][6] = {{{(void*)0,&l_644,&l_645,(void*)0,&l_645,(void*)0},{&l_645,&l_645,&l_645,&l_644,&l_644,&l_644},{&l_644,(void*)0,(void*)0,&l_644,(void*)0,&l_644},{&l_644,&l_645,&l_645,(void*)0,&l_644,(void*)0},{&l_645,(void*)0,&l_644,&l_644,(void*)0,&l_645},{&l_645,&l_644,&l_645,&l_645,&l_645,&l_644},{&l_645,&l_645,(void*)0,&l_645,&l_644,&l_645},{&l_645,&l_644,&l_645,&l_645,&l_644,&l_645},{&l_645,&l_645,&l_644,&l_644,&l_645,&l_644},{&l_645,&l_644,&l_645,(void*)0,&l_645,(void*)0}},{{&l_644,(void*)0,&l_645,&l_644,(void*)0,&l_644},{&l_644,&l_644,(void*)0,&l_644,&l_644,&l_644},{&l_645,(void*)0,&l_645,(void*)0,&l_644,&l_645},{(void*)0,&l_644,&l_644,(void*)0,&l_644,&l_645},{&l_644,&l_645,&l_645,&l_645,&l_644,&l_644},{&l_644,&l_645,(void*)0,(void*)0,&l_645,&l_644},{(void*)0,&l_645,&l_645,&l_645,(void*)0,(void*)0},{(void*)0,&l_645,&l_645,&l_645,&l_644,&l_644},{&l_645,&l_644,&l_644,&l_645,(void*)0,&l_645},{&l_644,&l_644,&l_645,&l_644,&l_645,&l_645}},{{&l_644,&l_645,(void*)0,&l_644,&l_645,&l_644},{&l_645,&l_644,&l_645,(void*)0,(void*)0,&l_645},{&l_645,&l_644,&l_644,&l_645,&l_644,(void*)0},{&l_645,&l_645,&l_645,&l_644,(void*)0,&l_644},{&l_644,&l_645,(void*)0,&l_644,&l_645,&l_644},{&l_645,&l_645,&l_645,&l_645,&l_644,(void*)0},{&l_645,&l_645,&l_645,&l_644,&l_644,&l_644},{(void*)0,&l_644,&l_645,(void*)0,&l_644,&l_644},{&l_645,(void*)0,&l_644,&l_644,&l_645,(void*)0},{&l_645,&l_644,&l_645,&l_645,&l_645,&l_644}}}; + union U0 ** const l_722[5][7][7] = {{{(void*)0,&l_584,&l_584,(void*)0,&l_584,&l_584,&l_584},{&l_584,&l_584,&l_584,&l_584,&l_584,&l_584,&l_584},{&l_584,&l_584,&l_584,&l_584,&l_584,&l_584,&l_584},{&l_584,(void*)0,&l_584,(void*)0,&l_584,(void*)0,(void*)0},{(void*)0,&l_584,&l_584,&l_584,&l_584,&l_584,(void*)0},{&l_584,&l_584,&l_584,(void*)0,(void*)0,(void*)0,&l_584},{(void*)0,&l_584,&l_584,&l_584,&l_584,&l_584,&l_584}},{{&l_584,&l_584,&l_584,&l_584,&l_584,&l_584,(void*)0},{&l_584,&l_584,&l_584,&l_584,&l_584,&l_584,&l_584},{&l_584,(void*)0,&l_584,&l_584,&l_584,&l_584,(void*)0},{(void*)0,&l_584,&l_584,&l_584,&l_584,&l_584,&l_584},{&l_584,&l_584,&l_584,(void*)0,&l_584,(void*)0,&l_584},{&l_584,(void*)0,&l_584,&l_584,&l_584,&l_584,(void*)0},{(void*)0,&l_584,&l_584,&l_584,&l_584,(void*)0,(void*)0}},{{&l_584,(void*)0,&l_584,&l_584,(void*)0,&l_584,&l_584},{&l_584,&l_584,&l_584,(void*)0,&l_584,&l_584,&l_584},{&l_584,&l_584,&l_584,&l_584,&l_584,&l_584,&l_584},{&l_584,&l_584,&l_584,(void*)0,&l_584,&l_584,&l_584},{&l_584,&l_584,&l_584,(void*)0,(void*)0,&l_584,&l_584},{&l_584,&l_584,&l_584,&l_584,&l_584,(void*)0,&l_584},{&l_584,&l_584,&l_584,&l_584,&l_584,&l_584,&l_584}},{{(void*)0,&l_584,&l_584,&l_584,&l_584,(void*)0,&l_584},{(void*)0,&l_584,&l_584,(void*)0,&l_584,&l_584,(void*)0},{&l_584,&l_584,(void*)0,(void*)0,&l_584,&l_584,&l_584},{&l_584,(void*)0,&l_584,&l_584,&l_584,&l_584,&l_584},{&l_584,&l_584,&l_584,&l_584,&l_584,&l_584,(void*)0},{&l_584,&l_584,&l_584,&l_584,&l_584,&l_584,&l_584},{&l_584,&l_584,(void*)0,&l_584,&l_584,&l_584,&l_584}},{{&l_584,&l_584,&l_584,&l_584,&l_584,&l_584,&l_584},{&l_584,&l_584,&l_584,&l_584,(void*)0,&l_584,&l_584},{&l_584,&l_584,&l_584,&l_584,&l_584,(void*)0,&l_584},{&l_584,&l_584,&l_584,&l_584,&l_584,&l_584,&l_584},{&l_584,&l_584,&l_584,&l_584,&l_584,&l_584,&l_584},{&l_584,&l_584,&l_584,(void*)0,&l_584,&l_584,&l_584},{&l_584,&l_584,&l_584,&l_584,&l_584,&l_584,&l_584}}}; + int32_t l_735 = 0xE625D4F8L; + uint16_t l_736 = 65533UL; + int i, j, k; + l_704 = &l_601; + l_715 &= (((safe_add_func_int8_t_s_s((l_707 , 0x2FL), ((+(safe_lshift_func_uint32_t_u_u(((((g_712 = &g_214[1][3]) == &g_214[1][3]) ^ p_91) & ((0x256D3B2FL >= (safe_unary_minus_func_int64_t_s(((((void*)0 != l_714) > (0x0D9CA7B907856A5CLL <= (*l_704))) ^ p_91)))) == g_267)), 21))) ^ l_701))) < g_207) >= l_703); + l_721 &= (l_720 = (((l_703 <= p_90) <= (l_707 >= (((*l_704) |= (l_585[0][7] , 0xAD1CCBADL)) || (((*g_456) = (safe_sub_func_int8_t_s_s((&p_89 != (void*)0), ((*g_99) = (l_718 ^= p_91))))) ^ (l_719[9][2] , p_91))))) , p_90)); + (*l_704) = (l_707 > (l_722[1][1][3] != ((0xB65BL >= (safe_mul_func_uint32_t_u_u(((*l_704) > (~((g_431 ^ (safe_sub_func_uint8_t_u_u(((safe_sub_func_int32_t_s_s((safe_mul_func_uint64_t_u_u(((((*g_456) = (safe_div_func_uint8_t_u_u((((((g_214[1][3] && ((l_734 != (void*)0) && ((l_735 = 0x22L) < (*l_626)))) ^ g_214[1][3]) == l_635.f0) != 6L) && (*l_704)), 0xA6L))) | l_736) , 0x23DCEC98B66774C8LL), l_721)), l_736)) || p_89), l_737))) <= l_736))), l_687))) , (void*)0))); + } + if (((safe_lshift_func_uint16_t_u_s(p_91, (safe_unary_minus_func_uint32_t_u(((void*)0 == &g_528[4]))))) , ((l_741 ^ (safe_add_func_uint16_t_u_u((*l_626), l_721))) < (*l_704)))) + { /* block id: 286 */ + if (p_89) + break; + l_744 = &l_665; + if ((*l_626)) + continue; + } + else + { /* block id: 290 */ + int32_t *l_747 = &l_646[4]; + int32_t **l_746[7][8][4] = {{{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,&l_747,(void*)0},{&l_747,(void*)0,&l_747,&l_747},{&l_747,(void*)0,&l_747,(void*)0},{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,&l_747,(void*)0}},{{&l_747,(void*)0,&l_747,&l_747},{&l_747,(void*)0,&l_747,(void*)0},{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,&l_747,(void*)0},{&l_747,(void*)0,&l_747,&l_747},{&l_747,(void*)0,&l_747,(void*)0},{&l_747,&l_747,&l_747,&l_747}},{{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,&l_747,(void*)0},{&l_747,(void*)0,&l_747,&l_747},{&l_747,(void*)0,&l_747,(void*)0},{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,&l_747,(void*)0},{&l_747,(void*)0,&l_747,&l_747}},{{&l_747,(void*)0,&l_747,(void*)0},{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,&l_747,(void*)0},{&l_747,(void*)0,&l_747,&l_747},{&l_747,(void*)0,(void*)0,&l_747},{&l_747,&l_747,(void*)0,&l_747},{&l_747,(void*)0,&l_747,&l_747}},{{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,(void*)0,&l_747},{&l_747,&l_747,(void*)0,&l_747},{&l_747,(void*)0,&l_747,&l_747},{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,(void*)0,&l_747}},{{&l_747,&l_747,(void*)0,&l_747},{&l_747,(void*)0,&l_747,&l_747},{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,(void*)0,&l_747},{&l_747,&l_747,(void*)0,&l_747},{&l_747,(void*)0,&l_747,&l_747},{&l_747,&l_747,&l_747,&l_747}},{{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,(void*)0,&l_747},{&l_747,&l_747,(void*)0,&l_747},{&l_747,(void*)0,&l_747,&l_747},{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,&l_747,&l_747},{&l_747,&l_747,(void*)0,&l_747},{&l_747,&l_747,(void*)0,&l_747}}}; + int32_t ***l_745 = &l_746[4][5][2]; + int32_t ***l_748 = (void*)0; + int32_t **l_750 = &l_747; + int32_t ***l_749 = &l_750; + int32_t **l_752 = &l_747; + int32_t ***l_751 = &l_752; + int i, j, k; + (*l_751) = ((*l_749) = ((*l_745) = (void*)0)); + l_665 |= ((*l_704) , (safe_mul_func_int32_t_s_s((p_91 == ((!((*l_744) | (p_89 | (l_635 , 0x724FL)))) , ((safe_mul_func_uint64_t_u_u((((safe_mul_func_uint16_t_u_u(((*g_456) = 65534UL), (((void*)0 == &g_118) == p_89))) , 255UL) && p_90), p_91)) || 0x03L))), p_90))); + if (g_364) + goto lbl_760; + } + for (l_562 = 0; (l_562 >= 0); l_562 -= 1) + { /* block id: 300 */ + int32_t *l_781 = &l_646[3]; + int32_t **l_780[4] = {&l_781,&l_781,&l_781,&l_781}; + uint64_t l_798[6][2] = {{0x40A473E20C4A9054LL,0UL},{0UL,0x40A473E20C4A9054LL},{0UL,0UL},{0x40A473E20C4A9054LL,0UL},{0UL,0x40A473E20C4A9054LL},{0UL,0UL}}; + uint64_t *l_799 = (void*)0; + uint64_t *l_800 = &g_417; + int i, j, k; + (*l_704) ^= ((safe_sub_func_int64_t_s_s((safe_sub_func_int64_t_s_s((safe_lshift_func_int32_t_s_s((!(safe_add_func_uint16_t_u_u(((((*l_800) ^= ((safe_sub_func_uint16_t_u_u((safe_mul_func_int32_t_s_s(((safe_add_func_uint16_t_u_u((safe_mul_func_int16_t_s_s((g_100 != (safe_div_func_int32_t_s_s((l_780[1] == l_782), (safe_rshift_func_int8_t_s_u((safe_mul_func_int32_t_s_s((p_91 || ((l_787 != (!(safe_lshift_func_int16_t_s_s((p_89 > (safe_mod_func_int32_t_s_s((safe_sub_func_int16_t_s_s(0L, (safe_mul_func_int16_t_s_s(((*l_734) = (0UL && 0UL)), (*g_456))))), 4L))), 4)))) | g_145)), l_797)), l_721))))), l_798[1][0])), g_364)) , (*g_56)), p_90)), (*l_744))) || p_89)) > g_122.f2) | p_90), 65534UL))), p_90)), 1UL)), g_122.f2)) , 0x38D08DE3L); + if (p_91) + break; + if (p_91) + continue; + } + } + l_803[3][5]--; + } + l_626 = ((((void*)0 == &l_802[4][5][0]) >= (p_91 <= (((((safe_mod_func_int8_t_s_s((p_89 || g_431), ((*g_99) = (safe_lshift_func_int16_t_s_u(((*l_734) ^= p_89), (8UL >= (safe_rshift_func_int64_t_s_s((safe_mod_func_uint8_t_u_u((p_90 = (((*l_704) && p_89) >= (*g_456))), p_91)), g_122.f2)))))))) > (*g_456)) < 0x5E0FA0D5L) , 65535UL) <= (*g_456)))) , (void*)0); + for (g_35 = 0; (g_35 != 8); g_35 = safe_add_func_uint8_t_u_u(g_35, 8)) + { /* block id: 316 */ + uint8_t *l_826 = (void*)0; + uint8_t *l_827 = &l_803[3][5]; + int32_t l_835 = 7L; + int32_t l_836[8][10] = {{0x4B62439DL,0L,1L,1L,0L,0x4B62439DL,0L,1L,1L,0L},{0x4B62439DL,0L,1L,1L,0L,0x4B62439DL,0L,1L,1L,0L},{0x4B62439DL,0L,1L,1L,0L,0x4B62439DL,0L,1L,1L,0L},{0x4B62439DL,0L,1L,1L,0L,0x4B62439DL,0L,1L,1L,0L},{0x4B62439DL,0L,1L,1L,0L,0x4B62439DL,0L,1L,1L,0L},{0x4B62439DL,0L,1L,1L,0L,0x4B62439DL,0L,1L,1L,0L},{0x4B62439DL,0L,1L,1L,0L,0x4B62439DL,0L,1L,1L,1L},{1L,1L,0L,0L,1L,1L,1L,0L,0L,1L}}; + uint8_t l_886 = 0x6FL; + int i, j; + l_704 = &l_802[2][6][0]; + (*l_704) = (safe_add_func_int64_t_s_s(0xFE7C445D7FD1BAB7LL, (((safe_mul_func_uint32_t_u_u((safe_add_func_int16_t_s_s(p_90, (g_143 = ((((*l_827) = (safe_sub_func_int32_t_s_s((*g_56), (safe_lshift_func_uint32_t_u_u(4294967295UL, 12))))) , &g_118) == (void*)0)))), ((((safe_add_func_uint32_t_u_u(((safe_sub_func_int32_t_s_s((p_90 > (safe_lshift_func_int16_t_s_s((0x7FE3L != (*g_456)), 10))), p_89)) < g_214[2][1]), p_90)) && g_307[0][3]) ^ p_90) && p_90))) && 0x11AEBE23L) && (*g_456)))); + for (g_137 = 0; (g_137 <= 6); g_137 += 1) + { /* block id: 323 */ + int32_t l_834 = (-9L); + int32_t l_837 = (-3L); + int32_t l_838 = 0x998FE91FL; + int32_t l_841[7] = {0xA26DD3ACL,0xA26DD3ACL,0xA26DD3ACL,0xA26DD3ACL,0xA26DD3ACL,0xA26DD3ACL,0xA26DD3ACL}; + uint32_t *l_860 = (void*)0; + uint32_t *l_861[8] = {(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0}; + union U1 l_874 = {0xDA10L}; + uint64_t *l_879[8][1] = {{&l_737},{&l_737},{&l_737},{&l_737},{&l_737},{&l_737},{&l_737},{&l_737}}; + int i, j; + ++l_844; + for (l_680 = 0; (l_680 <= 3); l_680 += 1) + { /* block id: 327 */ + uint64_t *l_849 = &l_737; + uint32_t *l_855 = &l_585[0][0].f0; + int32_t l_856 = (-7L); + int i, j; + (*l_704) = (((l_803[(g_364 + 1)][(g_364 + 4)] >= ((*g_456) = (*l_704))) >= ((safe_sub_func_uint64_t_u_u(((*l_849)--), ((((g_852[0] , ((((l_836[1][9] = (safe_sub_func_uint32_t_u_u((l_803[(g_364 + 1)][(g_364 + 4)] < ((((*l_855) = (((void*)0 != l_849) <= 0xDFL)) ^ (l_856 = ((g_852[0].f0 & p_91) != (-9L)))) | g_305)), 0x0EE5A381L))) , l_841[4]) <= p_89) >= g_137)) , p_91) && p_90) > 246UL))) || g_441)) >= l_835); + if (g_137) + goto lbl_760; + return l_857; + } + l_801 ^= (g_852[0].f0 | (safe_mod_func_int32_t_s_s(((l_834 &= 4294967295UL) , ((((safe_mod_func_uint64_t_u_u((l_836[7][3] = ((g_878 &= (safe_div_func_int64_t_s_s((((*l_704) = ((safe_lshift_func_uint32_t_u_s((safe_add_func_uint64_t_u_u((*l_857), 0x882FC67FF5D5F23CLL)), (((((safe_div_func_int64_t_s_s(((((l_874 , (((g_143 |= (g_652 == l_875)) < 65533UL) != (p_90 , l_838))) <= (*l_857)) == p_89) | p_91), g_852[0].f0)) && (-1L)) & p_90) , (-1L)) && 255UL))) & g_307[1][0])) && 0L), g_35))) || 0x55L)), l_835)) ^ 0L) <= 1L) & p_90)), p_90))); + } + (*l_704) &= (safe_sub_func_uint16_t_u_u(((safe_lshift_func_int32_t_s_u((((safe_lshift_func_int8_t_s_s((((l_886 ^ (safe_mul_func_uint16_t_u_u(((((safe_mod_func_uint8_t_u_u(((((((8UL && ((p_90 >= (((safe_mul_func_uint32_t_u_u((p_91 | (-2L)), (-2L))) >= (l_835 = (l_836[1][9] = ((safe_add_func_uint8_t_u_u(((((*l_857) = (g_895 != l_897)) , (g_56 == (void*)0)) >= 0xCA07L), g_100)) , g_3)))) , 0xDB7E94E76873EAE7LL)) >= p_90)) & 0UL) > 4294967295UL) | g_214[2][4]) & 246UL) , (*l_857)), 0xBBL)) == l_886) , g_214[1][3]) ^ (*g_456)), p_89))) || p_89) < 0x9BL), p_91)) >= 65529UL) | p_91), 12)) ^ p_91), (-3L))); + } + } + } + return l_898; +} + + +/* ------------------------------------------ */ +/* + * reads : g_35 g_99 g_3 g_100 g_118 g_122 g_129 g_137 g_122.f0 g_143 g_145 g_135 g_130 g_56 g_305 g_441 g_307 + * writes: g_99 g_100 g_35 g_135 g_137 g_143 g_145 + */ +static uint16_t func_92(int32_t ** p_93, const int32_t p_94) +{ /* block id: 16 */ + int32_t *l_96 = (void*)0; + int8_t **l_101 = (void*)0; + int8_t **l_102 = (void*)0; + int8_t **l_103 = &g_99; + union U1 l_556 = {0UL}; + int16_t *l_558 = &g_143; + int32_t *l_559[7][6][4] = {{{&g_431,&g_431,&g_137,&g_431},{&g_431,(void*)0,(void*)0,&g_431},{(void*)0,&g_431,(void*)0,(void*)0},{&g_431,&g_431,&g_137,&g_431},{&g_431,(void*)0,(void*)0,&g_431},{(void*)0,&g_431,(void*)0,(void*)0}},{{&g_431,&g_431,&g_137,&g_431},{&g_431,(void*)0,(void*)0,&g_431},{(void*)0,&g_431,(void*)0,(void*)0},{&g_431,&g_431,&g_137,&g_431},{&g_431,(void*)0,(void*)0,&g_431},{(void*)0,&g_431,(void*)0,(void*)0}},{{&g_431,&g_431,&g_137,&g_431},{&g_431,(void*)0,(void*)0,&g_431},{(void*)0,&g_431,(void*)0,(void*)0},{&g_431,&g_431,&g_137,&g_431},{&g_431,(void*)0,(void*)0,&g_431},{(void*)0,&g_431,(void*)0,(void*)0}},{{&g_431,&g_431,&g_137,&g_431},{&g_431,(void*)0,(void*)0,&g_431},{(void*)0,&g_431,(void*)0,(void*)0},{&g_431,&g_431,&g_137,&g_431},{&g_431,(void*)0,(void*)0,&g_431},{(void*)0,&g_431,(void*)0,(void*)0}},{{&g_431,&g_431,&g_137,&g_431},{&g_431,(void*)0,(void*)0,&g_431},{(void*)0,&g_431,(void*)0,(void*)0},{&g_431,&g_431,&g_137,&g_431},{&g_431,(void*)0,(void*)0,&g_431},{(void*)0,&g_431,(void*)0,(void*)0}},{{&g_431,&g_431,&g_137,&g_431},{&g_431,(void*)0,(void*)0,&g_431},{(void*)0,&g_431,(void*)0,(void*)0},{&g_431,&g_431,&g_137,&g_431},{&g_431,(void*)0,(void*)0,&g_431},{(void*)0,&g_431,(void*)0,(void*)0}},{{&g_431,&g_431,&g_137,&g_431},{&g_431,(void*)0,(void*)0,&g_431},{(void*)0,&g_431,(void*)0,(void*)0},{(void*)0,(void*)0,&g_431,(void*)0},{(void*)0,&g_137,&g_137,(void*)0},{&g_137,(void*)0,&g_137,&g_137}}}; + uint16_t l_560 = 0x2FB8L; + int i, j, k; + (*p_93) = l_96; + l_560 = (func_40(((safe_mul_func_int8_t_s_s((-3L), g_35)) , func_40(((((*l_103) = g_99) != (func_104(g_3) , (p_94 , (*g_129)))) || (((safe_sub_func_uint8_t_u_u((l_556 , (((((*l_558) = (+((void*)0 != g_56))) == g_305) <= 5UL) == g_441)), 253UL)) , g_135) && g_307[0][0]))))) , 0x08ECABE5L); + return g_137; +} + + +/* ------------------------------------------ */ +/* + * reads : g_100 g_118 g_122 g_129 g_137 g_122.f0 g_143 g_145 g_135 + * writes: g_100 g_35 g_135 g_137 g_143 g_145 + */ +static union U0 func_104(uint8_t p_105) +{ /* block id: 19 */ + int32_t l_139 = 0x2293C579L; + int32_t l_166 = 1L; + const int8_t *l_206[9] = {(void*)0,(void*)0,&g_207,(void*)0,(void*)0,&g_207,(void*)0,(void*)0,&g_207}; + int8_t l_268[5][8] = {{0x18L,8L,3L,8L,(-1L),8L,3L,8L},{0x82L,0x2BL,0xF8L,0x18L,0x12L,1L,0xFBL,3L},{8L,8L,0x4BL,0xFBL,0x82L,0x82L,0xFBL,0x4BL},{0xFBL,0xFBL,0xF8L,1L,(-1L),(-1L),3L,0x18L},{(-1L),(-1L),3L,0x18L,0L,0x4BL,0L,0x18L}}; + union U0 * const *l_292[7][1]; + int64_t l_310 = 0L; + uint32_t ** const l_315 = (void*)0; + int32_t l_459 = 1L; + int32_t l_460 = 0x16C7F9CEL; + int16_t l_461 = 0x13BCL; + int32_t l_462 = 3L; + int32_t l_463 = (-2L); + int32_t l_464 = 0L; + int32_t l_465 = 0x1B750790L; + int32_t l_466 = 1L; + int32_t l_467 = 0xF172AF90L; + int32_t l_468 = 0L; + const union U0 l_501 = {4294967295UL}; + uint64_t l_520 = 0UL; + int16_t l_530 = 0x69CEL; + union U0 l_553 = {1UL}; + int i, j; + for (i = 0; i < 7; i++) + { + for (j = 0; j < 1; j++) + l_292[i][j] = (void*)0; + } + for (g_100 = 0; (g_100 <= 0); g_100 += 1) + { /* block id: 22 */ + int32_t **l_117 = &g_56; + int8_t *l_119 = &g_100; + int16_t l_140 = 3L; + uint8_t l_141 = 6UL; + int16_t *l_142[2]; + int32_t *l_144 = &g_145; + int32_t l_183 = 1L; + int32_t l_237[3]; + int8_t ****l_301 = (void*)0; + uint32_t *l_317 = &g_118.f0; + uint32_t **l_316 = &l_317; + union U0 *l_349 = &g_118; + uint8_t l_400 = 0x8EL; + uint64_t * const l_436 = &g_417; + int32_t l_442 = 1L; + int32_t l_449 = 0xBD7A8749L; + uint16_t l_471 = 7UL; + uint32_t l_476 = 0xB15281E2L; + int i; + for (i = 0; i < 2; i++) + l_142[i] = (void*)0; + for (i = 0; i < 3; i++) + l_237[i] = 0x659DC613L; + (*l_144) |= (safe_rshift_func_uint16_t_u_s(1UL, (g_143 &= func_40((((((((safe_div_func_uint32_t_u_u(((func_110(func_112(l_117, &g_56, g_118, l_119)) , l_139) , (((4294967295UL <= l_140) && p_105) <= p_105)), g_122.f0)) < l_141) ^ g_122.f0) < p_105) , 4L) <= 0xED6FL) < 0x73E231492E8FA5C3LL))))); + for (g_135 = 0; (g_135 >= 0); g_135 -= 1) + { /* block id: 37 */ + uint64_t l_146[3]; + int32_t * const l_150 = &l_139; + uint32_t *l_175 = &g_118.f0; + uint16_t *l_196 = &g_122.f2; + uint64_t l_210 = 0x67575CCD8886A51ELL; + int32_t l_238[4] = {0xDFB7D6CBL,0xDFB7D6CBL,0xDFB7D6CBL,0xDFB7D6CBL}; + int64_t *l_273 = &g_214[1][5]; + int64_t *l_274[1][8][10] = {{{(void*)0,&g_267,&g_267,&g_267,&g_267,&g_267,&g_267,&g_267,(void*)0,(void*)0},{&g_267,&g_267,&g_267,&g_267,&g_267,&g_267,&g_267,&g_267,&g_267,&g_267},{&g_267,&g_267,&g_267,&g_267,&g_267,&g_267,&g_267,(void*)0,(void*)0,&g_267},{(void*)0,&g_267,&g_267,&g_267,&g_267,(void*)0,&g_267,&g_267,&g_267,(void*)0},{&g_267,&g_267,&g_267,&g_267,&g_267,&g_267,&g_267,&g_267,&g_267,&g_267},{&g_267,&g_267,&g_267,&g_267,&g_267,(void*)0,&g_267,(void*)0,&g_267,&g_267},{(void*)0,&g_267,(void*)0,&g_267,&g_267,&g_267,&g_267,&g_267,&g_267,(void*)0},{&g_267,&g_267,&g_267,&g_267,&g_267,&g_267,&g_267,&g_267,&g_267,&g_267}}}; + int32_t l_275 = 1L; + uint32_t l_287 = 0xB3BC167CL; + union U0 **l_295 = (void*)0; + int64_t l_373 = 1L; + int32_t **l_382[8][7]; + int32_t l_518 = 0xDEE36842L; + int16_t l_519 = 0L; + int8_t **l_526 = &g_130[1][1]; + int8_t *** const l_525 = &l_526; + int8_t *** const *l_524 = &l_525; + int8_t *** const **l_523 = &l_524; + int i, j, k; + for (i = 0; i < 3; i++) + l_146[i] = 0UL; + for (i = 0; i < 8; i++) + { + for (j = 0; j < 7; j++) + l_382[i][j] = (void*)0; + } + } + } + return l_553; +} + + +/* ------------------------------------------ */ +/* + * reads : g_137 + * writes: g_135 g_137 + */ +static union U0 func_110(int8_t ** p_111) +{ /* block id: 29 */ + uint8_t l_131 = 0xB2L; + int32_t *l_132 = (void*)0; + int32_t *l_133 = (void*)0; + int32_t *l_134 = &g_135; + int32_t *l_136 = &g_137; + union U0 l_138 = {4294967295UL}; + (*l_136) ^= ((*l_134) = l_131); + return l_138; +} + + +/* ------------------------------------------ */ +/* + * reads : g_122 g_129 + * writes: g_35 + */ +static int8_t ** func_112(int32_t ** p_113, int32_t ** p_114, union U0 p_115, int8_t * p_116) +{ /* block id: 23 */ + int32_t l_120 = 0xFB5D9459L; + uint16_t *l_121 = &g_35; + int8_t l_123 = (-1L); + int32_t **l_124 = (void*)0; + int32_t *l_126 = &g_3; + int32_t **l_125 = &l_126; + int32_t *l_128[6][5][1] = {{{&g_3},{&g_3},{&l_120},{&g_3},{&g_3}},{{&g_3},{&g_3},{&l_120},{&g_3},{&g_3}},{{&g_3},{&g_3},{&l_120},{&g_3},{&g_3}},{{&l_120},{&g_3},{&g_3},{&g_3},{&g_3}},{{&l_120},{&g_3},{&g_3},{&g_3},{&g_3}},{{&l_120},{&g_3},{&g_3},{&l_120},{&g_3}}}; + int32_t **l_127 = &l_128[2][4][0]; + int i, j, k; + l_120 = (((*l_121) = l_120) > (g_122 , l_123)); + (*l_127) = ((*l_125) = &l_120); + return g_129; +} + + + + +/* ---------------------------------------- */ +int main (int argc, char* argv[]) +{ + int i, j, k; + int print_hash_value = 0; + if (argc == 2 && strcmp(argv[1], "1") == 0) print_hash_value = 1; + platform_main_begin(); + crc32_gentab(); + func_1(); + transparent_crc(g_2, "g_2", print_hash_value); + transparent_crc(g_3, "g_3", print_hash_value); + transparent_crc(g_11, "g_11", print_hash_value); + transparent_crc(g_35, "g_35", print_hash_value); + transparent_crc(g_59, "g_59", print_hash_value); + transparent_crc(g_100, "g_100", print_hash_value); + transparent_crc(g_118.f0, "g_118.f0", print_hash_value); + transparent_crc(g_135, "g_135", print_hash_value); + transparent_crc(g_137, "g_137", print_hash_value); + transparent_crc(g_143, "g_143", print_hash_value); + transparent_crc(g_145, "g_145", print_hash_value); + transparent_crc(g_207, "g_207", print_hash_value); + for (i = 0; i < 3; i++) + { + for (j = 0; j < 6; j++) + { + transparent_crc(g_214[i][j], "g_214[i][j]", print_hash_value); + if (print_hash_value) printf("index = [%d][%d]\n", i, j); + + } + } + transparent_crc(g_267, "g_267", print_hash_value); + transparent_crc(g_305, "g_305", print_hash_value); + for (i = 0; i < 10; i++) + { + for (j = 0; j < 4; j++) + { + transparent_crc(g_307[i][j], "g_307[i][j]", print_hash_value); + if (print_hash_value) printf("index = [%d][%d]\n", i, j); + + } + } + transparent_crc(g_364, "g_364", print_hash_value); + transparent_crc(g_417, "g_417", print_hash_value); + transparent_crc(g_431, "g_431", print_hash_value); + transparent_crc(g_441, "g_441", print_hash_value); + transparent_crc(g_589.f0, "g_589.f0", print_hash_value); + transparent_crc(g_590.f0, "g_590.f0", print_hash_value); + for (i = 0; i < 2; i++) + { + transparent_crc(g_852[i].f0, "g_852[i].f0", print_hash_value); + if (print_hash_value) printf("index = [%d]\n", i); + + } + transparent_crc(g_878, "g_878", print_hash_value); + transparent_crc(g_933, "g_933", print_hash_value); + transparent_crc(g_935, "g_935", print_hash_value); + for (i = 0; i < 10; i++) + { + for (j = 0; j < 4; j++) + { + for (k = 0; k < 6; k++) + { + transparent_crc(g_1009[i][j][k], "g_1009[i][j][k]", print_hash_value); + if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k); + + } + } + } + for (i = 0; i < 1; i++) + { + transparent_crc(g_1056[i], "g_1056[i]", print_hash_value); + if (print_hash_value) printf("index = [%d]\n", i); + + } + transparent_crc(g_1137, "g_1137", print_hash_value); + transparent_crc(g_1214, "g_1214", print_hash_value); + transparent_crc(g_1331, "g_1331", print_hash_value); + transparent_crc(g_1332, "g_1332", print_hash_value); + transparent_crc(g_1333, "g_1333", print_hash_value); + for (i = 0; i < 4; i++) + { + for (j = 0; j < 9; j++) + { + for (k = 0; k < 3; k++) + { + transparent_crc(g_1334[i][j][k], "g_1334[i][j][k]", print_hash_value); + if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k); + + } + } + } + transparent_crc(g_1335, "g_1335", print_hash_value); + transparent_crc(g_1336, "g_1336", print_hash_value); + transparent_crc(g_1337, "g_1337", print_hash_value); + transparent_crc(g_1338, "g_1338", print_hash_value); + transparent_crc(g_1339, "g_1339", print_hash_value); + transparent_crc(g_1374, "g_1374", print_hash_value); + transparent_crc(g_1433, "g_1433", print_hash_value); + transparent_crc(g_1481, "g_1481", print_hash_value); + transparent_crc(g_1658, "g_1658", print_hash_value); + transparent_crc(g_1665.f0, "g_1665.f0", print_hash_value); + for (i = 0; i < 4; i++) + { + transparent_crc(g_1689[i], "g_1689[i]", print_hash_value); + if (print_hash_value) printf("index = [%d]\n", i); + + } + transparent_crc(g_1978, "g_1978", print_hash_value); + transparent_crc(g_1999, "g_1999", print_hash_value); + transparent_crc(g_2095, "g_2095", print_hash_value); + transparent_crc(g_2150, "g_2150", print_hash_value); + transparent_crc(g_2157.f0, "g_2157.f0", print_hash_value); + transparent_crc(g_2288, "g_2288", print_hash_value); + transparent_crc(g_2337.f0, "g_2337.f0", print_hash_value); + transparent_crc(g_2437.f0, "g_2437.f0", print_hash_value); + transparent_crc(g_2438.f0, "g_2438.f0", print_hash_value); + transparent_crc(g_2439.f0, "g_2439.f0", print_hash_value); + transparent_crc(g_2440.f0, "g_2440.f0", print_hash_value); + transparent_crc(g_2441.f0, "g_2441.f0", print_hash_value); + transparent_crc(g_2442.f0, "g_2442.f0", print_hash_value); + transparent_crc(g_2443.f0, "g_2443.f0", print_hash_value); + transparent_crc(g_2545, "g_2545", print_hash_value); + transparent_crc(g_2635, "g_2635", print_hash_value); + transparent_crc(g_2660, "g_2660", print_hash_value); + transparent_crc(g_2714, "g_2714", print_hash_value); + transparent_crc(g_2718, "g_2718", print_hash_value); + for (i = 0; i < 9; i++) + { + for (j = 0; j < 1; j++) + { + transparent_crc(g_2774[i][j], "g_2774[i][j]", print_hash_value); + if (print_hash_value) printf("index = [%d][%d]\n", i, j); + + } + } + transparent_crc(g_2781, "g_2781", print_hash_value); + for (i = 0; i < 7; i++) + { + transparent_crc(g_2808[i], "g_2808[i]", print_hash_value); + if (print_hash_value) printf("index = [%d]\n", i); + + } + platform_main_end(crc32_context ^ 0xFFFFFFFFUL, print_hash_value); + return 0; +} + +/************************ statistics ************************* +XXX max struct depth: 0 +breakdown: + depth: 0, occurrence: 700 +XXX total union variables: 36 + +XXX non-zero bitfields defined in structs: 0 +XXX zero bitfields defined in structs: 0 +XXX const bitfields defined in structs: 0 +XXX volatile bitfields defined in structs: 0 +XXX structs with bitfields in the program: 0 +breakdown: +XXX full-bitfields structs in the program: 0 +breakdown: +XXX times a bitfields struct's address is taken: 0 +XXX times a bitfields struct on LHS: 0 +XXX times a bitfields struct on RHS: 0 +XXX times a single bitfield on LHS: 0 +XXX times a single bitfield on RHS: 0 + +XXX max expression depth: 45 +breakdown: + depth: 1, occurrence: 179 + depth: 2, occurrence: 41 + depth: 3, occurrence: 3 + depth: 4, occurrence: 2 + depth: 6, occurrence: 1 + depth: 7, occurrence: 1 + depth: 8, occurrence: 2 + depth: 14, occurrence: 2 + depth: 16, occurrence: 3 + depth: 17, occurrence: 1 + depth: 19, occurrence: 4 + depth: 20, occurrence: 3 + depth: 21, occurrence: 6 + depth: 22, occurrence: 2 + depth: 23, occurrence: 3 + depth: 24, occurrence: 1 + depth: 25, occurrence: 1 + depth: 26, occurrence: 3 + depth: 27, occurrence: 1 + depth: 28, occurrence: 3 + depth: 29, occurrence: 2 + depth: 30, occurrence: 3 + depth: 31, occurrence: 2 + depth: 32, occurrence: 1 + depth: 33, occurrence: 3 + depth: 35, occurrence: 1 + depth: 36, occurrence: 1 + depth: 39, occurrence: 2 + depth: 41, occurrence: 1 + depth: 45, occurrence: 1 + +XXX total number of pointers: 571 + +XXX times a variable address is taken: 1339 +XXX times a pointer is dereferenced on RHS: 429 +breakdown: + depth: 1, occurrence: 289 + depth: 2, occurrence: 111 + depth: 3, occurrence: 20 + depth: 4, occurrence: 9 +XXX times a pointer is dereferenced on LHS: 328 +breakdown: + depth: 1, occurrence: 282 + depth: 2, occurrence: 37 + depth: 3, occurrence: 6 + depth: 4, occurrence: 3 +XXX times a pointer is compared with null: 53 +XXX times a pointer is compared with address of another variable: 16 +XXX times a pointer is compared with another pointer: 20 +XXX times a pointer is qualified to be dereferenced: 8477 + +XXX max dereference level: 5 +breakdown: + level: 0, occurrence: 0 + level: 1, occurrence: 1353 + level: 2, occurrence: 352 + level: 3, occurrence: 192 + level: 4, occurrence: 39 + level: 5, occurrence: 22 +XXX number of pointers point to pointers: 311 +XXX number of pointers point to scalars: 243 +XXX number of pointers point to structs: 0 +XXX percent of pointers has null in alias set: 34.2 +XXX average alias set size: 1.46 + +XXX times a non-volatile is read: 2565 +XXX times a non-volatile is write: 1040 +XXX times a volatile is read: 46 +XXX times read thru a pointer: 34 +XXX times a volatile is write: 11 +XXX times written thru a pointer: 7 +XXX times a volatile is available for access: 258 +XXX percentage of non-volatile access: 98.4 + +XXX forward jumps: 0 +XXX backward jumps: 9 + +XXX stmts: 187 +XXX max block depth: 5 +breakdown: + depth: 0, occurrence: 29 + depth: 1, occurrence: 24 + depth: 2, occurrence: 39 + depth: 3, occurrence: 35 + depth: 4, occurrence: 27 + depth: 5, occurrence: 33 + +XXX percentage a fresh-made variable is used: 15.4 +XXX percentage an existing variable is used: 84.6 +XXX total OOB instances added: 0 +********************* end of statistics **********************/ + diff --git a/tests/csmith/f0.clang.txt b/tests/csmith/f0.clang.txt new file mode 100644 index 00000000..42be1da5 --- /dev/null +++ b/tests/csmith/f0.clang.txt @@ -0,0 +1,917 @@ +...checksum after hashing g_2 : EC1ACFFE +...checksum after hashing g_3 : BE993D25 +...checksum after hashing g_11 : FA6335B2 +...checksum after hashing g_35 : 874EB14E +...checksum after hashing g_59 : D82E044D +...checksum after hashing g_100 : E3B07CED +...checksum after hashing g_118.f0 : DD930212 +...checksum after hashing g_135 : 4D0CE283 +...checksum after hashing g_137 : A9B46EB0 +...checksum after hashing g_143 : CDAE3661 +...checksum after hashing g_145 : 77BEA70E +...checksum after hashing g_207 : 981133E6 +...checksum after hashing g_214[i][j] : 5C40F131 +index = [0][0] +...checksum after hashing g_214[i][j] : 42CCBE16 +index = [0][1] +...checksum after hashing g_214[i][j] : 69AC0F2C +index = [0][2] +...checksum after hashing g_214[i][j] : 11453864 +index = [0][3] +...checksum after hashing g_214[i][j] : 2A13B602 +index = [0][4] +...checksum after hashing g_214[i][j] : 34AACE49 +index = [0][5] +...checksum after hashing g_214[i][j] : A1FDC745 +index = [1][0] +...checksum after hashing g_214[i][j] : 25040E9A +index = [1][1] +...checksum after hashing g_214[i][j] : CC4BF2D2 +index = [1][2] +...checksum after hashing g_214[i][j] : DFE77AF8 +index = [1][3] +...checksum after hashing g_214[i][j] : 45369C34 +index = [1][4] +...checksum after hashing g_214[i][j] : DD18B69A +index = [1][5] +...checksum after hashing g_214[i][j] : 842E3F26 +index = [2][0] +...checksum after hashing g_214[i][j] : FFD91AE5 +index = [2][1] +...checksum after hashing g_214[i][j] : D68FBDF2 +index = [2][2] +...checksum after hashing g_214[i][j] : A697EA9E +index = [2][3] +...checksum after hashing g_214[i][j] : 8973CBDD +index = [2][4] +...checksum after hashing g_214[i][j] : D16AFE0D +index = [2][5] +...checksum after hashing g_267 : AE792228 +...checksum after hashing g_305 : 3803F35F +...checksum after hashing g_307[i][j] : 67DD9F30 +index = [0][0] +...checksum after hashing g_307[i][j] : B0772EF3 +index = [0][1] +...checksum after hashing g_307[i][j] : 410EBBF2 +index = [0][2] +...checksum after hashing g_307[i][j] : 53DF8C26 +index = [0][3] +...checksum after hashing g_307[i][j] : 45FC2F41 +index = [1][0] +...checksum after hashing g_307[i][j] : B0BA9171 +index = [1][1] +...checksum after hashing g_307[i][j] : 11A94043 +index = [1][2] +...checksum after hashing g_307[i][j] : 13F0DAA1 +index = [1][3] +...checksum after hashing g_307[i][j] : F22A8F9F +index = [2][0] +...checksum after hashing g_307[i][j] : B591D9E6 +index = [2][1] +...checksum after hashing g_307[i][j] : DC71F705 +index = [2][2] +...checksum after hashing g_307[i][j] : FB795223 +index = [2][3] +...checksum after hashing g_307[i][j] : 4E41B442 +index = [3][0] +...checksum after hashing g_307[i][j] : 35CD4E35 +index = [3][1] +...checksum after hashing g_307[i][j] : B426B656 +index = [3][2] +...checksum after hashing g_307[i][j] : 4DD617D3 +index = [3][3] +...checksum after hashing g_307[i][j] : E74370B8 +index = [4][0] +...checksum after hashing g_307[i][j] : 9F61A15D +index = [4][1] +...checksum after hashing g_307[i][j] : 2C7BC631 +index = [4][2] +...checksum after hashing g_307[i][j] : 2AF619A2 +index = [4][3] +...checksum after hashing g_307[i][j] : FB1C2BBA +index = [5][0] +...checksum after hashing g_307[i][j] : A45EDBCC +index = [5][1] +...checksum after hashing g_307[i][j] : 52CC8A7F +index = [5][2] +...checksum after hashing g_307[i][j] : D467AB13 +index = [5][3] +...checksum after hashing g_307[i][j] : BB3E884E +index = [6][0] +...checksum after hashing g_307[i][j] : 7701F465 +index = [6][1] +...checksum after hashing g_307[i][j] : 21389FA2 +index = [6][2] +...checksum after hashing g_307[i][j] : 7B5B717C +index = [6][3] +...checksum after hashing g_307[i][j] : 3C89A9C3 +index = [7][0] +...checksum after hashing g_307[i][j] : D2D80633 +index = [7][1] +...checksum after hashing g_307[i][j] : E80CB6 +index = [7][2] +...checksum after hashing g_307[i][j] : BE54B879 +index = [7][3] +...checksum after hashing g_307[i][j] : 31E5A81F +index = [8][0] +...checksum after hashing g_307[i][j] : 952CB1A5 +index = [8][1] +...checksum after hashing g_307[i][j] : 9E5D5413 +index = [8][2] +...checksum after hashing g_307[i][j] : 68F2EDF6 +index = [8][3] +...checksum after hashing g_307[i][j] : 3C79E49 +index = [9][0] +...checksum after hashing g_307[i][j] : 6BC440B6 +index = [9][1] +...checksum after hashing g_307[i][j] : 99816F50 +index = [9][2] +...checksum after hashing g_307[i][j] : BF1959FA +index = [9][3] +...checksum after hashing g_364 : 9157978F +...checksum after hashing g_417 : 1D80F734 +...checksum after hashing g_431 : CF4D8DD5 +...checksum after hashing g_441 : 1A9D4A9B +...checksum after hashing g_589.f0 : BA74DEC0 +...checksum after hashing g_590.f0 : A6E1DA31 +...checksum after hashing g_852[i].f0 : CD23720E +index = [0] +...checksum after hashing g_852[i].f0 : 57485735 +index = [1] +...checksum after hashing g_878 : B7DCD169 +...checksum after hashing g_933 : 98D85B89 +...checksum after hashing g_935 : 25873601 +...checksum after hashing g_1009[i][j][k] : 43E4CAB9 +index = [0][0][0] +...checksum after hashing g_1009[i][j][k] : 9ADAA9B3 +index = [0][0][1] +...checksum after hashing g_1009[i][j][k] : 79C3DDA7 +index = [0][0][2] +...checksum after hashing g_1009[i][j][k] : 529D774C +index = [0][0][3] +...checksum after hashing g_1009[i][j][k] : FABF7E6A +index = [0][0][4] +...checksum after hashing g_1009[i][j][k] : DFC38FB8 +index = [0][0][5] +...checksum after hashing g_1009[i][j][k] : 4E1C0C6C +index = [0][1][0] +...checksum after hashing g_1009[i][j][k] : 26C68F7 +index = [0][1][1] +...checksum after hashing g_1009[i][j][k] : 995E102F +index = [0][1][2] +...checksum after hashing g_1009[i][j][k] : 66BDB133 +index = [0][1][3] +...checksum after hashing g_1009[i][j][k] : 730F4C97 +index = [0][1][4] +...checksum after hashing g_1009[i][j][k] : B2759FD7 +index = [0][1][5] +...checksum after hashing g_1009[i][j][k] : 419261BF +index = [0][2][0] +...checksum after hashing g_1009[i][j][k] : BEA29A1C +index = [0][2][1] +...checksum after hashing g_1009[i][j][k] : 111EF448 +index = [0][2][2] +...checksum after hashing g_1009[i][j][k] : DF4A89F4 +index = [0][2][3] +...checksum after hashing g_1009[i][j][k] : 6A41ABE4 +index = [0][2][4] +...checksum after hashing g_1009[i][j][k] : FC38C5DD +index = [0][2][5] +...checksum after hashing g_1009[i][j][k] : CF58348A +index = [0][3][0] +...checksum after hashing g_1009[i][j][k] : 388D3CCE +index = [0][3][1] +...checksum after hashing g_1009[i][j][k] : E2CFFDDD +index = [0][3][2] +...checksum after hashing g_1009[i][j][k] : 66AA84A0 +index = [0][3][3] +...checksum after hashing g_1009[i][j][k] : 34501DA2 +index = [0][3][4] +...checksum after hashing g_1009[i][j][k] : 671198F1 +index = [0][3][5] +...checksum after hashing g_1009[i][j][k] : A5F6891B +index = [1][0][0] +...checksum after hashing g_1009[i][j][k] : EEDBB749 +index = [1][0][1] +...checksum after hashing g_1009[i][j][k] : E787A71C +index = [1][0][2] +...checksum after hashing g_1009[i][j][k] : E1066594 +index = [1][0][3] +...checksum after hashing g_1009[i][j][k] : 60F64784 +index = [1][0][4] +...checksum after hashing g_1009[i][j][k] : 424D93C5 +index = [1][0][5] +...checksum after hashing g_1009[i][j][k] : 18B1E800 +index = [1][1][0] +...checksum after hashing g_1009[i][j][k] : 3BD80B2D +index = [1][1][1] +...checksum after hashing g_1009[i][j][k] : 652AE5A5 +index = [1][1][2] +...checksum after hashing g_1009[i][j][k] : 8F77CFD4 +index = [1][1][3] +...checksum after hashing g_1009[i][j][k] : D1220914 +index = [1][1][4] +...checksum after hashing g_1009[i][j][k] : 48021270 +index = [1][1][5] +...checksum after hashing g_1009[i][j][k] : D0D27103 +index = [1][2][0] +...checksum after hashing g_1009[i][j][k] : 77B1C168 +index = [1][2][1] +...checksum after hashing g_1009[i][j][k] : DEC20233 +index = [1][2][2] +...checksum after hashing g_1009[i][j][k] : AD872EC8 +index = [1][2][3] +...checksum after hashing g_1009[i][j][k] : 144BBEF3 +index = [1][2][4] +...checksum after hashing g_1009[i][j][k] : BF3832E2 +index = [1][2][5] +...checksum after hashing g_1009[i][j][k] : CADE5239 +index = [1][3][0] +...checksum after hashing g_1009[i][j][k] : FEE62815 +index = [1][3][1] +...checksum after hashing g_1009[i][j][k] : 248AC4B1 +index = [1][3][2] +...checksum after hashing g_1009[i][j][k] : EC0C2C +index = [1][3][3] +...checksum after hashing g_1009[i][j][k] : 469618CF +index = [1][3][4] +...checksum after hashing g_1009[i][j][k] : 3A644C3A +index = [1][3][5] +...checksum after hashing g_1009[i][j][k] : 46DA6224 +index = [2][0][0] +...checksum after hashing g_1009[i][j][k] : 4B6A7D9B +index = [2][0][1] +...checksum after hashing g_1009[i][j][k] : A846CF97 +index = [2][0][2] +...checksum after hashing g_1009[i][j][k] : 5719FC13 +index = [2][0][3] +...checksum after hashing g_1009[i][j][k] : B169F8B6 +index = [2][0][4] +...checksum after hashing g_1009[i][j][k] : ECDC0B5F +index = [2][0][5] +...checksum after hashing g_1009[i][j][k] : 63FB9C73 +index = [2][1][0] +...checksum after hashing g_1009[i][j][k] : F0CF7B84 +index = [2][1][1] +...checksum after hashing g_1009[i][j][k] : 1B050C03 +index = [2][1][2] +...checksum after hashing g_1009[i][j][k] : 40BB84EC +index = [2][1][3] +...checksum after hashing g_1009[i][j][k] : 29509AC7 +index = [2][1][4] +...checksum after hashing g_1009[i][j][k] : A03B3726 +index = [2][1][5] +...checksum after hashing g_1009[i][j][k] : E5CF4702 +index = [2][2][0] +...checksum after hashing g_1009[i][j][k] : A621772D +index = [2][2][1] +...checksum after hashing g_1009[i][j][k] : A974B638 +index = [2][2][2] +...checksum after hashing g_1009[i][j][k] : 23931AC4 +index = [2][2][3] +...checksum after hashing g_1009[i][j][k] : 6C603FDE +index = [2][2][4] +...checksum after hashing g_1009[i][j][k] : D22D5562 +index = [2][2][5] +...checksum after hashing g_1009[i][j][k] : 2AC84F0 +index = [2][3][0] +...checksum after hashing g_1009[i][j][k] : 1DBDA790 +index = [2][3][1] +...checksum after hashing g_1009[i][j][k] : 4832902F +index = [2][3][2] +...checksum after hashing g_1009[i][j][k] : A0C66DB3 +index = [2][3][3] +...checksum after hashing g_1009[i][j][k] : D4D10DE1 +index = [2][3][4] +...checksum after hashing g_1009[i][j][k] : 5AE5C193 +index = [2][3][5] +...checksum after hashing g_1009[i][j][k] : 9A6DA51F +index = [3][0][0] +...checksum after hashing g_1009[i][j][k] : 365C238C +index = [3][0][1] +...checksum after hashing g_1009[i][j][k] : 822EE733 +index = [3][0][2] +...checksum after hashing g_1009[i][j][k] : EA9AD80C +index = [3][0][3] +...checksum after hashing g_1009[i][j][k] : 5DAB369C +index = [3][0][4] +...checksum after hashing g_1009[i][j][k] : 4C755F2B +index = [3][0][5] +...checksum after hashing g_1009[i][j][k] : 1EE51193 +index = [3][1][0] +...checksum after hashing g_1009[i][j][k] : D43D56B7 +index = [3][1][1] +...checksum after hashing g_1009[i][j][k] : 75651FD4 +index = [3][1][2] +...checksum after hashing g_1009[i][j][k] : D342BA60 +index = [3][1][3] +...checksum after hashing g_1009[i][j][k] : 71A3C14C +index = [3][1][4] +...checksum after hashing g_1009[i][j][k] : 9E3D7A1D +index = [3][1][5] +...checksum after hashing g_1009[i][j][k] : 371DF8C6 +index = [3][2][0] +...checksum after hashing g_1009[i][j][k] : EE99902A +index = [3][2][1] +...checksum after hashing g_1009[i][j][k] : F169AC31 +index = [3][2][2] +...checksum after hashing g_1009[i][j][k] : C87CD87E +index = [3][2][3] +...checksum after hashing g_1009[i][j][k] : CA1A7E7B +index = [3][2][4] +...checksum after hashing g_1009[i][j][k] : 872286D6 +index = [3][2][5] +...checksum after hashing g_1009[i][j][k] : CB9EB71B +index = [3][3][0] +...checksum after hashing g_1009[i][j][k] : ACF56115 +index = [3][3][1] +...checksum after hashing g_1009[i][j][k] : 32881885 +index = [3][3][2] +...checksum after hashing g_1009[i][j][k] : 2A59A0EE +index = [3][3][3] +...checksum after hashing g_1009[i][j][k] : BAA6FB46 +index = [3][3][4] +...checksum after hashing g_1009[i][j][k] : 317B9602 +index = [3][3][5] +...checksum after hashing g_1009[i][j][k] : 7DF0F614 +index = [4][0][0] +...checksum after hashing g_1009[i][j][k] : 8EADD23C +index = [4][0][1] +...checksum after hashing g_1009[i][j][k] : A402890E +index = [4][0][2] +...checksum after hashing g_1009[i][j][k] : 1134B6F1 +index = [4][0][3] +...checksum after hashing g_1009[i][j][k] : 63500678 +index = [4][0][4] +...checksum after hashing g_1009[i][j][k] : AB5B651C +index = [4][0][5] +...checksum after hashing g_1009[i][j][k] : 427B822A +index = [4][1][0] +...checksum after hashing g_1009[i][j][k] : E5B6E0D1 +index = [4][1][1] +...checksum after hashing g_1009[i][j][k] : 3E2AF2F4 +index = [4][1][2] +...checksum after hashing g_1009[i][j][k] : 996ECE00 +index = [4][1][3] +...checksum after hashing g_1009[i][j][k] : DB42106A +index = [4][1][4] +...checksum after hashing g_1009[i][j][k] : 41DA5F34 +index = [4][1][5] +...checksum after hashing g_1009[i][j][k] : D37319D6 +index = [4][2][0] +...checksum after hashing g_1009[i][j][k] : A0884FDF +index = [4][2][1] +...checksum after hashing g_1009[i][j][k] : 652B97CD +index = [4][2][2] +...checksum after hashing g_1009[i][j][k] : 262A8423 +index = [4][2][3] +...checksum after hashing g_1009[i][j][k] : 4A9E8857 +index = [4][2][4] +...checksum after hashing g_1009[i][j][k] : 1A921870 +index = [4][2][5] +...checksum after hashing g_1009[i][j][k] : CCF6A509 +index = [4][3][0] +...checksum after hashing g_1009[i][j][k] : 49AC9AF +index = [4][3][1] +...checksum after hashing g_1009[i][j][k] : B2CA2F22 +index = [4][3][2] +...checksum after hashing g_1009[i][j][k] : 1463CE52 +index = [4][3][3] +...checksum after hashing g_1009[i][j][k] : 39A9832C +index = [4][3][4] +...checksum after hashing g_1009[i][j][k] : F94E269 +index = [4][3][5] +...checksum after hashing g_1009[i][j][k] : 3A1E1043 +index = [5][0][0] +...checksum after hashing g_1009[i][j][k] : 5CE84457 +index = [5][0][1] +...checksum after hashing g_1009[i][j][k] : 390C832F +index = [5][0][2] +...checksum after hashing g_1009[i][j][k] : 6F994B14 +index = [5][0][3] +...checksum after hashing g_1009[i][j][k] : 4EA92AFA +index = [5][0][4] +...checksum after hashing g_1009[i][j][k] : 1711B9BF +index = [5][0][5] +...checksum after hashing g_1009[i][j][k] : 6BD62535 +index = [5][1][0] +...checksum after hashing g_1009[i][j][k] : 57EF2341 +index = [5][1][1] +...checksum after hashing g_1009[i][j][k] : FCD2A430 +index = [5][1][2] +...checksum after hashing g_1009[i][j][k] : 81397B11 +index = [5][1][3] +...checksum after hashing g_1009[i][j][k] : 3A2A0BC2 +index = [5][1][4] +...checksum after hashing g_1009[i][j][k] : ACB80861 +index = [5][1][5] +...checksum after hashing g_1009[i][j][k] : 9C2D2A4 +index = [5][2][0] +...checksum after hashing g_1009[i][j][k] : 88CC5735 +index = [5][2][1] +...checksum after hashing g_1009[i][j][k] : 1779351A +index = [5][2][2] +...checksum after hashing g_1009[i][j][k] : 32572A2B +index = [5][2][3] +...checksum after hashing g_1009[i][j][k] : CE1CBA9A +index = [5][2][4] +...checksum after hashing g_1009[i][j][k] : 7D56F3E4 +index = [5][2][5] +...checksum after hashing g_1009[i][j][k] : C7F01A10 +index = [5][3][0] +...checksum after hashing g_1009[i][j][k] : DC700E74 +index = [5][3][1] +...checksum after hashing g_1009[i][j][k] : DE6AAA3D +index = [5][3][2] +...checksum after hashing g_1009[i][j][k] : A91E5669 +index = [5][3][3] +...checksum after hashing g_1009[i][j][k] : 1A156AAE +index = [5][3][4] +...checksum after hashing g_1009[i][j][k] : C4882B13 +index = [5][3][5] +...checksum after hashing g_1009[i][j][k] : A710BF +index = [6][0][0] +...checksum after hashing g_1009[i][j][k] : 2278A7C8 +index = [6][0][1] +...checksum after hashing g_1009[i][j][k] : ACA5D80C +index = [6][0][2] +...checksum after hashing g_1009[i][j][k] : B9145569 +index = [6][0][3] +...checksum after hashing g_1009[i][j][k] : 9251889F +index = [6][0][4] +...checksum after hashing g_1009[i][j][k] : 6DFC2940 +index = [6][0][5] +...checksum after hashing g_1009[i][j][k] : A1154783 +index = [6][1][0] +...checksum after hashing g_1009[i][j][k] : A32C3D53 +index = [6][1][1] +...checksum after hashing g_1009[i][j][k] : DF65EF72 +index = [6][1][2] +...checksum after hashing g_1009[i][j][k] : 83A64793 +index = [6][1][3] +...checksum after hashing g_1009[i][j][k] : B0281FA3 +index = [6][1][4] +...checksum after hashing g_1009[i][j][k] : 9F3310B8 +index = [6][1][5] +...checksum after hashing g_1009[i][j][k] : FD1C4A45 +index = [6][2][0] +...checksum after hashing g_1009[i][j][k] : 94E9230D +index = [6][2][1] +...checksum after hashing g_1009[i][j][k] : A1C26EF5 +index = [6][2][2] +...checksum after hashing g_1009[i][j][k] : A6FFBEA9 +index = [6][2][3] +...checksum after hashing g_1009[i][j][k] : 7763D657 +index = [6][2][4] +...checksum after hashing g_1009[i][j][k] : FBEA527C +index = [6][2][5] +...checksum after hashing g_1009[i][j][k] : A2ACFA80 +index = [6][3][0] +...checksum after hashing g_1009[i][j][k] : 26536E91 +index = [6][3][1] +...checksum after hashing g_1009[i][j][k] : 2D67B095 +index = [6][3][2] +...checksum after hashing g_1009[i][j][k] : E97FE0B +index = [6][3][3] +...checksum after hashing g_1009[i][j][k] : 72756F7 +index = [6][3][4] +...checksum after hashing g_1009[i][j][k] : CC7DBBFF +index = [6][3][5] +...checksum after hashing g_1009[i][j][k] : 54C77798 +index = [7][0][0] +...checksum after hashing g_1009[i][j][k] : 71F6D98F +index = [7][0][1] +...checksum after hashing g_1009[i][j][k] : 39A81D55 +index = [7][0][2] +...checksum after hashing g_1009[i][j][k] : 6F7398D5 +index = [7][0][3] +...checksum after hashing g_1009[i][j][k] : CFA9AE31 +index = [7][0][4] +...checksum after hashing g_1009[i][j][k] : 47144056 +index = [7][0][5] +...checksum after hashing g_1009[i][j][k] : C0F49485 +index = [7][1][0] +...checksum after hashing g_1009[i][j][k] : B615F9FA +index = [7][1][1] +...checksum after hashing g_1009[i][j][k] : 884B83B2 +index = [7][1][2] +...checksum after hashing g_1009[i][j][k] : 8595A4E3 +index = [7][1][3] +...checksum after hashing g_1009[i][j][k] : 41B11C0C +index = [7][1][4] +...checksum after hashing g_1009[i][j][k] : 6E1683D1 +index = [7][1][5] +...checksum after hashing g_1009[i][j][k] : CEAD701C +index = [7][2][0] +...checksum after hashing g_1009[i][j][k] : 51F97FAC +index = [7][2][1] +...checksum after hashing g_1009[i][j][k] : 31442D38 +index = [7][2][2] +...checksum after hashing g_1009[i][j][k] : 21955A67 +index = [7][2][3] +...checksum after hashing g_1009[i][j][k] : 3DDE0DA0 +index = [7][2][4] +...checksum after hashing g_1009[i][j][k] : DF3D584D +index = [7][2][5] +...checksum after hashing g_1009[i][j][k] : C0BC1FA8 +index = [7][3][0] +...checksum after hashing g_1009[i][j][k] : BD7CB874 +index = [7][3][1] +...checksum after hashing g_1009[i][j][k] : 74AD0514 +index = [7][3][2] +...checksum after hashing g_1009[i][j][k] : AA918BBE +index = [7][3][3] +...checksum after hashing g_1009[i][j][k] : C48E7BB +index = [7][3][4] +...checksum after hashing g_1009[i][j][k] : B0FAADCE +index = [7][3][5] +...checksum after hashing g_1009[i][j][k] : 3CC1467F +index = [8][0][0] +...checksum after hashing g_1009[i][j][k] : 3D91C856 +index = [8][0][1] +...checksum after hashing g_1009[i][j][k] : 69A16DB2 +index = [8][0][2] +...checksum after hashing g_1009[i][j][k] : E98FB837 +index = [8][0][3] +...checksum after hashing g_1009[i][j][k] : FF3887F7 +index = [8][0][4] +...checksum after hashing g_1009[i][j][k] : 51F5FA82 +index = [8][0][5] +...checksum after hashing g_1009[i][j][k] : DF5557BA +index = [8][1][0] +...checksum after hashing g_1009[i][j][k] : 17CABD09 +index = [8][1][1] +...checksum after hashing g_1009[i][j][k] : ED01D0B4 +index = [8][1][2] +...checksum after hashing g_1009[i][j][k] : AED68F79 +index = [8][1][3] +...checksum after hashing g_1009[i][j][k] : 6FB91192 +index = [8][1][4] +...checksum after hashing g_1009[i][j][k] : 3A7919 +index = [8][1][5] +...checksum after hashing g_1009[i][j][k] : DAC7445A +index = [8][2][0] +...checksum after hashing g_1009[i][j][k] : F56329CB +index = [8][2][1] +...checksum after hashing g_1009[i][j][k] : A2021648 +index = [8][2][2] +...checksum after hashing g_1009[i][j][k] : 949BCC5C +index = [8][2][3] +...checksum after hashing g_1009[i][j][k] : 8B4CE799 +index = [8][2][4] +...checksum after hashing g_1009[i][j][k] : 83C30D36 +index = [8][2][5] +...checksum after hashing g_1009[i][j][k] : 88E8EC83 +index = [8][3][0] +...checksum after hashing g_1009[i][j][k] : 4FF7FDEB +index = [8][3][1] +...checksum after hashing g_1009[i][j][k] : 83B67BD9 +index = [8][3][2] +...checksum after hashing g_1009[i][j][k] : A8CA0CA5 +index = [8][3][3] +...checksum after hashing g_1009[i][j][k] : 1E8E1BF8 +index = [8][3][4] +...checksum after hashing g_1009[i][j][k] : 69A70126 +index = [8][3][5] +...checksum after hashing g_1009[i][j][k] : 6C778B66 +index = [9][0][0] +...checksum after hashing g_1009[i][j][k] : 1DD7C1E0 +index = [9][0][1] +...checksum after hashing g_1009[i][j][k] : A56B545C +index = [9][0][2] +...checksum after hashing g_1009[i][j][k] : D47D5EF4 +index = [9][0][3] +...checksum after hashing g_1009[i][j][k] : 8A53E3D +index = [9][0][4] +...checksum after hashing g_1009[i][j][k] : FA178C56 +index = [9][0][5] +...checksum after hashing g_1009[i][j][k] : 8EC1DE43 +index = [9][1][0] +...checksum after hashing g_1009[i][j][k] : A54EAFF9 +index = [9][1][1] +...checksum after hashing g_1009[i][j][k] : 3D3A068F +index = [9][1][2] +...checksum after hashing g_1009[i][j][k] : DE3C8B51 +index = [9][1][3] +...checksum after hashing g_1009[i][j][k] : 87BFD801 +index = [9][1][4] +...checksum after hashing g_1009[i][j][k] : 911E5193 +index = [9][1][5] +...checksum after hashing g_1009[i][j][k] : 2048AFE5 +index = [9][2][0] +...checksum after hashing g_1009[i][j][k] : 1670F1DC +index = [9][2][1] +...checksum after hashing g_1009[i][j][k] : ACA3A77B +index = [9][2][2] +...checksum after hashing g_1009[i][j][k] : D3F88E3F +index = [9][2][3] +...checksum after hashing g_1009[i][j][k] : 1AD89174 +index = [9][2][4] +...checksum after hashing g_1009[i][j][k] : F9297729 +index = [9][2][5] +...checksum after hashing g_1009[i][j][k] : 7B2E62B5 +index = [9][3][0] +...checksum after hashing g_1009[i][j][k] : D0F3E104 +index = [9][3][1] +...checksum after hashing g_1009[i][j][k] : B1FF4879 +index = [9][3][2] +...checksum after hashing g_1009[i][j][k] : C63F4A2C +index = [9][3][3] +...checksum after hashing g_1009[i][j][k] : 74532ADA +index = [9][3][4] +...checksum after hashing g_1009[i][j][k] : AB07A3EF +index = [9][3][5] +...checksum after hashing g_1056[i] : FBA7BE6D +index = [0] +...checksum after hashing g_1137 : 6F63531B +...checksum after hashing g_1214 : 87AA9C23 +...checksum after hashing g_1331 : 81F2F89E +...checksum after hashing g_1332 : 4BE637E4 +...checksum after hashing g_1333 : 6408F013 +...checksum after hashing g_1334[i][j][k] : 72171B7D +index = [0][0][0] +...checksum after hashing g_1334[i][j][k] : EE0912E5 +index = [0][0][1] +...checksum after hashing g_1334[i][j][k] : 6037561E +index = [0][0][2] +...checksum after hashing g_1334[i][j][k] : BA9C9E62 +index = [0][1][0] +...checksum after hashing g_1334[i][j][k] : F647B4A0 +index = [0][1][1] +...checksum after hashing g_1334[i][j][k] : F511ACD0 +index = [0][1][2] +...checksum after hashing g_1334[i][j][k] : 788F05C9 +index = [0][2][0] +...checksum after hashing g_1334[i][j][k] : 51C72816 +index = [0][2][1] +...checksum after hashing g_1334[i][j][k] : B6799E95 +index = [0][2][2] +...checksum after hashing g_1334[i][j][k] : A8B758BC +index = [0][3][0] +...checksum after hashing g_1334[i][j][k] : DF244DE2 +index = [0][3][1] +...checksum after hashing g_1334[i][j][k] : 1C564F7D +index = [0][3][2] +...checksum after hashing g_1334[i][j][k] : 4C16D464 +index = [0][4][0] +...checksum after hashing g_1334[i][j][k] : A80C0553 +index = [0][4][1] +...checksum after hashing g_1334[i][j][k] : B7DB11EE +index = [0][4][2] +...checksum after hashing g_1334[i][j][k] : 9E08B96F +index = [0][5][0] +...checksum after hashing g_1334[i][j][k] : 5B617C11 +index = [0][5][1] +...checksum after hashing g_1334[i][j][k] : FC1F7145 +index = [0][5][2] +...checksum after hashing g_1334[i][j][k] : 309A5E88 +index = [0][6][0] +...checksum after hashing g_1334[i][j][k] : 167AB135 +index = [0][6][1] +...checksum after hashing g_1334[i][j][k] : 9695BC21 +index = [0][6][2] +...checksum after hashing g_1334[i][j][k] : B207E07A +index = [0][7][0] +...checksum after hashing g_1334[i][j][k] : A4DC9F01 +index = [0][7][1] +...checksum after hashing g_1334[i][j][k] : 50533C20 +index = [0][7][2] +...checksum after hashing g_1334[i][j][k] : CF11C068 +index = [0][8][0] +...checksum after hashing g_1334[i][j][k] : 91D58151 +index = [0][8][1] +...checksum after hashing g_1334[i][j][k] : 876638A7 +index = [0][8][2] +...checksum after hashing g_1334[i][j][k] : 1B668E85 +index = [1][0][0] +...checksum after hashing g_1334[i][j][k] : 2B2B8FD9 +index = [1][0][1] +...checksum after hashing g_1334[i][j][k] : 5198C34E +index = [1][0][2] +...checksum after hashing g_1334[i][j][k] : D4CCF60F +index = [1][1][0] +...checksum after hashing g_1334[i][j][k] : BFE29986 +index = [1][1][1] +...checksum after hashing g_1334[i][j][k] : 90D85E22 +index = [1][1][2] +...checksum after hashing g_1334[i][j][k] : C696918F +index = [1][2][0] +...checksum after hashing g_1334[i][j][k] : 15FD8144 +index = [1][2][1] +...checksum after hashing g_1334[i][j][k] : F4F921D +index = [1][2][2] +...checksum after hashing g_1334[i][j][k] : 7B14852E +index = [1][3][0] +...checksum after hashing g_1334[i][j][k] : 1D3FB7E +index = [1][3][1] +...checksum after hashing g_1334[i][j][k] : 2B306B54 +index = [1][3][2] +...checksum after hashing g_1334[i][j][k] : 8F9423F2 +index = [1][4][0] +...checksum after hashing g_1334[i][j][k] : B5348C0 +index = [1][4][1] +...checksum after hashing g_1334[i][j][k] : 943473ED +index = [1][4][2] +...checksum after hashing g_1334[i][j][k] : 5F7CE171 +index = [1][5][0] +...checksum after hashing g_1334[i][j][k] : EE60768F +index = [1][5][1] +...checksum after hashing g_1334[i][j][k] : 59394A76 +index = [1][5][2] +...checksum after hashing g_1334[i][j][k] : 64A079EC +index = [1][6][0] +...checksum after hashing g_1334[i][j][k] : 20B355A6 +index = [1][6][1] +...checksum after hashing g_1334[i][j][k] : 234BE267 +index = [1][6][2] +...checksum after hashing g_1334[i][j][k] : 8CAB6EFB +index = [1][7][0] +...checksum after hashing g_1334[i][j][k] : 1B675C73 +index = [1][7][1] +...checksum after hashing g_1334[i][j][k] : ED874CAA +index = [1][7][2] +...checksum after hashing g_1334[i][j][k] : 2B8595E9 +index = [1][8][0] +...checksum after hashing g_1334[i][j][k] : 32AE2425 +index = [1][8][1] +...checksum after hashing g_1334[i][j][k] : 53D735D9 +index = [1][8][2] +...checksum after hashing g_1334[i][j][k] : D9FD7CB +index = [2][0][0] +...checksum after hashing g_1334[i][j][k] : 54D7D8CD +index = [2][0][1] +...checksum after hashing g_1334[i][j][k] : 3DA02188 +index = [2][0][2] +...checksum after hashing g_1334[i][j][k] : C65E17EE +index = [2][1][0] +...checksum after hashing g_1334[i][j][k] : 24A0B741 +index = [2][1][1] +...checksum after hashing g_1334[i][j][k] : CFCF46B +index = [2][1][2] +...checksum after hashing g_1334[i][j][k] : 1B8269A +index = [2][2][0] +...checksum after hashing g_1334[i][j][k] : 3279C4BD +index = [2][2][1] +...checksum after hashing g_1334[i][j][k] : AB810F6A +index = [2][2][2] +...checksum after hashing g_1334[i][j][k] : 88967AE2 +index = [2][3][0] +...checksum after hashing g_1334[i][j][k] : E2007C68 +index = [2][3][1] +...checksum after hashing g_1334[i][j][k] : 19C9114D +index = [2][3][2] +...checksum after hashing g_1334[i][j][k] : 96225D5 +index = [2][4][0] +...checksum after hashing g_1334[i][j][k] : F4B37413 +index = [2][4][1] +...checksum after hashing g_1334[i][j][k] : 8731B43 +index = [2][4][2] +...checksum after hashing g_1334[i][j][k] : E08D4412 +index = [2][5][0] +...checksum after hashing g_1334[i][j][k] : B94FEDF0 +index = [2][5][1] +...checksum after hashing g_1334[i][j][k] : 1A7945CD +index = [2][5][2] +...checksum after hashing g_1334[i][j][k] : 1C030490 +index = [2][6][0] +...checksum after hashing g_1334[i][j][k] : 67CBE549 +index = [2][6][1] +...checksum after hashing g_1334[i][j][k] : B1F06E8C +index = [2][6][2] +...checksum after hashing g_1334[i][j][k] : C85471A +index = [2][7][0] +...checksum after hashing g_1334[i][j][k] : 94B9FC58 +index = [2][7][1] +...checksum after hashing g_1334[i][j][k] : 597CA4DA +index = [2][7][2] +...checksum after hashing g_1334[i][j][k] : 8034222B +index = [2][8][0] +...checksum after hashing g_1334[i][j][k] : F3777C80 +index = [2][8][1] +...checksum after hashing g_1334[i][j][k] : 8AEDF0FB +index = [2][8][2] +...checksum after hashing g_1334[i][j][k] : 7A1D4D28 +index = [3][0][0] +...checksum after hashing g_1334[i][j][k] : 85E2FFA1 +index = [3][0][1] +...checksum after hashing g_1334[i][j][k] : F969B14A +index = [3][0][2] +...checksum after hashing g_1334[i][j][k] : BF2D2E05 +index = [3][1][0] +...checksum after hashing g_1334[i][j][k] : 13291A0A +index = [3][1][1] +...checksum after hashing g_1334[i][j][k] : E34AA238 +index = [3][1][2] +...checksum after hashing g_1334[i][j][k] : 68998789 +index = [3][2][0] +...checksum after hashing g_1334[i][j][k] : 29468154 +index = [3][2][1] +...checksum after hashing g_1334[i][j][k] : 43556789 +index = [3][2][2] +...checksum after hashing g_1334[i][j][k] : 6899972C +index = [3][3][0] +...checksum after hashing g_1334[i][j][k] : AAF20EB9 +index = [3][3][1] +...checksum after hashing g_1334[i][j][k] : 4624C3E1 +index = [3][3][2] +...checksum after hashing g_1334[i][j][k] : 5300C96 +index = [3][4][0] +...checksum after hashing g_1334[i][j][k] : BC9AE019 +index = [3][4][1] +...checksum after hashing g_1334[i][j][k] : E47083A5 +index = [3][4][2] +...checksum after hashing g_1334[i][j][k] : E807AA30 +index = [3][5][0] +...checksum after hashing g_1334[i][j][k] : EE42CE82 +index = [3][5][1] +...checksum after hashing g_1334[i][j][k] : A0DA84BB +index = [3][5][2] +...checksum after hashing g_1334[i][j][k] : D9A97B4D +index = [3][6][0] +...checksum after hashing g_1334[i][j][k] : 9D328D7C +index = [3][6][1] +...checksum after hashing g_1334[i][j][k] : 535E95F6 +index = [3][6][2] +...checksum after hashing g_1334[i][j][k] : EC8747D6 +index = [3][7][0] +...checksum after hashing g_1334[i][j][k] : 807DA3D1 +index = [3][7][1] +...checksum after hashing g_1334[i][j][k] : C94DE3DA +index = [3][7][2] +...checksum after hashing g_1334[i][j][k] : 4491819A +index = [3][8][0] +...checksum after hashing g_1334[i][j][k] : 905BF18F +index = [3][8][1] +...checksum after hashing g_1334[i][j][k] : 1E35A8AC +index = [3][8][2] +...checksum after hashing g_1335 : 7F35A006 +...checksum after hashing g_1336 : FBC7634D +...checksum after hashing g_1337 : 15C06CE1 +...checksum after hashing g_1338 : F1493664 +...checksum after hashing g_1339 : FFEB1325 +...checksum after hashing g_1374 : 59E9C5 +...checksum after hashing g_1433 : CC962A27 +...checksum after hashing g_1481 : F1E0798F +...checksum after hashing g_1658 : 6EDCAA59 +...checksum after hashing g_1665.f0 : AFC9561 +...checksum after hashing g_1689[i] : FF9DD427 +index = [0] +...checksum after hashing g_1689[i] : B16F6252 +index = [1] +...checksum after hashing g_1689[i] : A9E3D906 +index = [2] +...checksum after hashing g_1689[i] : 631F3780 +index = [3] +...checksum after hashing g_1978 : A5BEFD0B +...checksum after hashing g_1999 : 3BE73924 +...checksum after hashing g_2095 : 6BA22DF3 +...checksum after hashing g_2150 : 8E1565C6 +...checksum after hashing g_2157.f0 : E77DE220 +...checksum after hashing g_2288 : E9890F4F +...checksum after hashing g_2337.f0 : AD16AED8 +...checksum after hashing g_2437.f0 : 36DCA0CC +...checksum after hashing g_2438.f0 : F06083DB +...checksum after hashing g_2439.f0 : 9F12A7F8 +...checksum after hashing g_2440.f0 : 629562F1 +...checksum after hashing g_2441.f0 : AC733BC8 +...checksum after hashing g_2442.f0 : A83C3410 +...checksum after hashing g_2443.f0 : D0CFE40B +...checksum after hashing g_2545 : 82700378 +...checksum after hashing g_2635 : 28591463 +...checksum after hashing g_2660 : C8DA7CD4 +...checksum after hashing g_2714 : 7E31E4DB +...checksum after hashing g_2718 : 8CD4BD1F +...checksum after hashing g_2774[i][j] : EB21CAE4 +index = [0][0] +...checksum after hashing g_2774[i][j] : EEE2F62E +index = [1][0] +...checksum after hashing g_2774[i][j] : D59B7819 +index = [2][0] +...checksum after hashing g_2774[i][j] : 98269FC8 +index = [3][0] +...checksum after hashing g_2774[i][j] : 72E11404 +index = [4][0] +...checksum after hashing g_2774[i][j] : 5B30F082 +index = [5][0] +...checksum after hashing g_2774[i][j] : CC7885A0 +index = [6][0] +...checksum after hashing g_2774[i][j] : A9169582 +index = [7][0] +...checksum after hashing g_2774[i][j] : F6F703F4 +index = [8][0] +...checksum after hashing g_2781 : DCA361EE +...checksum after hashing g_2808[i] : 88A665CE +index = [0] +...checksum after hashing g_2808[i] : 8901C7FB +index = [1] +...checksum after hashing g_2808[i] : AD615043 +index = [2] +...checksum after hashing g_2808[i] : 2F684FB5 +index = [3] +...checksum after hashing g_2808[i] : FA1310AD +index = [4] +...checksum after hashing g_2808[i] : A020AE46 +index = [5] +...checksum after hashing g_2808[i] : 6F5D1D2D +index = [6] +checksum = 6F5D1D2D diff --git a/tests/csmith/f1.c b/tests/csmith/f1.c new file mode 100644 index 00000000..cbd6c5a4 --- /dev/null +++ b/tests/csmith/f1.c @@ -0,0 +1,2689 @@ +/* + * This is a RANDOMLY GENERATED PROGRAM. + * + * Generator: csmith 2.4.0 + * Git version: 0ec6f1b + * Options: (none) + * Seed: 1736999600 + */ + +#include "csmith.h" + + +static long __undefined; + +/* --- Struct/Union Declarations --- */ +#pragma pack(push) +#pragma pack(1) +struct S0 { + volatile signed f0 : 6; +}; +#pragma pack(pop) + +struct S1 { + uint32_t f0; +}; + +union U2 { + volatile signed f0 : 18; + volatile int8_t f1; + int32_t f2; +}; + +union U3 { + int64_t f0; + signed f1 : 19; + uint32_t f2; + volatile int8_t f3; +}; + +/* --- GLOBAL VARIABLES --- */ +static uint32_t g_13 = 0xBBD0A708L; +static uint64_t g_15[3] = {3UL,3UL,3UL}; +static int16_t g_47 = (-1L); +static volatile union U3 g_48 = {0x7221EBC5F93BE41BLL};/* VOLATILE GLOBAL g_48 */ +static uint64_t g_50[8][6][4] = {{{1UL,18446744073709551615UL,0x771356723FF4914DLL,1UL},{0x962DE1B453F47794LL,18446744073709551606UL,8UL,0x99D012CD0AB83DCDLL},{0x9E06D3C1D26016E5LL,0x2A889E4E2CD5B9AALL,0x7A12536DE7EBAC3FLL,0xCC4390AC9F79E4B3LL},{0x7A12536DE7EBAC3FLL,0xCC4390AC9F79E4B3LL,18446744073709551608UL,0xE3C239170055833ALL},{18446744073709551615UL,0x935178915D48947DLL,1UL,0x99D012CD0AB83DCDLL},{0xEC37461BCF2EC287LL,0xCDD171CF63D7CB68LL,0xE3C239170055833ALL,18446744073709551613UL}},{{0xC42EF39980A6F85DLL,18446744073709551615UL,0UL,0UL},{0x2507BCD5AEB5978FLL,0x2507BCD5AEB5978FLL,8UL,0x962DE1B453F47794LL},{0xEC37461BCF2EC287LL,0UL,0xC42EF39980A6F85DLL,18446744073709551606UL},{0x771356723FF4914DLL,0x9E06D3C1D26016E5LL,18446744073709551608UL,0xC42EF39980A6F85DLL},{0x99D012CD0AB83DCDLL,0x9E06D3C1D26016E5LL,0UL,0x2A889E4E2CD5B9AALL},{0UL,4UL,0xC584EDB553A81F6ELL,0xCDD171CF63D7CB68LL}},{{0xD45C545F0A862252LL,0xE3C239170055833ALL,0UL,4UL},{0xC42EF39980A6F85DLL,1UL,18446744073709551613UL,0xC42EF39980A6F85DLL},{0xCDD171CF63D7CB68LL,0x647D02C9AA6F5761LL,0xC584EDB553A81F6ELL,0UL},{0UL,18446744073709551615UL,18446744073709551615UL,0x429B0536403AC464LL},{0UL,0xFE96F77D900D2964LL,0xEC37461BCF2EC287LL,0xFE96F77D900D2964LL},{1UL,8UL,8UL,0UL}},{{0UL,0x2A889E4E2CD5B9AALL,0x429B0536403AC464LL,1UL},{0xE3C239170055833ALL,1UL,18446744073709551615UL,0x771356723FF4914DLL},{0xE3C239170055833ALL,8UL,0x429B0536403AC464LL,0xCDD171CF63D7CB68LL},{0UL,0x771356723FF4914DLL,8UL,0x647D02C9AA6F5761LL},{1UL,0UL,0xEC37461BCF2EC287LL,0xE3C239170055833ALL},{0UL,0UL,18446744073709551615UL,0x2A889E4E2CD5B9AALL}},{{0UL,0x771356723FF4914DLL,0xC584EDB553A81F6ELL,0xD45C545F0A862252LL},{0xCDD171CF63D7CB68LL,0xE3C239170055833ALL,18446744073709551613UL,0x771356723FF4914DLL},{0xC42EF39980A6F85DLL,0UL,0UL,0xC42EF39980A6F85DLL},{0xD45C545F0A862252LL,0x2A889E4E2CD5B9AALL,0xC584EDB553A81F6ELL,18446744073709551615UL},{0UL,18446744073709551615UL,18446744073709551610UL,0xFE96F77D900D2964LL},{0UL,0x429B0536403AC464LL,0x709E8E548E01AFECLL,0xFE96F77D900D2964LL}},{{0UL,18446744073709551615UL,8UL,18446744073709551615UL},{0x7A12536DE7EBAC3FLL,0x2A889E4E2CD5B9AALL,0x9E06D3C1D26016E5LL,0xC42EF39980A6F85DLL},{0xE3C239170055833ALL,0UL,4UL,0x771356723FF4914DLL},{8UL,0xE3C239170055833ALL,0x429B0536403AC464LL,0xD45C545F0A862252LL},{0x7A12536DE7EBAC3FLL,0x771356723FF4914DLL,0xCC4390AC9F79E4B3LL,0x2A889E4E2CD5B9AALL},{1UL,0UL,0x709E8E548E01AFECLL,0xE3C239170055833ALL}},{{18446744073709551615UL,0UL,18446744073709551615UL,0x647D02C9AA6F5761LL},{0UL,0x771356723FF4914DLL,0xDD038CF49CF94A22LL,0xCDD171CF63D7CB68LL},{0xCDD171CF63D7CB68LL,8UL,0UL,0x771356723FF4914DLL},{1UL,1UL,0UL,1UL},{0xCDD171CF63D7CB68LL,0x2A889E4E2CD5B9AALL,0xDD038CF49CF94A22LL,0UL},{0UL,8UL,18446744073709551615UL,0xFE96F77D900D2964LL}},{{18446744073709551615UL,0xFE96F77D900D2964LL,0x709E8E548E01AFECLL,0x429B0536403AC464LL},{1UL,18446744073709551615UL,0xCC4390AC9F79E4B3LL,0UL},{0x7A12536DE7EBAC3FLL,0x647D02C9AA6F5761LL,0x429B0536403AC464LL,0xC42EF39980A6F85DLL},{8UL,1UL,4UL,4UL},{0xE3C239170055833ALL,0xE3C239170055833ALL,0x9E06D3C1D26016E5LL,0xCDD171CF63D7CB68LL},{0x7A12536DE7EBAC3FLL,4UL,8UL,0x2A889E4E2CD5B9AALL}}}; +static uint64_t * volatile g_49 = &g_50[1][2][1];/* VOLATILE GLOBAL g_49 */ +static int32_t g_56 = 0x98031143L; +static uint64_t g_57 = 18446744073709551606UL; +static struct S1 g_63 = {1UL}; +static struct S1 *g_62[2][2][8] = {{{&g_63,&g_63,&g_63,&g_63,&g_63,&g_63,&g_63,&g_63},{&g_63,&g_63,&g_63,&g_63,&g_63,&g_63,&g_63,&g_63}},{{&g_63,&g_63,&g_63,&g_63,&g_63,&g_63,&g_63,&g_63},{&g_63,&g_63,&g_63,&g_63,&g_63,&g_63,&g_63,&g_63}}}; +static struct S1 *g_66 = &g_63; +static struct S1 ** volatile g_65 = &g_66;/* VOLATILE GLOBAL g_65 */ +static int32_t * volatile g_68 = &g_56;/* VOLATILE GLOBAL g_68 */ +static struct S0 g_70 = {7};/* VOLATILE GLOBAL g_70 */ +static const struct S0 *g_72 = (void*)0; +static const struct S0 ** volatile g_71 = &g_72;/* VOLATILE GLOBAL g_71 */ +static int32_t g_75 = 1L; +static volatile uint16_t g_94[8] = {1UL,1UL,1UL,1UL,1UL,1UL,1UL,1UL}; +static struct S1 **g_109 = &g_62[1][0][1]; +static struct S0 g_128[8][6][2] = {{{{4},{0}},{{2},{-2}},{{-3},{-0}},{{-3},{-2}},{{2},{-2}},{{-3},{-0}}},{{{-3},{-2}},{{2},{-2}},{{-3},{-0}},{{-3},{-2}},{{2},{-2}},{{-3},{-0}}},{{{-3},{-2}},{{2},{-2}},{{-3},{-0}},{{-3},{-2}},{{2},{-2}},{{-3},{-0}}},{{{-3},{-2}},{{2},{-2}},{{-3},{-0}},{{-3},{-2}},{{2},{-2}},{{-3},{-0}}},{{{-3},{-2}},{{2},{-2}},{{-3},{-0}},{{-3},{-2}},{{2},{-2}},{{-3},{-0}}},{{{-3},{-2}},{{2},{-2}},{{-3},{-0}},{{-3},{-2}},{{2},{-2}},{{-3},{-0}}},{{{-3},{-2}},{{2},{-2}},{{-3},{-0}},{{-3},{-2}},{{2},{-2}},{{-3},{-0}}},{{{-3},{-2}},{{2},{-2}},{{-3},{-0}},{{-3},{-2}},{{2},{-2}},{{-3},{-0}}}}; +static uint64_t g_133 = 0x6651808F8001326FLL; +static int16_t g_148 = 0xB6B1L; +static int16_t g_153 = 1L; +static volatile uint32_t g_154 = 0x10136EA5L;/* VOLATILE GLOBAL g_154 */ +static uint16_t g_158 = 1UL; +static volatile int32_t ** volatile *g_159 = (void*)0; +static union U2 g_161[3] = {{0x02645416L},{0x02645416L},{0x02645416L}}; +static int32_t *g_163 = &g_75; +static int32_t ** const volatile g_162 = &g_163;/* VOLATILE GLOBAL g_162 */ +static int32_t ** const volatile g_164 = (void*)0;/* VOLATILE GLOBAL g_164 */ +static uint64_t g_171 = 0UL; +static int8_t g_196 = 0xFFL; +static const struct S0 ** volatile g_199 = &g_72;/* VOLATILE GLOBAL g_199 */ +static uint8_t g_217[5][10] = {{1UL,0x6EL,5UL,0x0CL,0x54L,0xE6L,0x54L,0x0CL,5UL,0x6EL},{0xEBL,0UL,0x2FL,255UL,255UL,0x02L,0xF0L,5UL,255UL,255UL},{0UL,255UL,0x02L,0xE6L,0xE6L,0x02L,255UL,0UL,255UL,0xF0L},{0xEBL,0x2FL,0x0CL,0UL,0xCBL,0xE6L,0x32L,0xF0L,0x32L,0xE6L},{1UL,0xCBL,0x0CL,0xCBL,1UL,0xF0L,255UL,0UL,255UL,0x02L}}; +static uint8_t g_219 = 0x3BL; +static const int32_t *g_226 = (void*)0; +static const int32_t ** volatile g_225 = &g_226;/* VOLATILE GLOBAL g_225 */ +static int64_t g_232 = 0xEB3E65D3785568F7LL; +static volatile uint32_t g_234[8][3] = {{1UL,1UL,0x997FF8A4L},{0x8716988AL,0x997FF8A4L,0x997FF8A4L},{0x997FF8A4L,0x01C5CEDBL,0x69F502D7L},{0x8716988AL,0x01C5CEDBL,0x8716988AL},{1UL,0x997FF8A4L,0x69F502D7L},{1UL,1UL,0x997FF8A4L},{0x8716988AL,0x997FF8A4L,0x997FF8A4L},{0x997FF8A4L,0x01C5CEDBL,0x69F502D7L}}; +static volatile struct S0 g_270 = {-5};/* VOLATILE GLOBAL g_270 */ +static uint16_t g_275 = 0xB296L; +static volatile struct S0 g_276 = {-2};/* VOLATILE GLOBAL g_276 */ +static const volatile union U2 g_279 = {0xFD4C5296L};/* VOLATILE GLOBAL g_279 */ +static int32_t * volatile g_292 = &g_56;/* VOLATILE GLOBAL g_292 */ +static volatile union U3 g_293 = {0xB230814F4F9EC15FLL};/* VOLATILE GLOBAL g_293 */ +static struct S1 g_334[8][10] = {{{0x73953954L},{0xEF3ABFB5L},{4294967295UL},{0x73953954L},{0x3F403EBEL},{4294967295UL},{4294967295UL},{0x3F403EBEL},{0x73953954L},{4294967295UL}},{{0x3F403EBEL},{0x3F403EBEL},{4UL},{0xEF3ABFB5L},{0x3F403EBEL},{4294967294UL},{0xEF3ABFB5L},{0xEF3ABFB5L},{4294967294UL},{0x73953954L}},{{0x73953954L},{4UL},{4UL},{0x73953954L},{4294967294UL},{4UL},{4294967295UL},{4294967294UL},{4294967294UL},{4294967295UL}},{{4294967294UL},{0x73953954L},{4UL},{4UL},{0x73953954L},{4294967294UL},{4UL},{4294967295UL},{4294967294UL},{4294967294UL}},{{0x73953954L},{4294967295UL},{0xEF3ABFB5L},{0x73953954L},{0x73953954L},{0xEF3ABFB5L},{4294967295UL},{0x73953954L},{0x3F403EBEL},{4294967295UL}},{{0x73953954L},{4294967294UL},{4UL},{4294967295UL},{4294967294UL},{4294967294UL},{4294967295UL},{4UL},{4294967294UL},{0x73953954L}},{{4294967294UL},{4294967295UL},{4UL},{4294967294UL},{0x73953954L},{4UL},{4UL},{0x73953954L},{4294967294UL},{4UL}},{{0x73953954L},{0x73953954L},{0xEF3ABFB5L},{4294967295UL},{0x73953954L},{0x3F403EBEL},{4294967295UL},{4294967295UL},{0x3F403EBEL},{0x73953954L}}}; +static struct S1 * const volatile g_336 = (void*)0;/* VOLATILE GLOBAL g_336 */ +static struct S1 * volatile g_337 = &g_334[7][3];/* VOLATILE GLOBAL g_337 */ +static int32_t ** volatile g_346[4] = {&g_163,&g_163,&g_163,&g_163}; +static int32_t ** volatile g_347 = &g_163;/* VOLATILE GLOBAL g_347 */ +static int32_t ***** volatile g_360 = (void*)0;/* VOLATILE GLOBAL g_360 */ +static struct S1 ***g_391 = &g_109; +static struct S1 ****g_390 = &g_391; +static const int32_t ** volatile g_472[6][3] = {{&g_226,&g_226,&g_226},{&g_226,&g_226,&g_226},{&g_226,&g_226,&g_226},{&g_226,&g_226,&g_226},{&g_226,&g_226,&g_226},{&g_226,&g_226,&g_226}}; +static const int32_t ** volatile g_473 = &g_226;/* VOLATILE GLOBAL g_473 */ +static int8_t g_554 = 0L; +static uint32_t *g_563 = (void*)0; +static uint64_t g_626[10][5][5] = {{{18446744073709551607UL,2UL,18446744073709551615UL,2UL,18446744073709551607UL},{1UL,0x7B7528EB9E8552F8LL,18446744073709551608UL,1UL,0x67934836B9889BBCLL},{0x0645434E3136FB00LL,0x5DA485B180E4EADCLL,0x9ABC841629C48CF7LL,0x2C2FC08B493F9349LL,0x58179D24AA2698B7LL},{5UL,18446744073709551612UL,0x67934836B9889BBCLL,0x7B7528EB9E8552F8LL,0x67934836B9889BBCLL},{0x2C2FC08B493F9349LL,0x2C2FC08B493F9349LL,18446744073709551615UL,0x9ABC841629C48CF7LL,18446744073709551607UL}},{{0x67934836B9889BBCLL,0UL,0x7FACDD10D1700F88LL,18446744073709551611UL,0x726E4FEAD361A7A1LL},{18446744073709551615UL,0xCB604D9EE8143DC4LL,0x58179D24AA2698B7LL,1UL,2UL},{0xC27263100BF3AC69LL,0UL,1UL,1UL,0UL},{0x5DA485B180E4EADCLL,0x2C2FC08B493F9349LL,0UL,18446744073709551607UL,5UL},{0x7FACDD10D1700F88LL,18446744073709551612UL,7UL,0xDE8CD0D28004AF81LL,1UL}},{{0xCB604D9EE8143DC4LL,0x5DA485B180E4EADCLL,18446744073709551607UL,18446744073709551607UL,0x5DA485B180E4EADCLL},{0x726E4FEAD361A7A1LL,0x7B7528EB9E8552F8LL,0x25870BD17F6E7D1FLL,1UL,1UL},{0xB0BD6536BDD317C1LL,2UL,0x2C2FC08B493F9349LL,1UL,0UL},{0UL,0xBBFB95DE3D5A84F0LL,0xEC291840EDA9A4A2LL,18446744073709551611UL,0xE2EA130B41F19CA0LL},{0xB0BD6536BDD317C1LL,18446744073709551615UL,0xB0BD6536BDD317C1LL,0x9ABC841629C48CF7LL,0x2C6022DD8C05D00ELL}},{{0x726E4FEAD361A7A1LL,0x129B96CB15F39CA0LL,5UL,0x7B7528EB9E8552F8LL,1UL},{0xCB604D9EE8143DC4LL,1UL,5UL,0x2C2FC08B493F9349LL,2UL},{0x7FACDD10D1700F88LL,1UL,5UL,1UL,0x7FACDD10D1700F88LL},{0x5DA485B180E4EADCLL,0x75769F63764777E1LL,0xB0BD6536BDD317C1LL,2UL,0x2C2FC08B493F9349LL},{0xC27263100BF3AC69LL,0UL,0xEC291840EDA9A4A2LL,0UL,7UL}},{{18446744073709551615UL,0xB0BD6536BDD317C1LL,0x2C2FC08B493F9349LL,0x75769F63764777E1LL,0x2C2FC08B493F9349LL},{0x67934836B9889BBCLL,0UL,0x25870BD17F6E7D1FLL,0UL,18446744073709551608UL},{18446744073709551615UL,0x58179D24AA2698B7LL,0xB0BD6536BDD317C1LL,18446744073709551607UL,0x9ABC841629C48CF7LL},{0UL,1UL,0xE2EA130B41F19CA0LL,5UL,0x67934836B9889BBCLL},{2UL,0x58179D24AA2698B7LL,0x58179D24AA2698B7LL,2UL,18446744073709551615UL}},{{1UL,0xDE8CD0D28004AF81LL,7UL,18446744073709551612UL,0x7FACDD10D1700F88LL},{0xB0BD6536BDD317C1LL,0x2C6022DD8C05D00ELL,5UL,0x75769F63764777E1LL,0x58179D24AA2698B7LL},{1UL,0UL,18446744073709551608UL,18446744073709551612UL,1UL},{0x9ABC841629C48CF7LL,0x0645434E3136FB00LL,1UL,2UL,0UL},{0UL,0UL,5UL,5UL,7UL}},{{0x0645434E3136FB00LL,0xCB604D9EE8143DC4LL,0x5DA485B180E4EADCLL,18446744073709551607UL,18446744073709551607UL},{0UL,0xBBFB95DE3D5A84F0LL,0UL,0UL,0x25870BD17F6E7D1FLL},{0x9ABC841629C48CF7LL,1UL,0x75769F63764777E1LL,0x0645434E3136FB00LL,0x2C2FC08B493F9349LL},{1UL,5UL,0x7FACDD10D1700F88LL,0xDE8CD0D28004AF81LL,0xEC291840EDA9A4A2LL},{0xB0BD6536BDD317C1LL,0x2C2FC08B493F9349LL,0x75769F63764777E1LL,0x2C2FC08B493F9349LL,0xB0BD6536BDD317C1LL}},{{1UL,1UL,0UL,0UL,5UL},{2UL,0UL,0x5DA485B180E4EADCLL,18446744073709551615UL,5UL},{0UL,0UL,5UL,1UL,5UL},{18446744073709551615UL,18446744073709551615UL,1UL,0x5DA485B180E4EADCLL,0xB0BD6536BDD317C1LL},{5UL,0xD477FF0998DA7BBBLL,18446744073709551608UL,18446744073709551608UL,0xEC291840EDA9A4A2LL}},{{0x75769F63764777E1LL,2UL,5UL,0xCB604D9EE8143DC4LL,0x2C2FC08B493F9349LL},{0x726E4FEAD361A7A1LL,0xD477FF0998DA7BBBLL,7UL,0xB42DDA73BD8A8B03LL,0x25870BD17F6E7D1FLL},{0UL,18446744073709551615UL,0x58179D24AA2698B7LL,0xB0BD6536BDD317C1LL,18446744073709551607UL},{18446744073709551608UL,0UL,0xE2EA130B41F19CA0LL,0x7B7528EB9E8552F8LL,7UL},{2UL,0UL,0xB0BD6536BDD317C1LL,0xB0BD6536BDD317C1LL,0UL}},{{0xEC291840EDA9A4A2LL,1UL,0x0FF08DE55C7EB277LL,0xB42DDA73BD8A8B03LL,1UL},{0x2C6022DD8C05D00ELL,0x2C2FC08B493F9349LL,18446744073709551615UL,0xCB604D9EE8143DC4LL,0x58179D24AA2698B7LL},{0xC27263100BF3AC69LL,5UL,1UL,18446744073709551608UL,0x7FACDD10D1700F88LL},{0x2C6022DD8C05D00ELL,1UL,0x2C6022DD8C05D00ELL,0x5DA485B180E4EADCLL,18446744073709551615UL},{0xEC291840EDA9A4A2LL,0xBBFB95DE3D5A84F0LL,0UL,1UL,0x67934836B9889BBCLL}}}; +static union U2 g_679 = {-1L};/* VOLATILE GLOBAL g_679 */ +static struct S0 g_692 = {6};/* VOLATILE GLOBAL g_692 */ +static const volatile union U2 g_700[2][1][3] = {{{{0xF1199B2FL},{0xF1199B2FL},{0x1618003CL}}},{{{0xF1199B2FL},{0xF1199B2FL},{0x1618003CL}}}}; +static const struct S0 ** volatile g_736 = &g_72;/* VOLATILE GLOBAL g_736 */ +static union U2 *g_741 = &g_161[2]; +static union U2 ** volatile g_740 = &g_741;/* VOLATILE GLOBAL g_740 */ +static volatile union U2 g_760 = {0L};/* VOLATILE GLOBAL g_760 */ +static uint32_t g_763[1] = {0x065D854FL}; +static int32_t **g_790 = &g_163; +static int32_t g_809[1] = {5L}; +static union U3 g_836 = {-3L};/* VOLATILE GLOBAL g_836 */ +static const struct S1 *g_901[4] = {(void*)0,(void*)0,(void*)0,(void*)0}; +static const struct S1 **g_900 = &g_901[3]; +static const struct S1 ***g_899[3][6] = {{&g_900,&g_900,&g_900,&g_900,&g_900,&g_900},{&g_900,&g_900,&g_900,&g_900,&g_900,&g_900},{&g_900,&g_900,&g_900,&g_900,&g_900,&g_900}}; +static const struct S1 **** const g_898 = &g_899[0][5]; +static const struct S1 **** const *g_897[1][4] = {{&g_898,&g_898,&g_898,&g_898}}; +static uint64_t g_906 = 18446744073709551615UL; +static uint16_t g_919[9] = {65535UL,65535UL,65535UL,65535UL,65535UL,65535UL,65535UL,65535UL,65535UL}; +static int16_t g_937 = 1L; +static volatile union U2 g_975 = {1L};/* VOLATILE GLOBAL g_975 */ +static struct S0 g_987 = {-3};/* VOLATILE GLOBAL g_987 */ +static struct S0 g_1005 = {0};/* VOLATILE GLOBAL g_1005 */ +static int8_t *g_1032 = &g_554; +static const int32_t ** volatile g_1040 = &g_226;/* VOLATILE GLOBAL g_1040 */ +static struct S0 g_1043 = {-7};/* VOLATILE GLOBAL g_1043 */ +static uint32_t g_1057 = 1UL; +static volatile int8_t g_1071 = 0xBFL;/* VOLATILE GLOBAL g_1071 */ +static volatile int8_t * volatile g_1081 = &g_1071;/* VOLATILE GLOBAL g_1081 */ +static volatile int8_t * volatile * const g_1080 = &g_1081; +static volatile int8_t * volatile * const * volatile g_1079[2] = {&g_1080,&g_1080}; +static volatile int8_t * volatile * const * volatile * volatile g_1082 = &g_1079[1];/* VOLATILE GLOBAL g_1082 */ +static union U2 ** volatile g_1084 = &g_741;/* VOLATILE GLOBAL g_1084 */ +static const struct S0 g_1116 = {1};/* VOLATILE GLOBAL g_1116 */ +static union U2 g_1127 = {0L};/* VOLATILE GLOBAL g_1127 */ +static struct S0 g_1137 = {-0};/* VOLATILE GLOBAL g_1137 */ +static const volatile uint32_t * volatile * volatile g_1138 = (void*)0;/* VOLATILE GLOBAL g_1138 */ +static const struct S0 ** volatile ** volatile g_1181 = (void*)0;/* VOLATILE GLOBAL g_1181 */ +static const struct S0 g_1209[7] = {{-6},{-6},{-6},{-6},{-6},{-6},{-6}}; +static int32_t ***g_1229[8][10][3] = {{{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{(void*)0,&g_790,&g_790},{&g_790,&g_790,&g_790},{(void*)0,&g_790,&g_790},{&g_790,&g_790,&g_790},{(void*)0,&g_790,&g_790},{&g_790,&g_790,(void*)0},{(void*)0,&g_790,&g_790}},{{&g_790,&g_790,(void*)0},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790}},{{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{(void*)0,&g_790,&g_790},{&g_790,&g_790,&g_790},{(void*)0,&g_790,&g_790},{&g_790,&g_790,&g_790},{(void*)0,&g_790,&g_790}},{{&g_790,&g_790,(void*)0},{(void*)0,&g_790,&g_790},{&g_790,&g_790,(void*)0},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790}},{{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{(void*)0,&g_790,&g_790},{&g_790,&g_790,&g_790},{(void*)0,&g_790,&g_790}},{{&g_790,&g_790,&g_790},{(void*)0,&g_790,&g_790},{&g_790,&g_790,(void*)0},{(void*)0,&g_790,&g_790},{&g_790,&g_790,(void*)0},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790}},{{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,(void*)0,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,(void*)0},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790}},{{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,(void*)0,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790},{&g_790,&g_790,&g_790}}}; +static int32_t ****g_1228 = &g_1229[6][5][0]; +static int32_t *****g_1227 = &g_1228; +static int32_t g_1247[7] = {(-1L),(-1L),(-1L),(-1L),(-1L),(-1L),(-1L)}; +static volatile struct S0 g_1251 = {5};/* VOLATILE GLOBAL g_1251 */ +static volatile struct S0 g_1305 = {5};/* VOLATILE GLOBAL g_1305 */ +static int8_t ****g_1312 = (void*)0; +static struct S0 *g_1338[3] = {(void*)0,(void*)0,(void*)0}; +static struct S0 **g_1337 = &g_1338[0]; +static struct S0 ***g_1336 = &g_1337; +static struct S0 *** const *g_1335 = &g_1336; +static volatile struct S0 g_1421 = {1};/* VOLATILE GLOBAL g_1421 */ +static struct S0 g_1435 = {-4};/* VOLATILE GLOBAL g_1435 */ +static struct S0 * volatile g_1436 = &g_987;/* VOLATILE GLOBAL g_1436 */ +static struct S0 g_1454[6] = {{-1},{6},{-1},{-1},{6},{-1}}; +static uint32_t ***g_1466 = (void*)0; +static int32_t * volatile g_1481 = &g_809[0];/* VOLATILE GLOBAL g_1481 */ +static union U2 g_1488 = {-6L};/* VOLATILE GLOBAL g_1488 */ +static union U3 g_1499 = {0L};/* VOLATILE GLOBAL g_1499 */ +static union U3 *g_1498 = &g_1499; +static volatile union U2 g_1551 = {0L};/* VOLATILE GLOBAL g_1551 */ +static uint16_t *g_1621 = &g_919[1]; +static uint16_t **g_1620 = &g_1621; +static int32_t g_1630 = 5L; +static union U3 **g_1648 = &g_1498; +static union U2 ** volatile g_1659 = (void*)0;/* VOLATILE GLOBAL g_1659 */ +static uint32_t g_1663[9][10][2] = {{{4294967292UL,5UL},{4294967293UL,5UL},{4294967292UL,0x8498AD4DL},{0x8498AD4DL,4294967292UL},{5UL,4294967293UL},{5UL,4294967292UL},{0x8498AD4DL,0x8498AD4DL},{4294967292UL,5UL},{4294967293UL,5UL},{4294967292UL,0x8498AD4DL}},{{0x8498AD4DL,4294967292UL},{5UL,4294967293UL},{5UL,4294967292UL},{0x8498AD4DL,0x8498AD4DL},{4294967292UL,5UL},{4294967293UL,5UL},{4294967292UL,0x8498AD4DL},{0x8498AD4DL,4294967292UL},{5UL,4294967293UL},{5UL,4294967292UL}},{{0x8498AD4DL,0x8498AD4DL},{4294967292UL,5UL},{4294967293UL,5UL},{4294967292UL,0x8498AD4DL},{0x8498AD4DL,4294967292UL},{5UL,4294967293UL},{5UL,4294967292UL},{0x8498AD4DL,0x8498AD4DL},{4294967292UL,5UL},{4294967293UL,5UL}},{{4294967292UL,0x8498AD4DL},{0x8498AD4DL,4294967292UL},{5UL,4294967293UL},{5UL,4294967292UL},{0x8498AD4DL,0x8498AD4DL},{4294967292UL,5UL},{4294967293UL,5UL},{4294967292UL,0x8498AD4DL},{0x8498AD4DL,4294967292UL},{5UL,4294967293UL}},{{5UL,4294967292UL},{0x8498AD4DL,0x8498AD4DL},{4294967292UL,5UL},{4294967293UL,5UL},{4294967292UL,0x8498AD4DL},{0x8498AD4DL,4294967292UL},{5UL,4294967293UL},{5UL,4294967292UL},{0x8498AD4DL,0x8498AD4DL},{4294967292UL,5UL}},{{4294967293UL,5UL},{4294967292UL,0x8498AD4DL},{0x8498AD4DL,4294967292UL},{5UL,4294967293UL},{5UL,4294967292UL},{0x8498AD4DL,0x8498AD4DL},{4294967292UL,5UL},{4294967293UL,5UL},{4294967292UL,0x8498AD4DL},{0x8498AD4DL,4294967292UL}},{{5UL,4294967293UL},{4294967292UL,4294967293UL},{0UL,0UL},{4294967293UL,4294967292UL},{6UL,4294967292UL},{4294967293UL,0UL},{0UL,4294967293UL},{4294967292UL,6UL},{4294967292UL,4294967293UL},{0UL,0UL}},{{4294967293UL,4294967292UL},{6UL,4294967292UL},{4294967293UL,0UL},{0UL,4294967293UL},{4294967292UL,6UL},{4294967292UL,4294967293UL},{0UL,0UL},{4294967293UL,4294967292UL},{6UL,4294967292UL},{4294967293UL,0UL}},{{0UL,4294967293UL},{4294967292UL,6UL},{4294967292UL,4294967293UL},{0UL,0UL},{4294967293UL,4294967292UL},{6UL,4294967292UL},{4294967293UL,0UL},{0UL,4294967293UL},{4294967292UL,6UL},{4294967292UL,4294967293UL}}}; +static int32_t *** const *g_1669 = (void*)0; +static int32_t *** const ** volatile g_1668 = &g_1669;/* VOLATILE GLOBAL g_1668 */ +static union U3 ***g_1679 = &g_1648; +static const struct S0 ** const volatile g_1689 = &g_72;/* VOLATILE GLOBAL g_1689 */ +static volatile struct S0 g_1690[5] = {{-0},{-0},{-0},{-0},{-0}}; +static volatile struct S0 * volatile g_1691 = &g_1421;/* VOLATILE GLOBAL g_1691 */ +static struct S0 g_1704[8] = {{-6},{7},{-6},{7},{-6},{7},{-6},{7}}; +static int8_t g_1728 = 0xA5L; +static struct S0 g_1797 = {-4};/* VOLATILE GLOBAL g_1797 */ +static uint16_t * const * const g_1883[2] = {&g_1621,&g_1621}; +static uint16_t * const * const *g_1882[1] = {&g_1883[1]}; +static uint16_t * const * const **g_1881 = &g_1882[0]; +static int8_t *****g_1905 = &g_1312; +static const volatile int32_t g_1939 = 0x4C6E402AL;/* VOLATILE GLOBAL g_1939 */ +static struct S0 g_1954 = {3};/* VOLATILE GLOBAL g_1954 */ +static volatile union U3 g_1986 = {0x3DD9C89159887CDDLL};/* VOLATILE GLOBAL g_1986 */ +static volatile int32_t g_1991 = 0x1AC447CDL;/* VOLATILE GLOBAL g_1991 */ +static const int32_t ** volatile g_2001 = &g_226;/* VOLATILE GLOBAL g_2001 */ +static volatile union U2 g_2073 = {0x8A616871L};/* VOLATILE GLOBAL g_2073 */ +static volatile union U3 g_2078 = {0xE79DA20478FDDA7ELL};/* VOLATILE GLOBAL g_2078 */ +static volatile uint8_t g_2101 = 0x3BL;/* VOLATILE GLOBAL g_2101 */ +static uint64_t *g_2111[1] = {(void*)0}; +static const int64_t g_2201 = 0xF08B23571D3B01B0LL; +static const int64_t g_2203 = (-1L); +static const int64_t *g_2202 = &g_2203; +static struct S0 g_2207[9][10] = {{{2},{-1},{0},{-3},{4},{2},{-0},{1},{-0},{2}},{{-1},{4},{0},{4},{-1},{1},{1},{-3},{1},{6}},{{1},{-6},{6},{1},{1},{-2},{-2},{1},{1},{6}},{{1},{1},{-1},{6},{-1},{-2},{1},{0},{0},{2}},{{0},{-0},{1},{1},{4},{1},{1},{-0},{0},{1}},{{-6},{1},{0},{-1},{2},{2},{-2},{4},{4},{-2}},{{-0},{-6},{-1},{-1},{-6},{-0},{1},{2},{0},{-2}},{{-2},{4},{1},{1},{0},{-1},{-0},{-1},{0},{1}},{{-2},{-1},{-2},{6},{-2},{-0},{1},{2},{1},{2}}}; +static struct S0 g_2208 = {-5};/* VOLATILE GLOBAL g_2208 */ +static volatile uint32_t g_2254 = 0xF0540343L;/* VOLATILE GLOBAL g_2254 */ +static union U2 g_2270[8][7][4] = {{{{-5L},{0x2D5F37E4L},{5L},{-1L}},{{-4L},{0x3DCAB47AL},{-5L},{-1L}},{{0xE32BAB41L},{0x2D5F37E4L},{0xE32BAB41L},{0xCA341128L}},{{0xE32BAB41L},{0xCA341128L},{-5L},{0x9A2F9D2BL}},{{-4L},{0xCA341128L},{5L},{0xCA341128L}},{{-5L},{0x2D5F37E4L},{5L},{-1L}},{{-4L},{0x3DCAB47AL},{0xE32BAB41L},{0x2D5F37E4L}}},{{{5L},{0x3DCAB47AL},{5L},{0x9A2F9D2BL}},{{5L},{0x9A2F9D2BL},{0xE32BAB41L},{-1L}},{{-5L},{0x9A2F9D2BL},{-1L},{0x9A2F9D2BL}},{{0xE32BAB41L},{0x3DCAB47AL},{-1L},{0x2D5F37E4L}},{{-5L},{0xCA341128L},{0xE32BAB41L},{0x2D5F37E4L}},{{5L},{0x3DCAB47AL},{5L},{0x9A2F9D2BL}},{{5L},{0x9A2F9D2BL},{0xE32BAB41L},{-1L}}},{{{-5L},{0x9A2F9D2BL},{-1L},{0x9A2F9D2BL}},{{0xE32BAB41L},{0x3DCAB47AL},{-1L},{0x2D5F37E4L}},{{-5L},{0xCA341128L},{0xE32BAB41L},{0x2D5F37E4L}},{{5L},{0x3DCAB47AL},{5L},{0x9A2F9D2BL}},{{5L},{0x9A2F9D2BL},{0xE32BAB41L},{-1L}},{{-5L},{0x9A2F9D2BL},{-1L},{0x9A2F9D2BL}},{{0xE32BAB41L},{0x3DCAB47AL},{-1L},{0x2D5F37E4L}}},{{{-5L},{0xCA341128L},{0xE32BAB41L},{0x2D5F37E4L}},{{5L},{0x3DCAB47AL},{5L},{0x9A2F9D2BL}},{{5L},{0x9A2F9D2BL},{0xE32BAB41L},{-1L}},{{-5L},{0x9A2F9D2BL},{-1L},{0x9A2F9D2BL}},{{0xE32BAB41L},{0x3DCAB47AL},{-1L},{0x2D5F37E4L}},{{-5L},{0xCA341128L},{0xE32BAB41L},{0x2D5F37E4L}},{{5L},{0x3DCAB47AL},{5L},{0x9A2F9D2BL}}},{{{5L},{0x9A2F9D2BL},{0xE32BAB41L},{-1L}},{{-5L},{0x9A2F9D2BL},{-1L},{0x9A2F9D2BL}},{{0xE32BAB41L},{0x3DCAB47AL},{-1L},{0x2D5F37E4L}},{{-5L},{0xCA341128L},{0xE32BAB41L},{0x2D5F37E4L}},{{5L},{0x3DCAB47AL},{5L},{0x9A2F9D2BL}},{{5L},{0x9A2F9D2BL},{0xE32BAB41L},{-1L}},{{-5L},{0x9A2F9D2BL},{-1L},{0x9A2F9D2BL}}},{{{0xE32BAB41L},{0x3DCAB47AL},{-1L},{0x2D5F37E4L}},{{-5L},{0xCA341128L},{0xE32BAB41L},{0x2D5F37E4L}},{{5L},{0x3DCAB47AL},{5L},{0x9A2F9D2BL}},{{5L},{0x9A2F9D2BL},{0xE32BAB41L},{-1L}},{{-5L},{0x9A2F9D2BL},{-1L},{0x9A2F9D2BL}},{{0xE32BAB41L},{0x3DCAB47AL},{-1L},{0x2D5F37E4L}},{{-5L},{0xCA341128L},{0xE32BAB41L},{0x2D5F37E4L}}},{{{5L},{0x3DCAB47AL},{5L},{0x9A2F9D2BL}},{{5L},{0x9A2F9D2BL},{0xE32BAB41L},{-1L}},{{-5L},{0x9A2F9D2BL},{-1L},{0x9A2F9D2BL}},{{0xE32BAB41L},{0x3DCAB47AL},{-1L},{0x2D5F37E4L}},{{-5L},{0xCA341128L},{0xE32BAB41L},{0x2D5F37E4L}},{{5L},{0x3DCAB47AL},{5L},{0x9A2F9D2BL}},{{5L},{0x9A2F9D2BL},{0xE32BAB41L},{-1L}}},{{{-5L},{0x9A2F9D2BL},{-1L},{0x9A2F9D2BL}},{{0xE32BAB41L},{0x3DCAB47AL},{-1L},{0x2D5F37E4L}},{{-5L},{0xCA341128L},{0xE32BAB41L},{0x2D5F37E4L}},{{5L},{0x3DCAB47AL},{5L},{0x9A2F9D2BL}},{{5L},{0x9A2F9D2BL},{0xE32BAB41L},{-1L}},{{-5L},{-1L},{-4L},{-1L}},{{5L},{0xCA341128L},{-4L},{0x3DCAB47AL}}}}; +static union U2 g_2271 = {0x24F2782AL};/* VOLATILE GLOBAL g_2271 */ +static union U2 g_2272 = {0L};/* VOLATILE GLOBAL g_2272 */ +static union U2 g_2273 = {0xDAD95808L};/* VOLATILE GLOBAL g_2273 */ +static union U2 g_2274 = {0xE25F7C6AL};/* VOLATILE GLOBAL g_2274 */ +static union U2 g_2275[5] = {{4L},{4L},{4L},{4L},{4L}}; +static union U2 g_2276 = {-3L};/* VOLATILE GLOBAL g_2276 */ +static union U2 g_2277 = {0x8D3F0A85L};/* VOLATILE GLOBAL g_2277 */ +static union U2 g_2278 = {0x79274EEEL};/* VOLATILE GLOBAL g_2278 */ +static union U2 g_2279 = {0xA2072C5EL};/* VOLATILE GLOBAL g_2279 */ +static union U2 g_2280[4][5][8] = {{{{0x53F55769L},{1L},{0L},{0x0AD43505L},{0xAB29AFF8L},{0x0AD43505L},{0L},{1L}},{{-1L},{3L},{0x001D0AB5L},{0x0D7ADAACL},{0xDAB9027DL},{-1L},{0L},{0xEADB0F8BL}},{{0xBB34E193L},{-1L},{-5L},{4L},{-1L},{-1L},{0L},{0xAB29AFF8L}},{{0L},{4L},{0x001D0AB5L},{-1L},{0x0D7ADAACL},{0x53F55769L},{0L},{0x22320633L}},{{0x0D7ADAACL},{0x53F55769L},{0L},{0x22320633L},{0x001D0AB5L},{0x4E5552EEL},{6L},{0x9A398DA3L}}},{{{0L},{0xBB34E193L},{0xC2CE9A7AL},{4L},{4L},{0xC2CE9A7AL},{0xBB34E193L},{0L}},{{0xEADB0F8BL},{0x22320633L},{0xDAB9027DL},{0L},{0xBB34E193L},{3L},{-4L},{1L}},{{0x0D7ADAACL},{0x0AD43505L},{0x9A398DA3L},{0L},{0L},{3L},{1L},{0x001D0AB5L}},{{6L},{0x22320633L},{-3L},{0xA21F54D6L},{-1L},{0xC2CE9A7AL},{0xA21F54D6L},{0L}},{{0x001D0AB5L},{0xBB34E193L},{0x0AD43505L},{0xEADB0F8BL},{0xAB9524A2L},{0x4E5552EEL},{0x53F55769L},{6L}}},{{{-1L},{0x53F55769L},{0x9A398DA3L},{0xBB34E193L},{0x9A398DA3L},{0x53F55769L},{-1L},{0L}},{{1L},{4L},{0xBDC58391L},{0L},{0L},{-1L},{0xBB34E193L},{0L}},{{0x87BCEC8CL},{-1L},{-4L},{0x87BCEC8CL},{0L},{-1L},{0L},{0xBB34E193L}},{{1L},{3L},{0L},{0L},{0x9A398DA3L},{0x0AD43505L},{0x0D7ADAACL},{3L}},{{-1L},{1L},{-1L},{0x0D7ADAACL},{0xAB9524A2L},{1L},{0L},{0L}}},{{{0x001D0AB5L},{-1L},{0x4E5552EEL},{0x4E5552EEL},{-1L},{0x001D0AB5L},{0xEADB0F8BL},{0xAB29AFF8L}},{{6L},{0x4E5552EEL},{0x001D0AB5L},{0x22320633L},{0L},{0x53F55769L},{0x0D7ADAACL},{-1L}},{{0x0D7ADAACL},{1L},{-1L},{0x22320633L},{0xBB34E193L},{-5L},{6L},{0xAB29AFF8L}},{{0xEADB0F8BL},{0xBB34E193L},{-4L},{0x4E5552EEL},{4L},{-4L},{0x001D0AB5L},{0L}},{{0L},{-1L},{0xDAB9027DL},{0x0D7ADAACL},{0x001D0AB5L},{3L},{-1L},{3L}}}}; +static union U2 g_2281 = {-8L};/* VOLATILE GLOBAL g_2281 */ +static union U2 g_2282 = {0xF033530BL};/* VOLATILE GLOBAL g_2282 */ +static union U2 g_2283 = {1L};/* VOLATILE GLOBAL g_2283 */ +static union U2 g_2284 = {0x6C6A2E21L};/* VOLATILE GLOBAL g_2284 */ +static union U2 g_2285 = {0xC08D2476L};/* VOLATILE GLOBAL g_2285 */ +static union U2 g_2286[6][3] = {{{-10L},{0x6C77B0BAL},{-10L}},{{-10L},{0x4A20C8D9L},{0x6C77B0BAL}},{{0x4A20C8D9L},{-10L},{-10L}},{{0x6C77B0BAL},{-10L},{0x39EE6CF7L}},{{6L},{0x4A20C8D9L},{-6L}},{{0x6C77B0BAL},{0x6C77B0BAL},{-6L}}}; +static union U2 g_2287[9][5][1] = {{{{0x223FE2AFL}},{{1L}},{{0x4E9E33F7L}},{{2L}},{{0x68E83701L}}},{{{1L}},{{0x68E83701L}},{{2L}},{{0x4E9E33F7L}},{{1L}}},{{{0x223FE2AFL}},{{1L}},{{0x7869C727L}},{{0x9E6C6DA6L}},{{0x4E9E33F7L}}},{{{0x9E6C6DA6L}},{{0x7869C727L}},{{1L}},{{0x223FE2AFL}},{{1L}}},{{{0x4E9E33F7L}},{{2L}},{{0x68E83701L}},{{1L}},{{0x68E83701L}}},{{{2L}},{{0x4E9E33F7L}},{{1L}},{{0x223FE2AFL}},{{1L}}},{{{0x7869C727L}},{{0x9E6C6DA6L}},{{0x4E9E33F7L}},{{0x9E6C6DA6L}},{{0x7869C727L}}},{{{1L}},{{0x223FE2AFL}},{{1L}},{{0x4E9E33F7L}},{{2L}}},{{{0x68E83701L}},{{1L}},{{0x68E83701L}},{{2L}},{{0x4E9E33F7L}}}}; +static volatile uint64_t g_2293 = 0x0BE0EC4D18DC958FLL;/* VOLATILE GLOBAL g_2293 */ +static struct S0 g_2296 = {-1};/* VOLATILE GLOBAL g_2296 */ +static struct S0 * volatile g_2297 = &g_692;/* VOLATILE GLOBAL g_2297 */ +static volatile struct S0 g_2298 = {7};/* VOLATILE GLOBAL g_2298 */ +static volatile struct S0 * volatile g_2299 = &g_1251;/* VOLATILE GLOBAL g_2299 */ +static volatile struct S0 * volatile g_2301[8] = {(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0}; +static union U3 *g_2349 = &g_1499; +static struct S0 g_2350 = {0};/* VOLATILE GLOBAL g_2350 */ +static union U3 ** const *g_2375 = &g_1648; +static union U3 ** const **g_2374[7] = {&g_2375,&g_2375,&g_2375,&g_2375,&g_2375,&g_2375,&g_2375}; +static union U3 **g_2380 = &g_2349; +static union U3 **g_2381[8] = {&g_2349,&g_2349,&g_2349,&g_2349,&g_2349,&g_2349,&g_2349,&g_2349}; +static union U3 **g_2382 = &g_2349; +static union U3 *** const g_2379[7] = {&g_2381[7],&g_2382,&g_2381[7],&g_2381[7],&g_2382,&g_2381[7],&g_2381[7]}; +static union U3 *** const *g_2378 = &g_2379[4]; +static union U2 g_2393 = {0xD096BB92L};/* VOLATILE GLOBAL g_2393 */ +static struct S0 g_2467 = {5};/* VOLATILE GLOBAL g_2467 */ +static struct S0 g_2533 = {4};/* VOLATILE GLOBAL g_2533 */ +static volatile int32_t g_2535 = 0x37D8999AL;/* VOLATILE GLOBAL g_2535 */ +static struct S0 * volatile g_2558 = &g_1454[4];/* VOLATILE GLOBAL g_2558 */ +static int8_t g_2582[1] = {0L}; +static union U3 ** const ***g_2590 = &g_2374[0]; +static volatile struct S0 g_2592 = {-0};/* VOLATILE GLOBAL g_2592 */ +static volatile int32_t g_2621 = 0x0072052BL;/* VOLATILE GLOBAL g_2621 */ +static const int32_t *g_2641 = &g_1247[0]; +static const int32_t **g_2640 = &g_2641; +static const int32_t *** volatile g_2639 = &g_2640;/* VOLATILE GLOBAL g_2639 */ +static int8_t ***g_2690 = (void*)0; +static int8_t ****g_2689[5] = {&g_2690,&g_2690,&g_2690,&g_2690,&g_2690}; +static int8_t *****g_2688[9] = {&g_2689[1],&g_2689[1],&g_2689[1],&g_2689[1],&g_2689[1],&g_2689[1],&g_2689[1],&g_2689[1],&g_2689[1]}; +static int8_t *****g_2691 = &g_2689[0]; +static int64_t g_2744[2][9] = {{5L,7L,0xEF5EBC862873473ELL,7L,5L,0xEF5EBC862873473ELL,4L,4L,0xEF5EBC862873473ELL},{5L,7L,0xEF5EBC862873473ELL,7L,5L,0xEF5EBC862873473ELL,4L,4L,0xEF5EBC862873473ELL}}; +static union U3 g_2792 = {0L};/* VOLATILE GLOBAL g_2792 */ +static uint32_t g_2805[7][3] = {{0x6EFACD24L,0x6EFACD24L,0x6EFACD24L},{4294967289UL,4294967289UL,4294967289UL},{0x6EFACD24L,0x6EFACD24L,0x6EFACD24L},{4294967289UL,4294967289UL,4294967289UL},{0x6EFACD24L,0x6EFACD24L,0x6EFACD24L},{4294967289UL,4294967289UL,4294967289UL},{0x6EFACD24L,0x6EFACD24L,0x6EFACD24L}}; +static volatile union U3 g_2815 = {1L};/* VOLATILE GLOBAL g_2815 */ +static const uint16_t **g_2841[3][1] = {{(void*)0},{(void*)0},{(void*)0}}; +static const uint16_t g_2845[4] = {0UL,0UL,0UL,0UL}; +static uint32_t g_2898 = 0xE4A4376BL; +static union U2 ** volatile g_2900[3][10][6] = {{{&g_741,(void*)0,&g_741,(void*)0,&g_741,&g_741},{&g_741,&g_741,&g_741,&g_741,(void*)0,&g_741},{&g_741,&g_741,&g_741,&g_741,&g_741,&g_741},{&g_741,&g_741,&g_741,(void*)0,&g_741,&g_741},{&g_741,&g_741,(void*)0,&g_741,(void*)0,&g_741},{&g_741,&g_741,&g_741,&g_741,&g_741,&g_741},{&g_741,(void*)0,&g_741,&g_741,&g_741,&g_741},{&g_741,(void*)0,&g_741,(void*)0,&g_741,&g_741},{&g_741,&g_741,&g_741,&g_741,(void*)0,&g_741},{&g_741,&g_741,&g_741,&g_741,(void*)0,(void*)0}},{{&g_741,(void*)0,(void*)0,&g_741,(void*)0,&g_741},{&g_741,&g_741,&g_741,&g_741,&g_741,&g_741},{&g_741,&g_741,(void*)0,(void*)0,&g_741,(void*)0},{&g_741,&g_741,&g_741,&g_741,&g_741,(void*)0},{&g_741,&g_741,&g_741,&g_741,&g_741,&g_741},{&g_741,&g_741,&g_741,&g_741,&g_741,(void*)0},{&g_741,&g_741,&g_741,&g_741,(void*)0,(void*)0},{&g_741,(void*)0,(void*)0,&g_741,(void*)0,&g_741},{&g_741,&g_741,&g_741,&g_741,&g_741,&g_741},{&g_741,&g_741,(void*)0,(void*)0,&g_741,(void*)0}},{{&g_741,&g_741,&g_741,&g_741,&g_741,(void*)0},{&g_741,&g_741,&g_741,&g_741,&g_741,&g_741},{&g_741,&g_741,&g_741,&g_741,&g_741,(void*)0},{&g_741,&g_741,&g_741,&g_741,(void*)0,(void*)0},{&g_741,(void*)0,(void*)0,&g_741,(void*)0,&g_741},{&g_741,&g_741,&g_741,&g_741,&g_741,&g_741},{&g_741,&g_741,(void*)0,(void*)0,&g_741,(void*)0},{&g_741,&g_741,&g_741,&g_741,&g_741,(void*)0},{&g_741,&g_741,&g_741,&g_741,&g_741,&g_741},{&g_741,&g_741,&g_741,&g_741,&g_741,(void*)0}}}; +static const volatile union U2 g_2932 = {-3L};/* VOLATILE GLOBAL g_2932 */ + + +/* --- FORWARD DECLARATIONS --- */ +static int32_t func_1(void); +static int32_t func_2(uint8_t p_3, uint8_t p_4, uint64_t p_5); +static uint32_t func_9(uint64_t p_10, uint32_t p_11, uint32_t p_12); +static uint32_t func_16(uint32_t p_17, uint64_t * p_18, struct S1 p_19, uint64_t * const p_20, uint32_t p_21); +static uint64_t * func_22(uint64_t * p_23, uint32_t p_24, int64_t p_25); +static uint64_t * func_26(int16_t p_27); +static int16_t func_30(uint64_t p_31); +static const int32_t func_32(uint32_t p_33, uint64_t * p_34, uint64_t * const p_35, struct S1 p_36, uint64_t * p_37); +static uint64_t * func_38(uint32_t p_39, uint64_t * p_40); +static uint64_t * func_41(int32_t p_42, uint64_t * const p_43); + + +/* --- FUNCTIONS --- */ +/* ------------------------------------------ */ +/* + * reads : g_13 g_1057 g_63.f0 g_1071 g_790 g_163 g_75 g_217 g_906 g_1079 g_1082 g_1084 g_836.f2 g_109 g_62 g_1080 g_1081 g_162 g_390 g_391 g_919 g_56 g_275 g_1116 g_809 g_334.f0 g_741 g_49 g_763 g_700.f0 g_937 g_626 g_1137 g_1138 g_1032 g_48 g_57 g_554 g_47 g_50 g_347 g_196 g_133 g_148 g_1209 g_153 g_270 g_128 g_1305 g_1312 g_276.f0 g_1335 g_171 g_94 g_68 g_700 g_1421 g_292 g_1435 g_1436 g_1454 g_1336 g_1337 g_1481 g_1488 g_63 g_1498 g_692 g_1227 g_975.f0 g_158 g_219 g_1551 g_234 g_1620 g_1630 g_1247 g_1663 g_1668 g_1621 g_199 g_72 g_1689 g_1690 g_1691 g_1679 g_1648 g_1704 g_1488.f2 g_1728 g_987.f0 g_1040 g_1499.f0 g_2073 g_2078 g_2101 g_760.f0 g_1954.f0 g_2207 g_898 g_899 g_1986.f0 g_2254 g_2293 g_2296 g_2297 g_2298 g_2299 g_1338 g_2276.f0 g_2350 g_2202 g_2203 g_232 g_2374 g_2393 g_2201 g_2375 g_2286.f0 g_15 g_2467 g_1905 g_2533 g_2271.f2 g_2558 g_2592 g_2278.f2 g_836 g_2621 g_161.f0 g_2639 g_2744 g_900 g_901 g_2792 g_2271 g_2805 g_2815 g_2841 g_71 g_1939 g_2641 g_2898 g_740 g_2590 g_2932 g_2274.f2 + * writes: g_15 g_1057 g_836.f2 g_63.f0 g_217 g_906 g_1079 g_741 g_275 g_75 g_1005 g_334.f0 g_50 g_763 g_554 g_679.f2 g_196 g_163 g_133 g_692 g_1312 g_148 g_153 g_158 g_56 g_232 g_919 g_987 g_63 g_1137 g_1338 g_1466 g_809 g_626 g_1228 g_219 g_57 g_1620 g_1648 g_1663 g_1669 g_1679 g_72 g_1421 g_1498 g_47 g_937 g_334 g_70 g_1488.f2 g_226 g_1881 g_1499.f0 g_1127.f2 g_2101 g_2111 g_2202 g_2208 g_1621 g_171 g_2254 g_2293 g_1251 g_2349 g_2378 g_2285.f2 g_2278.f2 g_2271.f2 g_1454 g_836.f0 g_2590 g_2640 g_62 g_1032 g_2805 g_2274.f2 g_2283.f2 + */ +static int32_t func_1(void) +{ /* block id: 0 */ + uint32_t l_6 = 4294967294UL; + uint64_t *l_14 = &g_15[2]; + uint64_t *l_2110 = (void*)0; + uint64_t **l_2109[1][8] = {{&l_2110,&l_2110,&l_2110,&l_2110,&l_2110,&l_2110,&l_2110,&l_2110}}; + struct S1 l_2116 = {4294967295UL}; + uint32_t *l_2120 = (void*)0; + uint32_t *l_2121 = (void*)0; + uint32_t *l_2122[3][10] = {{&l_2116.f0,(void*)0,&g_334[3][3].f0,(void*)0,&l_2116.f0,&l_2116.f0,(void*)0,&g_334[3][3].f0,(void*)0,&l_2116.f0},{&l_2116.f0,(void*)0,&g_334[3][3].f0,(void*)0,&l_2116.f0,&l_2116.f0,(void*)0,&g_334[3][3].f0,(void*)0,&l_2116.f0},{&l_2116.f0,(void*)0,&g_334[3][3].f0,(void*)0,&l_2116.f0,&l_2116.f0,(void*)0,&g_334[3][3].f0,(void*)0,&l_2116.f0}}; + int32_t l_2123 = 0xFF4A4FE3L; + union U2 *l_2308[9]; + const uint32_t l_2319 = 0xEC19D3C9L; + int32_t *l_2404 = (void*)0; + int32_t ** const l_2403 = &l_2404; + int32_t ** const *l_2402 = &l_2403; + int32_t l_2416 = 0x0AC639BBL; + int32_t l_2418 = 0x6607F19AL; + int16_t l_2420 = 0xB848L; + int32_t l_2423 = 9L; + int32_t l_2424 = 0x69DA250BL; + int32_t l_2425 = 0x9A41C1ADL; + int32_t l_2426[5]; + int64_t *l_2433 = (void*)0; + int64_t **l_2432 = &l_2433; + int16_t l_2539 = 0xC40BL; + uint32_t l_2573[1][9][9] = {{{4294967290UL,0xA9032EA9L,4294967295UL,4294967295UL,4294967290UL,1UL,0xA9032EA9L,0xD6983E6CL,4294967295UL},{4294967289UL,0xF04A2676L,4294967295UL,4294967292UL,4294967286UL,3UL,4294967286UL,4294967292UL,4294967295UL},{4294967290UL,4294967290UL,0xA9032EA9L,4294967295UL,4294967295UL,4294967290UL,1UL,0xA9032EA9L,0xD6983E6CL},{1UL,4294967292UL,0x745DF2E2L,0x8FCAA842L,1UL,4294967292UL,7UL,4294967292UL,1UL},{0xD6983E6CL,0UL,0UL,0xD6983E6CL,4294967290UL,4294967295UL,0UL,8UL,0xD6983E6CL},{4294967289UL,0x8FCAA842L,4294967286UL,0x8FCAA842L,4294967289UL,3UL,0UL,0xF04A2676L,0UL},{8UL,4294967290UL,0x063998BAL,0x063998BAL,4294967290UL,8UL,1UL,0x063998BAL,8UL},{4294967295UL,3UL,1UL,0xF04A2676L,1UL,3UL,4294967295UL,0x8FCAA842L,4294967295UL},{0xD6983E6CL,1UL,4294967295UL,8UL,8UL,4294967295UL,1UL,0xD6983E6CL,8UL}}}; + int8_t l_2578 = 0x01L; + int32_t *l_2602[1]; + const uint32_t l_2620 = 4294967295UL; + int8_t l_2660 = 9L; + uint16_t l_2706 = 0xAFB5L; + struct S1 *l_2759[10]; + int64_t l_2765 = 0L; + uint32_t l_2806 = 0UL; + uint8_t l_2819 = 252UL; + uint32_t l_2853[2]; + uint64_t l_2882 = 18446744073709551615UL; + uint16_t *l_2883 = &g_919[1]; + uint16_t l_2886 = 0UL; + int64_t l_2893 = (-4L); + uint32_t l_2894 = 0x3CA8509AL; + uint64_t l_2895 = 0x4372EEFF82E9B829LL; + uint32_t l_2896 = 4294967290UL; + int8_t l_2897 = 0x95L; + uint8_t l_2899 = 247UL; + int16_t l_2922 = 0xB37CL; + uint8_t l_2923 = 0xFAL; + int8_t l_2993 = 1L; + int8_t l_2995 = 0x0BL; + uint16_t l_3008 = 0xADBBL; + int i, j, k; + for (i = 0; i < 9; i++) + l_2308[i] = &g_2270[0][3][3]; + for (i = 0; i < 5; i++) + l_2426[i] = 0L; + for (i = 0; i < 1; i++) + l_2602[i] = &g_56; + for (i = 0; i < 10; i++) + l_2759[i] = &l_2116; + for (i = 0; i < 2; i++) + l_2853[i] = 0x555DFCBCL; + if (func_2(l_6, (safe_mul_func_uint32_t_u_u(func_9(((*l_14) = g_13), (l_2123 = func_16(l_6, func_22((g_2111[0] = func_26((safe_mod_func_uint16_t_u_u(g_13, func_30(l_6))))), g_1247[0], (safe_lshift_func_uint16_t_u_u((safe_mul_func_int16_t_s_s(0x8FC5L, 0x9EDEL)), l_6))), l_2116, &g_171, g_1630)), g_1728), 0L)), g_1728)) + { /* block id: 1117 */ + int16_t l_2315 = 0x9C5AL; + struct S0 *l_2316 = &g_1043; + int8_t l_2333 = 8L; + int32_t l_2335 = 3L; + int32_t l_2336 = 0L; + int16_t l_2339[5][7][5] = {{{0x0B8FL,1L,0L,(-7L),0x56BEL},{(-9L),6L,0x8BAAL,(-7L),(-4L)},{0xAEE3L,0x8BAAL,1L,(-7L),0xD367L},{(-7L),0L,0L,(-7L),1L},{0xDCDAL,0L,6L,(-7L),1L},{0x0B8FL,1L,0L,(-7L),0x56BEL},{(-9L),6L,0x8BAAL,(-7L),(-4L)}},{{0xAEE3L,0x8BAAL,1L,(-7L),0xD367L},{(-7L),0L,0L,(-7L),1L},{0xDCDAL,0L,6L,(-7L),1L},{0x0B8FL,1L,0L,(-7L),0x56BEL},{(-9L),6L,0x8BAAL,(-7L),(-4L)},{0xAEE3L,0x8BAAL,1L,(-7L),0xD367L},{(-7L),0L,0L,(-7L),1L}},{{0xDCDAL,0L,6L,(-7L),1L},{0x0B8FL,1L,0L,(-7L),0x56BEL},{(-9L),6L,0x8BAAL,(-7L),(-4L)},{0xAEE3L,0x8BAAL,1L,(-7L),0xD367L},{(-7L),0L,0L,(-7L),1L},{0xDCDAL,0L,6L,(-7L),1L},{0x0B8FL,1L,0L,(-7L),0x56BEL}},{{(-9L),6L,0x8BAAL,(-7L),(-4L)},{0xAEE3L,0x8BAAL,1L,(-7L),0xD367L},{(-7L),0L,0L,(-7L),1L},{0xDCDAL,0L,6L,(-7L),1L},{0x0B8FL,1L,0L,(-7L),0x56BEL},{(-9L),6L,0x8BAAL,(-7L),(-4L)},{0xAEE3L,0x8BAAL,(-9L),0x24F8L,4L}},{{0x24F8L,(-7L),(-7L),0x24F8L,0L},{0x2D12L,0xAEE3L,0x0B8FL,0x24F8L,0xE1B8L},{(-6L),(-9L),0xAEE3L,0x24F8L,0x6F19L},{0L,0x0B8FL,0xDCDAL,0x24F8L,(-10L)},{0x4320L,0xDCDAL,(-9L),0x24F8L,4L},{0x24F8L,(-7L),(-7L),0x24F8L,0L},{0x2D12L,0xAEE3L,0x0B8FL,0x24F8L,0xE1B8L}}}; + int64_t l_2419 = 0x7160B4E7AAC79CABLL; + int32_t l_2422[5][6][6] = {{{1L,(-6L),1L,0xF073D7F3L,0x745FDAD9L,0x1C627C02L},{0x91DC3236L,0x5CB6FE52L,0xCFA25F1CL,1L,(-8L),(-6L)},{1L,4L,0x2B403E00L,0xEF722533L,(-1L),0x7B642941L},{0L,0xA0F4AB8AL,0xDB0E09ECL,0xF528355BL,0x12A3A5D0L,2L},{(-1L),(-1L),1L,0x5A4EB599L,1L,0x5A4EB599L},{0x59B2FF8AL,0L,0x59B2FF8AL,0L,1L,7L}},{{0xFA13B5C5L,0x0A54DC80L,0x669B4658L,0x1A302CC0L,(-1L),(-9L)},{0x745FDAD9L,(-1L),0xF528355BL,0x1A302CC0L,0x0E221C48L,0L},{0xFA13B5C5L,1L,0x1C627C02L,0L,(-8L),4L},{0x59B2FF8AL,0xFA13B5C5L,2L,0x5A4EB599L,(-5L),6L},{(-1L),0xB31F9C66L,(-3L),0xF528355BL,0xB3301B3EL,(-1L)},{0L,(-1L),1L,0xEF722533L,0xD723578DL,(-8L)}},{{1L,0x2B403E00L,0x59B2FF8AL,1L,7L,0xB3301B3EL},{0x91DC3236L,1L,0L,0xF073D7F3L,(-1L),0x0E221C48L},{1L,(-1L),0xB7C032DAL,4L,0x28FC56EBL,2L},{5L,0x0E221C48L,1L,0x611DE466L,0xEF722533L,(-6L)},{0x59B2FF8AL,0x55992B28L,(-1L),0xDF23C8F3L,1L,0x91DC3236L},{0x2B403E00L,0x0A54DC80L,(-1L),0x12A3A5D0L,0x12A3A5D0L,(-1L)}},{{(-5L),(-5L),0xF528355BL,0x28FC56EBL,0x9CC5A870L,0xDF23C8F3L},{0L,0L,1L,0L,7L,0xF528355BL},{0x1A302CC0L,0L,1L,(-6L),(-5L),0xDF23C8F3L},{(-9L),(-6L),0xF528355BL,4L,0x5A4EB599L,(-1L)},{4L,0x5A4EB599L,(-1L),(-1L),0x745FDAD9L,0x91DC3236L},{1L,0xFA13B5C5L,(-1L),0x5CB6FE52L,2L,(-6L)}},{{2L,1L,1L,1L,0x373E16EAL,2L},{0L,(-5L),0xB7C032DAL,0xDB0E09ECL,(-6L),0x1C627C02L},{0x28FC56EBL,0x31BCA2B7L,(-1L),0xF528355BL,(-1L),0L},{0xB31F9C66L,0xEF722533L,0x5A4EB599L,0L,0x9CC5A870L,(-1L)},{0x55B83F95L,1L,(-1L),0xB31F9C66L,0x611DE466L,0x12A3A5D0L},{1L,0L,0xB7C032DAL,0xB3301B3EL,0x1C627C02L,0L}}}; + int64_t *l_2431[4][4][9] = {{{&g_1499.f0,&l_2419,&g_232,&l_2419,&g_232,&l_2419,&g_1499.f0,&l_2419,&g_1499.f0},{(void*)0,(void*)0,&l_2419,(void*)0,(void*)0,(void*)0,&l_2419,(void*)0,(void*)0},{&l_2419,&l_2419,&g_232,&l_2419,&g_232,&g_232,&g_232,&l_2419,&g_232},{&g_232,&l_2419,&g_232,&g_232,&g_1499.f0,(void*)0,(void*)0,(void*)0,&g_1499.f0}},{{&l_2419,&g_232,&g_232,&l_2419,&l_2419,&g_1499.f0,&l_2419,&g_232,&l_2419},{(void*)0,(void*)0,&g_232,&g_232,&g_1499.f0,(void*)0,(void*)0,&l_2419,&g_232},{&g_1499.f0,&g_1499.f0,&g_232,&l_2419,&l_2419,&g_232,&g_1499.f0,&g_1499.f0,&l_2419},{&g_232,&g_232,&l_2419,&l_2419,&g_1499.f0,(void*)0,(void*)0,&g_1499.f0,&g_232}},{{&l_2419,&g_1499.f0,&g_232,&l_2419,&g_232,&l_2419,&l_2419,&g_232,&l_2419},{&l_2419,(void*)0,&l_2419,(void*)0,(void*)0,&g_1499.f0,(void*)0,(void*)0,&g_232},{&g_232,&g_1499.f0,&l_2419,&g_1499.f0,&g_232,&l_2419,&g_232,&l_2419,&l_2419},{&l_2419,&g_232,&g_232,(void*)0,&g_232,&g_232,&l_2419,&l_2419,&g_1499.f0}},{{&g_232,&g_1499.f0,&g_1499.f0,&l_2419,&l_2419,&l_2419,&g_1499.f0,&g_1499.f0,&g_232},{&g_232,(void*)0,(void*)0,&l_2419,&g_232,&g_1499.f0,&g_232,&l_2419,(void*)0},{&g_232,&g_232,&l_2419,&l_2419,&g_1499.f0,&l_2419,&g_232,&l_2419,&g_1499.f0},{&g_232,&l_2419,&g_232,&g_232,&l_2419,(void*)0,&l_2419,(void*)0,&l_2419}}}; + int64_t **l_2430 = &l_2431[0][2][8]; + int16_t l_2451 = 0xCFDFL; + uint64_t *l_2468 = &g_626[6][0][4]; + uint64_t l_2509 = 0xBCD9AEAA4ADF78E6LL; + int32_t l_2510 = 0xA81A0D94L; + int32_t l_2511[3]; + uint8_t l_2540 = 0UL; + const uint16_t *l_2556 = &g_275; + uint64_t l_2583 = 18446744073709551615UL; + volatile struct S0 *l_2593 = &g_1421; + int i, j, k; + for (i = 0; i < 3; i++) + l_2511[i] = 0xAAE6BFBCL; + for (l_2116.f0 = (-28); (l_2116.f0 <= 4); l_2116.f0 = safe_add_func_int16_t_s_s(l_2116.f0, 8)) + { /* block id: 1120 */ + union U2 * const l_2307 = &g_2286[1][2]; + union U2 **l_2309[5][10][3] = {{{(void*)0,(void*)0,&l_2308[6]},{(void*)0,&g_741,&l_2308[1]},{&l_2308[6],&g_741,&l_2308[0]},{(void*)0,&l_2308[3],&l_2308[3]},{&l_2308[3],(void*)0,(void*)0},{(void*)0,&l_2308[3],(void*)0},{&g_741,&l_2308[0],&l_2308[3]},{&l_2308[3],&l_2308[5],&l_2308[3]},{(void*)0,&g_741,(void*)0},{&l_2308[0],&g_741,&l_2308[1]}},{{(void*)0,(void*)0,(void*)0},{(void*)0,&g_741,&l_2308[0]},{(void*)0,&g_741,&l_2308[3]},{&l_2308[7],&l_2308[6],&l_2308[3]},{&g_741,(void*)0,&g_741},{&g_741,&g_741,&g_741},{&l_2308[3],&l_2308[3],&l_2308[3]},{&g_741,&g_741,&l_2308[3]},{&l_2308[3],&l_2308[3],&l_2308[0]},{(void*)0,&l_2308[3],(void*)0}},{{(void*)0,&l_2308[3],&l_2308[1]},{&l_2308[7],&l_2308[1],(void*)0},{(void*)0,&l_2308[0],&l_2308[3]},{&l_2308[0],&g_741,&l_2308[3]},{(void*)0,&l_2308[3],&g_741},{&l_2308[7],(void*)0,&l_2308[3]},{(void*)0,(void*)0,&g_741},{(void*)0,(void*)0,&l_2308[3]},{&l_2308[3],&g_741,(void*)0},{&g_741,&g_741,&l_2308[5]}},{{&l_2308[3],&g_741,(void*)0},{&g_741,&g_741,&l_2308[3]},{&g_741,&g_741,(void*)0},{&l_2308[7],&g_741,(void*)0},{(void*)0,(void*)0,&l_2308[0]},{(void*)0,(void*)0,&g_741},{(void*)0,(void*)0,&g_741},{&l_2308[0],&l_2308[3],&g_741},{(void*)0,&g_741,(void*)0},{&l_2308[3],&l_2308[0],&g_741}},{{&l_2308[6],&l_2308[1],&g_741},{(void*)0,&l_2308[3],&g_741},{&g_741,&l_2308[3],&l_2308[0]},{&g_741,&l_2308[3],(void*)0},{&l_2308[5],&g_741,(void*)0},{&l_2308[3],&l_2308[3],&l_2308[3]},{&l_2308[3],&g_741,(void*)0},{&l_2308[3],(void*)0,&l_2308[5]},{&l_2308[3],&l_2308[6],(void*)0},{&l_2308[5],&g_741,&l_2308[3]}}}; + int16_t *l_2317 = (void*)0; + int32_t l_2318 = (-7L); + int32_t *****l_2337 = &g_1228; + struct S1 *l_2361 = &g_334[3][3]; + int32_t l_2417 = 0x534EDEDAL; + int32_t l_2421[2][4] = {{0x62A763A4L,0x62A763A4L,0x62A763A4L,0x62A763A4L},{0x62A763A4L,0x62A763A4L,0x62A763A4L,0x62A763A4L}}; + uint16_t l_2427 = 0xA5F4L; + int64_t ** const l_2434 = &l_2431[3][1][4]; + int32_t l_2437[6] = {(-1L),(-1L),(-1L),(-1L),(-1L),(-1L)}; + int32_t l_2452 = 0xBE9C3BF5L; + uint32_t l_2512 = 0xF343B5F4L; + uint32_t l_2522 = 4UL; + uint8_t l_2525 = 0xBEL; + uint32_t l_2528[8][3][1] = {{{0xBC5624AAL},{0x49396FF2L},{0xBC5624AAL}},{{0x037DA4EEL},{0xBC5624AAL},{0x49396FF2L}},{{0xBC5624AAL},{0x037DA4EEL},{0xBC5624AAL}},{{0x49396FF2L},{0xBC5624AAL},{0x037DA4EEL}},{{0xBC5624AAL},{0x49396FF2L},{0xBC5624AAL}},{{0x037DA4EEL},{0xBC5624AAL},{0x49396FF2L}},{{0xBC5624AAL},{0x037DA4EEL},{0xBC5624AAL}},{{0x49396FF2L},{0xBC5624AAL},{0x037DA4EEL}}}; + int i, j, k; + if ((((l_2116.f0 > (safe_rshift_func_int8_t_s_s(((((((-9L) == (((*g_1032) |= (l_2307 != ((*g_1084) = l_2308[3]))) && (safe_lshift_func_int32_t_s_u(((safe_mul_func_uint8_t_u_u((~l_2315), (((*g_1337) = (**g_1336)) == l_2316))) ^ l_6), 1)))) , (l_2318 = g_2293)) , (*g_49)) , g_700[0][0][2]) , l_2319), 0))) && l_2315) && 0x3E49A3ECL)) + { /* block id: 1125 */ + uint64_t l_2320 = 18446744073709551615UL; + int32_t *l_2334 = &g_809[0]; + uint16_t *l_2338 = &g_919[8]; + union U3 ***l_2367 = (void*)0; + union U3 ** const **l_2377 = &g_2375; + int32_t ***l_2385[6] = {&g_790,&g_790,&g_790,&g_790,&g_790,&g_790}; + int i; + if ((l_2320 && (safe_lshift_func_uint16_t_u_s((safe_add_func_int8_t_s_s(((*g_1032) |= (safe_lshift_func_int8_t_s_s((safe_add_func_uint16_t_u_u(0x3EF5L, ((*l_2338) = (safe_mul_func_int16_t_s_s(((((*l_2334) = (safe_mod_func_uint32_t_u_u(l_2333, g_75))) < (l_2335 = (l_2318 = l_2333))) == ((l_2336 = 0x215B2C1F8F721435LL) >= (g_2276.f0 != (g_937 = l_2315)))), ((void*)0 != l_2337)))))), 0))), l_2339[3][1][3])), l_6)))) + { /* block id: 1133 */ + (*g_790) = &l_2123; + } + else + { /* block id: 1135 */ + union U3 *l_2348 = (void*)0; + union U3 **l_2347[9] = {&l_2348,&l_2348,&l_2348,&l_2348,&l_2348,&l_2348,&l_2348,&l_2348,&l_2348}; + int64_t l_2351[5][5][1] = {{{0x950AC346A87F3317LL},{1L},{0x86FDFC8F590AF42DLL},{1L},{0x950AC346A87F3317LL}},{{1L},{0x86FDFC8F590AF42DLL},{1L},{0x950AC346A87F3317LL},{1L}},{{0x86FDFC8F590AF42DLL},{1L},{0x950AC346A87F3317LL},{1L},{0x86FDFC8F590AF42DLL}},{{1L},{0x950AC346A87F3317LL},{1L},{0x86FDFC8F590AF42DLL},{1L}},{{0x950AC346A87F3317LL},{1L},{0x86FDFC8F590AF42DLL},{1L},{0x950AC346A87F3317LL}}}; + struct S1 *l_2360 = &g_334[0][0]; + int64_t l_2362 = 0x4D38C07B383B7C05LL; + union U3 ** const ***l_2376[3]; + int64_t *l_2386 = &g_1499.f0; + int i, j, k; + for (i = 0; i < 3; i++) + l_2376[i] = &g_2374[6]; + l_2123 ^= l_6; + (*l_2334) = (safe_unary_minus_func_uint8_t_u((safe_add_func_int32_t_s_s((((safe_lshift_func_uint32_t_u_u((l_2351[0][0][0] = (safe_add_func_int16_t_s_s(g_13, ((g_153 > (l_6 != 65529UL)) <= ((g_2349 = ((**g_1679) = (*g_1648))) != (g_2350 , &g_2078)))))), 22)) > (safe_div_func_int32_t_s_s((safe_add_func_uint16_t_u_u((safe_add_func_uint16_t_u_u((((safe_sub_func_uint32_t_u_u((((*g_2202) || (((l_2360 == l_2361) , l_2362) , 1L)) , g_809[0]), (-1L))) & 4294967295UL) || g_906), (*l_2334))), l_2335)), (*l_2334)))) != 0UL), l_2333)))); + (*l_2334) = ((safe_mul_func_int64_t_s_s((safe_sub_func_int64_t_s_s(((*l_2386) ^= (((void*)0 == l_2367) , (((((*g_1032) |= (safe_lshift_func_uint64_t_u_u(((safe_rshift_func_int8_t_s_u(l_2339[2][0][3], (((l_2377 = g_2374[2]) != (g_2378 = &l_2367)) & 0x30FAE559L))) <= ((l_2339[0][4][1] , (safe_rshift_func_int64_t_s_s((((l_2385[1] == l_2385[1]) >= l_2362) != 0x01L), (*g_2202)))) >= (*g_2202))), l_6))) | 0x54L) , l_2116.f0) && l_2362))), 0x9FC28B1F27604427LL)), (*g_2202))) > 0x96A5C97E8F174753LL); + } + } + else + { /* block id: 1147 */ + uint16_t l_2409 = 9UL; + int32_t l_2410 = 0x62083163L; + int32_t *l_2411 = &l_2336; + int32_t *l_2412 = &l_2318; + int32_t *l_2413 = &l_2318; + int32_t *l_2414 = &g_809[0]; + int32_t *l_2415[3]; + uint8_t *l_2446 = &g_217[4][4]; + uint64_t l_2495 = 9UL; + uint32_t l_2507 = 0x4F77C9F1L; + int i; + for (i = 0; i < 3; i++) + l_2415[i] = &l_2123; + for (g_2285.f2 = 0; (g_2285.f2 >= 0); g_2285.f2 -= 1) + { /* block id: 1150 */ + int32_t ***l_2405[4][2] = {{(void*)0,(void*)0},{(void*)0,(void*)0},{(void*)0,(void*)0},{(void*)0,(void*)0}}; + int i, j; + for (g_2278.f2 = 2; (g_2278.f2 <= 7); g_2278.f2 += 1) + { /* block id: 1153 */ + const int8_t *l_2394 = &l_2333; + int32_t ** const *l_2401 = &g_790; + int i; + l_2410 = (((safe_add_func_uint64_t_u_u((safe_lshift_func_int32_t_s_u(((-1L) != (safe_add_func_int64_t_s_s(((g_2393 , (*g_1080)) != l_2394), ((safe_div_func_int8_t_s_s((safe_mul_func_uint16_t_u_u(((l_2402 = l_2401) != l_2405[2][0]), g_763[0])), (*g_1032))) & ((~(safe_mod_func_int16_t_s_s(l_2409, g_763[0]))) != 0x0DFCL))))), g_2201)), l_2409)) > g_763[0]) && g_1704[4].f0); + (**g_2375) = (void*)0; + return g_2286[4][2].f0; + } + } + l_2427--; + if ((((l_2432 = l_2430) == l_2434) != (safe_sub_func_int64_t_s_s(l_2437[4], (((*g_2202) <= (safe_add_func_uint32_t_u_u(0x6CCCB29BL, ((safe_mod_func_int16_t_s_s(((l_2335 = (((safe_div_func_uint8_t_u_u(((((*l_2446)++) > ((((*g_1691) , (0x4D76207D9FB0953ALL && (safe_lshift_func_uint16_t_u_s(((g_1057 = ((-1L) != g_809[0])) != l_2451), 6)))) || g_1728) == 0L)) ^ 0L), l_2437[2])) < 0x26A4AF0CL) ^ l_2421[1][1])) > g_158), (*l_2413))) , 3UL)))) && 0xB857579238D5B6C9LL))))) + { /* block id: 1165 */ + for (l_2425 = 7; (l_2425 >= 1); l_2425 -= 1) + { /* block id: 1168 */ + (*l_2414) = 0x66EAB57CL; + return g_94[5]; + } + if (l_2452) + break; + } + else + { /* block id: 1173 */ + int16_t l_2453 = 0x9F4BL; + int32_t l_2454 = 1L; + int32_t l_2455 = 0xA1AECC36L; + int32_t l_2456 = 1L; + uint32_t l_2457 = 4294967295UL; + int16_t *l_2479 = &l_2420; + int32_t l_2480 = 0xB4E6CA02L; + int32_t l_2508 = 0xD0B9F633L; + l_2457++; + if ((g_15[2] != (safe_mod_func_uint16_t_u_u((*l_2413), (safe_add_func_uint64_t_u_u((((+l_2456) || (safe_mul_func_int8_t_s_s(((*g_1032) = (g_2467 , ((g_2111[0] = &g_50[1][2][1]) == (l_2468 = &g_171)))), (safe_lshift_func_int8_t_s_u((safe_rshift_func_uint32_t_u_s(l_2451, 25)), 6))))) ^ l_2455), (safe_rshift_func_int16_t_s_s((g_937 = ((((*l_2446) = (safe_add_func_int32_t_s_s((l_2336 = (((safe_mod_func_int16_t_s_s(((*l_2479) = g_919[4]), l_2480)) & 0x897C825FL) | 4294967290UL)), g_1247[6]))) || 0L) >= (-1L))), g_63.f0)))))))) + { /* block id: 1182 */ + union U3 *** const *l_2487 = &g_2379[4]; + int32_t l_2504 = 0xE1A5A078L; + (*l_2412) = ((safe_mod_func_int8_t_s_s((((l_2457 && ((*g_2202) >= ((void*)0 != (*g_1905)))) && (-1L)) > (((safe_mod_func_int64_t_s_s(((*g_1481) , ((l_2487 == &g_1679) && ((void*)0 != &l_2116))), (*g_2202))) < 4L) || g_94[1])), (*g_1032))) | (*g_1032)); + (*l_2412) ^= (safe_div_func_uint16_t_u_u(((safe_mul_func_uint16_t_u_u(0x7A5DL, g_809[0])) <= (((*g_1032) = ((+(((l_2454 >= ((l_2335 = l_2495) && ((0L & (safe_add_func_uint16_t_u_u(((safe_add_func_int8_t_s_s((((safe_lshift_func_uint16_t_u_s(0xFCECL, 14)) , (safe_rshift_func_uint16_t_u_s(((l_2339[0][0][4] , ((l_2504 , (safe_rshift_func_uint64_t_u_u(0x9E31B0FFAECFF908LL, (*g_49)))) & l_2507)) > (*g_1032)), 1))) & g_196), 0x54L)) < l_2452), l_2456))) , 8L))) > 0x25E4D65C08A14A3ALL) <= l_2508)) & l_2336)) <= l_2509)), l_2510)); + } + else + { /* block id: 1187 */ + return g_128[1][3][0].f0; + } + l_2512--; + } + } + for (l_2512 = 0; (l_2512 != 22); l_2512++) + { /* block id: 1195 */ + int32_t l_2518 = 0xD13DD1C4L; + int32_t *l_2519 = &l_2318; + int32_t *l_2520 = &l_2421[0][3]; + int32_t *l_2521[8][4] = {{&l_2318,&l_2318,&l_2318,&l_2318},{&l_2318,&l_2318,&l_2318,&l_2318},{&l_2318,&l_2318,&l_2318,&l_2318},{&l_2318,&l_2318,&l_2318,&l_2318},{&l_2318,&l_2318,&l_2318,&l_2318},{&l_2318,&l_2318,&l_2318,&l_2318},{&l_2318,&l_2318,&l_2318,&l_2318},{&l_2318,&l_2318,&l_2318,&l_2318}}; + int i, j; + for (l_2335 = 8; (l_2335 >= 2); l_2335 -= 1) + { /* block id: 1198 */ + int8_t l_2517[9] = {(-7L),(-1L),(-7L),(-7L),(-1L),(-7L),(-7L),(-1L),(-7L)}; + int i; + if (l_2517[2]) + break; + if (l_2451) + break; + return l_2517[2]; + } + l_2522++; + ++l_2525; + } + l_2528[6][2][0] &= ((*g_1336) == (void*)0); + } + (*l_2403) = &l_2422[1][1][5]; + for (g_57 = 0; (g_57 <= 1); g_57 += 1) + { /* block id: 1211 */ + int32_t l_2529 = 0x5BD42B83L; + int32_t l_2579 = 0xC573E843L; + int32_t l_2581[3]; + struct S1 l_2591 = {0x8513EE8BL}; + int i; + for (i = 0; i < 3; i++) + l_2581[i] = 6L; + if (l_2529) + break; + for (g_148 = 1; (g_148 >= 0); g_148 -= 1) + { /* block id: 1215 */ + int32_t l_2536 = (-1L); + int32_t *l_2537 = &l_2336; + int32_t *l_2538[1][6]; + int i, j; + for (i = 0; i < 1; i++) + { + for (j = 0; j < 6; j++) + l_2538[i][j] = (void*)0; + } + for (l_2510 = 3; (l_2510 >= 0); l_2510 -= 1) + { /* block id: 1218 */ + const int32_t *l_2532 = &l_2425; + int i, j, k; + if (g_626[(g_148 + 7)][(l_2510 + 1)][(l_2510 + 1)]) + { /* block id: 1219 */ + const int32_t *l_2530 = &l_2510; + const int32_t **l_2531[6] = {(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0}; + int i; + l_2532 = l_2530; + } + else + { /* block id: 1221 */ + const int32_t **l_2534 = &g_226; + (*l_2534) = (g_2533 , l_2532); + } + } + l_2540++; + return g_217[4][7]; + } + for (g_2271.f2 = 0; (g_2271.f2 <= 1); g_2271.f2 += 1) + { /* block id: 1230 */ + int32_t l_2570 = 0L; + int32_t *l_2574 = &l_2423; + int32_t *l_2575 = (void*)0; + int32_t *l_2576 = &l_2425; + int32_t *l_2577[10] = {(void*)0,&l_2529,(void*)0,(void*)0,&l_2529,(void*)0,(void*)0,&l_2529,(void*)0,(void*)0}; + int16_t l_2580[1][1][10] = {{{(-1L),(-1L),0xC950L,(-1L),(-1L),0xC950L,(-1L),(-1L),0xC950L,(-1L)}}}; + union U3 ** const ***l_2589 = &g_2374[6]; + int i, j, k; + for (g_171 = 0; (g_171 <= 1); g_171 += 1) + { /* block id: 1233 */ + uint32_t * const l_2563 = &g_1663[7][0][1]; + uint32_t * const *l_2562 = &l_2563; + int i, j, k; + if ((g_626[(g_171 + 7)][(g_171 + 2)][(g_57 + 2)] < ((&g_2203 == (void*)0) || (~g_626[(g_171 + 7)][(g_171 + 2)][(g_57 + 2)])))) + { /* block id: 1234 */ + uint16_t l_2544[10] = {0x0E84L,0x0E84L,5UL,0xC787L,5UL,0x0E84L,0x0E84L,5UL,0xC787L,5UL}; + int i; + return l_2544[2]; + } + else + { /* block id: 1236 */ + int32_t l_2547 = 0x45CEBF87L; + int8_t *l_2548 = &l_2333; + int32_t *l_2557 = &l_2426[2]; + int i, j, k; + (*l_2557) &= (safe_mul_func_uint64_t_u_u((((*l_2548) ^= ((*g_1032) = (0xE2L || l_2547))) | (safe_add_func_uint8_t_u_u(((*g_2202) , (safe_add_func_int64_t_s_s((g_1499.f0 = (g_232 = ((*g_2202) , (*l_2404)))), (safe_add_func_uint16_t_u_u((safe_unary_minus_func_int8_t_s(((void*)0 == l_2556))), (((*l_2404) >= (l_2510 > l_2335)) <= (**l_2403))))))), g_1209[0].f0))), 0x4EF26BD19921E703LL)); + (*g_2558) = g_128[(g_171 + 4)][(g_2271.f2 + 2)][g_171]; + } + for (g_836.f0 = 1; (g_836.f0 >= 0); g_836.f0 -= 1) + { /* block id: 1246 */ + uint16_t l_2559 = 0x0636L; + (*l_2404) = (l_2559 , (l_2333 & ((safe_mul_func_int32_t_s_s((((*g_49) >= ((l_2562 != (void*)0) , (~((0L & (+((safe_unary_minus_func_uint16_t_u((((0x051CL && (!(safe_div_func_int16_t_s_s(((l_2570 >= (safe_mul_func_uint16_t_u_u(l_2529, 0x05B2L))) || 0x8D3FL), l_2570)))) > l_2529) < g_626[(g_171 + 7)][(g_171 + 2)][(g_57 + 2)]))) & l_2511[0]))) | 1L)))) , l_2570), l_2573[0][7][8])) > l_2336))); + } + } + ++l_2583; + (*l_2574) = ((*g_292) = (safe_mul_func_int16_t_s_s(0L, (g_700[0][0][2].f0 != l_2509)))); + for (l_2424 = 4; (l_2424 >= 1); l_2424 -= 1) + { /* block id: 1255 */ + for (l_2333 = 1; (l_2333 >= 0); l_2333 -= 1) + { /* block id: 1258 */ + struct S0 *l_2588 = (void*)0; + int i, j, k; + (*l_2574) &= ((***l_2402) |= g_626[g_57][l_2424][(g_2271.f2 + 1)]); + l_2588 = ((***g_1335) = l_2316); + } + (***l_2402) |= 0xD6DA644EL; + (**l_2403) = (&g_2374[2] != (g_2590 = l_2589)); + l_2591 = (****g_390); + } + } + } + (*l_2593) = g_2592; + } + else + { /* block id: 1272 */ + int32_t *l_2594 = &g_56; + int32_t *l_2595 = (void*)0; + int32_t *l_2596[7][9][4] = {{{&l_2416,&g_809[0],(void*)0,&l_2123},{&l_2416,&l_2416,&g_809[0],&g_809[0]},{&g_809[0],(void*)0,&g_56,&g_809[0]},{&l_2416,&g_809[0],&l_2123,&l_2418},{(void*)0,&l_2418,&g_809[0],&l_2425},{&g_809[0],&l_2425,&l_2418,&l_2426[2]},{&l_2424,&l_2425,&l_2424,&l_2418},{&g_809[0],&l_2418,&l_2426[2],&g_809[0]},{&l_2424,(void*)0,&l_2423,&l_2418}},{{&g_56,&l_2418,&l_2423,&l_2123},{&l_2424,&l_2418,&l_2426[2],&l_2425},{&g_809[0],&g_75,&l_2424,&g_809[0]},{&l_2424,&g_809[0],&l_2418,(void*)0},{&g_809[0],(void*)0,&g_809[0],&l_2418},{(void*)0,&g_75,&l_2123,&l_2426[2]},{&l_2416,&l_2424,&g_56,&l_2123},{&g_809[0],&l_2425,&g_809[0],(void*)0},{&l_2416,(void*)0,(void*)0,&l_2416}},{{&l_2416,(void*)0,&l_2423,&l_2418},{&l_2418,&l_2416,&g_809[0],&l_2425},{&l_2418,&l_2425,&g_56,&l_2425},{&l_2424,&l_2416,(void*)0,&l_2418},{(void*)0,&l_2424,&g_809[0],&l_2423},{&g_56,&g_809[0],&l_2123,&l_2424},{&l_2426[0],&l_2425,&l_2123,&l_2123},{&l_2418,(void*)0,&g_809[0],&l_2425},{&l_2423,&g_809[0],&g_809[0],&l_2123}},{{&g_809[0],&l_2424,&g_809[0],&g_56},{(void*)0,(void*)0,&l_2418,(void*)0},{(void*)0,&g_809[0],&l_2123,(void*)0},{&g_809[0],&l_2418,(void*)0,&l_2123},{(void*)0,&l_2416,&l_2426[2],&l_2123},{(void*)0,&g_809[0],(void*)0,(void*)0},{&g_809[0],&l_2123,&l_2123,(void*)0},{(void*)0,&l_2425,&l_2418,&l_2425},{(void*)0,&l_2426[2],&g_809[0],&g_75}},{{&g_809[0],&l_2416,&g_809[0],(void*)0},{&l_2423,(void*)0,&g_809[0],&l_2123},{&l_2418,&g_809[0],&l_2123,(void*)0},{&l_2426[0],&l_2425,&l_2123,&l_2123},{&g_56,&g_56,&g_809[0],&g_75},{(void*)0,&g_809[0],&g_56,&l_2424},{&g_809[0],&l_2123,&l_2426[0],&g_56},{&l_2418,&l_2123,&l_2418,&l_2424},{&l_2123,&g_809[0],&l_2424,&g_75}},{{&g_809[0],&g_56,&g_809[0],&l_2123},{&l_2423,&l_2425,&l_2426[2],(void*)0},{&l_2123,&g_809[0],&l_2426[0],&l_2123},{&g_809[0],(void*)0,&l_2123,(void*)0},{&l_2424,&l_2416,&l_2418,&g_75},{&g_56,&l_2426[2],(void*)0,&l_2425},{&g_809[0],&l_2425,&g_809[0],(void*)0},{&l_2123,&l_2123,&g_809[0],(void*)0},{(void*)0,&g_809[0],&l_2424,&l_2123}},{{&l_2426[0],&l_2416,&l_2424,&l_2123},{(void*)0,&l_2418,&g_809[0],(void*)0},{&l_2123,&g_809[0],&g_809[0],(void*)0},{&g_809[0],(void*)0,(void*)0,&g_56},{&g_56,&l_2424,&l_2418,&l_2123},{&l_2424,&g_809[0],&l_2123,&l_2425},{&g_809[0],(void*)0,&l_2426[0],&l_2123},{&l_2123,&l_2425,&l_2426[2],&l_2424},{&l_2423,&g_809[0],&g_809[0],&l_2423}}}; + int16_t l_2597 = 1L; + uint16_t l_2598[3]; + int8_t **l_2736 = (void*)0; + int8_t ***l_2735 = &l_2736; + int32_t *l_2826 = &g_1630; + int32_t **l_2825 = &l_2826; + int32_t ***l_2824 = &l_2825; + int8_t l_2852 = 0xBFL; + uint32_t l_2875 = 0UL; + int i, j, k; + for (i = 0; i < 3; i++) + l_2598[i] = 0UL; + l_2598[0]--; + (*l_2403) = l_2594; + for (g_2278.f2 = 0; (g_2278.f2 <= 2); g_2278.f2 += 1) + { /* block id: 1277 */ + int32_t l_2601 = 6L; + int32_t l_2625[3]; + union U2 **l_2631 = &l_2308[7]; + uint32_t l_2677[7] = {4294967293UL,4294967295UL,4294967293UL,4294967293UL,4294967295UL,4294967293UL,4294967293UL}; + uint16_t l_2687 = 1UL; + union U3 ** const **l_2697[6][1][10] = {{{(void*)0,(void*)0,&g_2375,&g_2375,&g_2375,(void*)0,&g_2375,&g_2375,&g_2375,(void*)0}},{{&g_2375,&g_2375,&g_2375,&g_2375,&g_2375,(void*)0,&g_2375,(void*)0,&g_2375,&g_2375}},{{&g_2375,&g_2375,&g_2375,&g_2375,&g_2375,&g_2375,&g_2375,&g_2375,&g_2375,(void*)0}},{{&g_2375,&g_2375,&g_2375,(void*)0,(void*)0,&g_2375,(void*)0,(void*)0,&g_2375,&g_2375}},{{&g_2375,&g_2375,&g_2375,(void*)0,&g_2375,(void*)0,&g_2375,&g_2375,(void*)0,&g_2375}},{{(void*)0,&g_2375,&g_2375,(void*)0,&g_2375,(void*)0,&g_2375,&g_2375,&g_2375,&g_2375}}}; + int i, j, k; + for (i = 0; i < 3; i++) + l_2625[i] = 0xA9D41839L; + if (l_2601) + break; + for (g_56 = 2; (g_56 >= 0); g_56 -= 1) + { /* block id: 1281 */ + uint16_t l_2617 = 0x1DB8L; + int32_t l_2626 = 0x46F0A65FL; + uint64_t l_2635[2][4][10] = {{{0xC9357B0C2D237A9FLL,0x815CAE4B2D5BB77ALL,18446744073709551613UL,0x3CA4379F48632A2DLL,18446744073709551615UL,18446744073709551613UL,0x5DD66B3D4D4E18E9LL,18446744073709551613UL,18446744073709551615UL,0x3CA4379F48632A2DLL},{1UL,0xC9357B0C2D237A9FLL,1UL,0xF4D85337F4417DB7LL,0x41C778ED3A033020LL,0x6E83B6E29CF21EE8LL,18446744073709551615UL,0x4F3B0785C3C889FELL,0x3CA4379F48632A2DLL,2UL},{2UL,0x6E83B6E29CF21EE8LL,0x815CAE4B2D5BB77ALL,0x5DD66B3D4D4E18E9LL,0x4F3B0785C3C889FELL,0xF39D25F002D8A8B2LL,0xF39D25F002D8A8B2LL,0x4F3B0785C3C889FELL,0x5DD66B3D4D4E18E9LL,0x815CAE4B2D5BB77ALL},{18446744073709551613UL,18446744073709551613UL,1UL,0xFD87A9D2D267422ELL,0x3CA4379F48632A2DLL,0xC9357B0C2D237A9FLL,18446744073709551615UL,18446744073709551613UL,0x4F3B0785C3C889FELL,7UL}},{{0xF39D25F002D8A8B2LL,18446744073709551615UL,18446744073709551613UL,1UL,18446744073709551615UL,0x41C778ED3A033020LL,18446744073709551615UL,1UL,18446744073709551613UL,18446744073709551615UL},{0x4F3B0785C3C889FELL,18446744073709551613UL,0x5DD66B3D4D4E18E9LL,2UL,7UL,0xF4D85337F4417DB7LL,0xF39D25F002D8A8B2LL,0x41C778ED3A033020LL,0xFD87A9D2D267422ELL,18446744073709551613UL},{0xFD87A9D2D267422ELL,0x6E83B6E29CF21EE8LL,18446744073709551615UL,18446744073709551615UL,0xF4D85337F4417DB7LL,0xF4D85337F4417DB7LL,18446744073709551615UL,18446744073709551615UL,0x6E83B6E29CF21EE8LL,0xFD87A9D2D267422ELL},{0x4F3B0785C3C889FELL,0xC9357B0C2D237A9FLL,0xF4D85337F4417DB7LL,18446744073709551615UL,18446744073709551613UL,0x41C778ED3A033020LL,0x5DD66B3D4D4E18E9LL,0x6E83B6E29CF21EE8LL,1UL,0UL}}}; + const int32_t *l_2638 = &g_1630; + const int32_t **l_2637 = &l_2638; + struct S1 *****l_2678 = &g_390; + int8_t l_2692 = 5L; + union U3 * const **l_2696 = (void*)0; + union U3 * const ***l_2695[6] = {&l_2696,&l_2696,&l_2696,&l_2696,&l_2696,&l_2696}; + int16_t l_2720 = (-6L); + int i, j, k; + for (l_2601 = 0; (l_2601 <= 2); l_2601 += 1) + { /* block id: 1284 */ + (**g_109) = l_2116; + } + for (l_2597 = 0; (l_2597 <= 2); l_2597 += 1) + { /* block id: 1289 */ + int32_t l_2603 = 6L; + int32_t l_2622[8] = {(-1L),(-4L),(-1L),(-1L),(-4L),(-1L),(-1L),(-4L)}; + int32_t l_2636 = 0L; + int i; + (**l_2402) = l_2602[0]; + for (g_275 = 0; (g_275 <= 0); g_275 += 1) + { /* block id: 1293 */ + int i; + if (g_763[g_275]) + break; + } + if (l_2603) + { /* block id: 1296 */ + const uint8_t l_2608 = 0x55L; + const struct S1 l_2609 = {5UL}; + uint8_t *l_2610 = &g_217[3][9]; + int32_t l_2623[3][7][2] = {{{0x3FD2B59BL,(-1L)},{0x3FD2B59BL,0x3FD2B59BL},{(-1L),0x3FD2B59BL},{0x3FD2B59BL,(-1L)},{0x3FD2B59BL,0x3FD2B59BL},{(-1L),0x3FD2B59BL},{0x3FD2B59BL,(-1L)}},{{0x3FD2B59BL,0x3FD2B59BL},{(-1L),0x3FD2B59BL},{0x3FD2B59BL,(-1L)},{0x3FD2B59BL,0x3FD2B59BL},{(-1L),0x3FD2B59BL},{0x3FD2B59BL,(-1L)},{0x3FD2B59BL,0x3FD2B59BL}},{{(-1L),0x3FD2B59BL},{0x3FD2B59BL,(-1L)},{0x3FD2B59BL,0x3FD2B59BL},{(-1L),0x3FD2B59BL},{0x3FD2B59BL,(-1L)},{0x3FD2B59BL,0x3FD2B59BL},{(-1L),0x3FD2B59BL}}}; + int i, j, k; + l_2623[1][1][0] = ((g_1057 = ((++(*l_14)) <= l_2601)) , (((safe_add_func_uint16_t_u_u(1UL, l_2608)) == ((l_2609 , (--(*l_2610))) || (l_2601 , ((g_836 , (((((safe_div_func_int16_t_s_s((((safe_lshift_func_uint16_t_u_s(l_2617, 1)) | (safe_lshift_func_uint32_t_u_s((***l_2402), 3))) ^ ((*l_2594) >= g_1454[4].f0)), l_2620)) && (*g_1081)) <= (*g_2202)) || g_2621) == l_2608)) || 1L)))) , l_2622[2])); + } + else + { /* block id: 1301 */ + uint16_t *l_2624[2]; + union U2 ***l_2632 = (void*)0; + union U2 **l_2634 = &l_2308[2]; + union U2 ***l_2633 = &l_2634; + const int32_t l_2657 = 2L; + int i; + for (i = 0; i < 2; i++) + l_2624[i] = &g_919[6]; + l_2636 = (l_2635[1][1][8] ^= (((l_2625[0] = l_2601) , ((l_2626 ^= ((-1L) || (*g_2202))) < (**l_2403))) != ((g_334[3][3].f0 ^= l_2601) , (((safe_lshift_func_uint16_t_u_u(((safe_mul_func_int64_t_s_s((l_2631 != ((*l_2633) = (void*)0)), (*g_2202))) >= ((*g_1032) ^= (0x95L != g_161[1].f0))), 5)) , (**g_1080)) || 0xEAL)))); + (*g_2639) = l_2637; + l_2636 &= (safe_mul_func_int64_t_s_s((0xD2C42AD365A8F043LL == (l_2603 < ((safe_lshift_func_int8_t_s_s((+0x7E5E2E61L), (!(~(*g_2202))))) & (safe_add_func_uint16_t_u_u((l_2625[0] >= ((0x4B208B3FL <= (safe_add_func_int64_t_s_s((-1L), ((((safe_mod_func_uint64_t_u_u(((void*)0 != (*g_1082)), (*g_2202))) , (*g_1032)) & 1UL) | 0xC5L)))) & l_2622[0])), l_2657))))), 1L)); + l_2636 = (safe_mod_func_int32_t_s_s((l_2635[0][0][1] <= l_2660), 4294967295UL)); + } + } + for (g_158 = 0; (g_158 <= 2); g_158 += 1) + { /* block id: 1316 */ + const int64_t l_2661[2][8][9] = {{{0L,6L,0L,0x17C4AC356D38DFD3LL,3L,0xE80EB6E8E811918DLL,0xDBAD3398FC4BD163LL,0xB2525D5E1277629ALL,2L},{(-3L),0x5E798682BB9DA2A7LL,(-4L),0x2E9ABF09A7682818LL,(-1L),0xF60DF0079A24FAF0LL,0x5E798682BB9DA2A7LL,7L,6L},{3L,0x0131E6AF7225F83CLL,0xDC71F302CF7E3063LL,0L,0xB2525D5E1277629ALL,0L,0xDC71F302CF7E3063LL,0x0131E6AF7225F83CLL,3L},{0x2E9ABF09A7682818LL,0xFA4F1D5326D52B07LL,0L,(-4L),6L,0x0A8AC195DED6EBDFLL,(-3L),0x8E1D203FF76AFE09LL,0L},{0xE80EB6E8E811918DLL,0L,0xF1ACFB5A11DEE868LL,0x0131E6AF7225F83CLL,(-1L),3L,3L,(-4L),0L},{0x2E9ABF09A7682818LL,6L,(-3L),0L,0xFFF6C8A73411CAE5LL,9L,0xFFF6C8A73411CAE5LL,0L,(-3L)},{3L,3L,2L,0x78674453534AEBC7LL,0xE80EB6E8E811918DLL,0xFBDB1F655167C439LL,0L,0xB2525D5E1277629ALL,0x412FF9E80E018039LL},{0xFFF6C8A73411CAE5LL,0L,0xA80E7D0E70897334LL,0x5AE4527627E83AECLL,0xB5C5BB1E1E28E535LL,(-4L),0xFA4F1D5326D52B07LL,7L,0xFE86D434A637A85CLL}},{{0x0131E6AF7225F83CLL,0L,2L,0L,0x17C4AC356D38DFD3LL,(-3L),(-4L),(-3L),0x17C4AC356D38DFD3LL},{(-1L),(-3L),(-3L),(-1L),(-1L),0xA80E7D0E70897334LL,9L,0L,0x5E798682BB9DA2A7LL},{0xFBDB1F655167C439LL,0x412FF9E80E018039LL,0xF1ACFB5A11DEE868LL,0xCE20CDA666856F23LL,2L,0xDC71F302CF7E3063LL,6L,0L,(-3L)},{0x0A8AC195DED6EBDFLL,0xFE86D434A637A85CLL,0L,0x5E798682BB9DA2A7LL,(-1L),0L,0xF60DF0079A24FAF0LL,0x5275535D5C0F382FLL,0xF60DF0079A24FAF0LL},{0L,0x17C4AC356D38DFD3LL,0xDC71F302CF7E3063LL,0xDC71F302CF7E3063LL,0x17C4AC356D38DFD3LL,0L,3L,(-4L),0xCE20CDA666856F23LL},{0L,0x5E798682BB9DA2A7LL,9L,(-3L),0xB5C5BB1E1E28E535LL,0L,7L,0xF60DF0079A24FAF0LL,0x0A8AC195DED6EBDFLL},{2L,(-3L),(-1L),3L,0xE80EB6E8E811918DLL,6L,3L,0xDBAD3398FC4BD163LL,0xE28176496743DD51LL},{0xFE86D434A637A85CLL,0xF60DF0079A24FAF0LL,3L,0xFFF6C8A73411CAE5LL,0xFFF6C8A73411CAE5LL,3L,0xF60DF0079A24FAF0LL,0xFE86D434A637A85CLL,0xA80E7D0E70897334LL}}}; + uint32_t l_2662 = 0x303A4123L; + int64_t *l_2669 = (void*)0; + int64_t *l_2670 = &g_836.f0; + int64_t *l_2671[1][1]; + struct S1 *****l_2681 = &g_390; + int32_t l_2682 = 1L; + struct S1 l_2702[10][2] = {{{0x65F08FD2L},{0x65F08FD2L}},{{0x65F08FD2L},{0x65F08FD2L}},{{0x65F08FD2L},{0x65F08FD2L}},{{0x65F08FD2L},{0x65F08FD2L}},{{0x65F08FD2L},{0x65F08FD2L}},{{0x65F08FD2L},{0x65F08FD2L}},{{0x65F08FD2L},{0x65F08FD2L}},{{0x65F08FD2L},{0x65F08FD2L}},{{0x65F08FD2L},{0x65F08FD2L}},{{0x65F08FD2L},{0x65F08FD2L}}}; + int32_t l_2704 = (-1L); + uint8_t l_2739[1]; + int i, j, k; + for (i = 0; i < 1; i++) + { + for (j = 0; j < 1; j++) + l_2671[i][j] = &g_1499.f0; + } + for (i = 0; i < 1; i++) + l_2739[i] = 0x2FL; + if (l_2661[1][2][4]) + break; + l_2625[1] ^= 0x61F029C2L; + l_2662++; + } + } + } + if ((*l_2404)) + { /* block id: 1344 */ + uint32_t l_2760[8] = {0x9645D804L,0x9645D804L,0x9645D804L,0x9645D804L,0x9645D804L,0x9645D804L,0x9645D804L,0x9645D804L}; + struct S0 ****l_2762 = &g_1336; + int32_t l_2766 = 2L; + int32_t l_2771[10][9] = {{0x3988A091L,0x892FE34EL,0xF2090898L,0x13C124AAL,0x13C124AAL,0xF2090898L,0x892FE34EL,0x3988A091L,0x892FE34EL},{0L,(-1L),1L,1L,(-1L),0L,0xF7E765D6L,0L,(-1L)},{0x0BD34B00L,0x892FE34EL,0x892FE34EL,0x0BD34B00L,0x3988A091L,0x55F02D1EL,0x3988A091L,0x0BD34B00L,0x892FE34EL},{(-1L),(-1L),0xF7E765D6L,(-1L),(-2L),(-1L),(-1L),(-2L),(-2L)},{0x55F02D1EL,0x892FE34EL,0x415FE7E4L,0xF2090898L,0x415FE7E4L,0x892FE34EL,0x55F02D1EL,0x55F02D1EL,0x892FE34EL},{1L,0x04B15D96L,(-1L),0x04B15D96L,1L,0xF7E765D6L,0xF7E765D6L,1L,0x04B15D96L},{0x55F02D1EL,0x415FE7E4L,0x55F02D1EL,0x13C124AAL,0x3988A091L,0x3988A091L,0x13C124AAL,0x55F02D1EL,0x415FE7E4L},{(-2L),(-1L),0xF7E765D6L,(-1L),(-1L),0xF7E765D6L,(-1L),(-2L),(-1L)},{0x892FE34EL,0xF2090898L,0x13C124AAL,0x13C124AAL,0xF2090898L,0x892FE34EL,0x3988A091L,0x892FE34EL,0xF2090898L},{0x04B15D96L,(-1L),(-1L),0x04B15D96L,(-2L),1L,(-2L),0x04B15D96L,(-1L)}}; + int8_t **l_2807[9] = {&g_1032,(void*)0,&g_1032,&g_1032,(void*)0,&g_1032,&g_1032,(void*)0,&g_1032}; + int32_t ***l_2827[1][4] = {{&l_2825,&l_2825,&l_2825,&l_2825}}; + uint32_t l_2832 = 0UL; + int32_t l_2851 = 0L; + int i, j; + for (l_2425 = (-18); (l_2425 >= (-2)); ++l_2425) + { /* block id: 1347 */ + for (g_153 = (-4); (g_153 > (-10)); --g_153) + { /* block id: 1350 */ + (*g_109) = (void*)0; + } + return g_2744[0][5]; + } + for (g_937 = (-5); (g_937 < 11); ++g_937) + { /* block id: 1357 */ + struct S1 *l_2757 = &g_334[6][9]; + struct S0 ****l_2761 = &g_1336; + const int32_t l_2764[7] = {(-5L),(-5L),0xED613B56L,(-5L),(-5L),0xED613B56L,(-5L)}; + int32_t l_2770[5]; + int16_t l_2772 = 0xCCF7L; + const uint16_t *l_2844 = &g_2845[0]; + const uint16_t **l_2843[2]; + int i; + for (i = 0; i < 5; i++) + l_2770[i] = 4L; + for (i = 0; i < 2; i++) + l_2843[i] = &l_2844; + for (g_63.f0 = (-25); (g_63.f0 < 29); ++g_63.f0) + { /* block id: 1360 */ + struct S1 **l_2758 = (void*)0; + int32_t l_2763 = 0x9C06E16FL; + int64_t *l_2767 = &g_232; + uint16_t *l_2768 = (void*)0; + uint16_t *l_2769 = &g_919[4]; + int16_t l_2783 = 0xC03EL; + int8_t *l_2791 = &g_2582[0]; + int8_t **l_2808[6][3] = {{&g_1032,&l_2791,&l_2791},{&g_1032,&l_2791,&l_2791},{&g_1032,&l_2791,&l_2791},{&g_1032,&l_2791,&l_2791},{&g_1032,&l_2791,&l_2791},{&g_1032,&l_2791,&l_2791}}; + union U2 **l_2810 = (void*)0; + union U2 ***l_2809 = &l_2810; + uint32_t l_2846 = 0x3AF45311L; + int i, j; + l_2771[5][2] |= ((safe_sub_func_int16_t_s_s((+((*g_68) , 0L)), ((l_2770[4] = ((+(&g_1057 != &g_1057)) >= ((*l_2769) = (safe_rshift_func_int8_t_s_s((((*l_2767) &= (((((safe_add_func_uint8_t_u_u((((l_2760[2] ^= ((***g_390) == (l_2759[1] = l_2757))) || (((l_2761 == l_2762) || ((((l_2763 | (-1L)) && l_2764[5]) < g_1247[1]) == l_2760[2])) , 0x12CCFA2AD6FB2D0FLL)) , l_2765), l_2766)) == 0xD5B07880L) , (void*)0) == (*g_900)) || 0UL)) > 0UL), l_2766))))) > 0xF8F7D44DL))) < 255UL); + if ((((**l_2403) = ((*l_2404) & ((l_2771[1][2] ^ l_2760[2]) >= l_2772))) != ((safe_div_func_uint64_t_u_u((safe_sub_func_uint8_t_u_u((l_2771[9][5] || ((safe_mul_func_uint32_t_u_u((safe_mul_func_uint32_t_u_u(l_2770[4], (safe_rshift_func_uint8_t_u_s((l_2783 , ((~(0x1FCD0D30L == l_2763)) & 0xF5DB42CC7B2D2E75LL)), 5)))), l_2760[2])) == l_2783)), l_2763)), 0xC7BF77BA731439BCLL)) || l_2771[1][5]))) + { /* block id: 1368 */ + int8_t *l_2789 = &l_2578; + int8_t **l_2790 = &g_1032; + int32_t l_2804 = 1L; + (*g_68) = ((safe_add_func_int32_t_s_s((safe_sub_func_int8_t_s_s((-9L), (((*l_2790) = l_2789) != l_2791))), (0x45EF2F1CL && (g_334[3][3].f0 = ((**l_2403) != ((((*l_2769) = (((g_2792 , (safe_sub_func_int16_t_s_s(1L, (safe_mod_func_uint8_t_u_u(((g_2805[4][0] ^= ((*l_2789) = (safe_add_func_int32_t_s_s((safe_div_func_uint32_t_u_u((((((((~(safe_lshift_func_int64_t_s_s((*g_2202), (*g_2202)))) , l_2760[2]) , g_2271) , (*g_2202)) == (*g_2202)) ^ l_2804) || 0UL), l_2772)), g_763[0])))) ^ (***l_2402)), (**l_2403)))))) || l_2760[7]) & 0xADADL)) == 0x3AACL) & 0L)))))) && l_2806); + } + else + { /* block id: 1375 */ + (*l_2404) = ((&l_2791 != (l_2808[1][0] = l_2807[6])) <= 1UL); + if (l_2763) + break; + } + (*l_2809) = &g_741; + if (((*l_2404) | l_2783)) + { /* block id: 1381 */ + uint64_t ***l_2813 = &l_2109[0][2]; + struct S1 l_2814 = {4UL}; + int32_t l_2818 = 0x20274ABDL; + (***l_2402) ^= (safe_mul_func_int8_t_s_s((((*l_2813) = &g_2111[0]) != (l_2814 , &g_2111[0])), ((g_2815 , (safe_rshift_func_int64_t_s_s(l_2772, 56))) & (l_2766 <= 0x01L)))); + ++l_2819; + } + else + { /* block id: 1385 */ + const uint16_t *l_2840 = &g_919[5]; + const uint16_t **l_2839 = &l_2840; + const uint16_t ***l_2842[5][2]; + uint64_t l_2847[10] = {0x75DD00123D1370D4LL,18446744073709551609UL,18446744073709551609UL,0x75DD00123D1370D4LL,18446744073709551609UL,18446744073709551609UL,0x75DD00123D1370D4LL,18446744073709551609UL,18446744073709551609UL,0x75DD00123D1370D4LL}; + int32_t l_2848 = 6L; + int i, j; + for (i = 0; i < 5; i++) + { + for (j = 0; j < 2; j++) + l_2842[i][j] = &g_2841[1][0]; + } + (*g_71) = ((***g_1335) = (((safe_add_func_int16_t_s_s((l_2824 == l_2827[0][2]), (((safe_add_func_uint16_t_u_u((safe_lshift_func_int64_t_s_s(l_2832, 40)), (*l_2404))) , (((l_2847[3] = ((safe_lshift_func_int16_t_s_s((-1L), (safe_lshift_func_uint32_t_u_s(4UL, l_2760[2])))) ^ ((l_2839 == (l_2843[0] = g_2841[1][0])) <= l_2846))) == l_2848) | 0x6152A7E5L)) && (*g_1032)))) < 0x2CL) , (**g_1336))); + } + } + for (l_2660 = (-13); (l_2660 >= 6); ++l_2660) + { /* block id: 1394 */ + l_2770[2] &= (*l_2404); + (*l_2403) = (**l_2402); + } + } + ++l_2853[1]; + } + else + { /* block id: 1400 */ + int32_t l_2856 = 1L; + int32_t l_2861 = 0x3419FA57L; + int32_t l_2866[6] = {(-9L),(-9L),(-9L),(-9L),(-9L),(-9L)}; + int16_t l_2869 = 7L; + int i; + (*l_2594) = (l_2856 <= (safe_sub_func_int8_t_s_s(((0x59B0DEA75494FF3ALL < (safe_rshift_func_uint32_t_u_s(g_1939, 24))) , l_2861), ((safe_mul_func_uint32_t_u_u((safe_add_func_uint64_t_u_u(l_2861, (l_2866[3] = (*g_2202)))), (((safe_mul_func_int32_t_s_s(l_2869, (((safe_rshift_func_uint32_t_u_u((((+(safe_sub_func_uint32_t_u_u(((*g_2202) && l_2875), l_2856))) , g_232) , 6UL), g_232)) > 9L) >= (*l_2594)))) != (*g_2202)) <= g_919[4]))) >= g_171)))); + } + } + if ((safe_add_func_int64_t_s_s(8L, ((safe_div_func_uint64_t_u_u((safe_sub_func_int16_t_s_s(((((((*l_2883) |= l_2882) | g_2744[1][1]) , (safe_mul_func_uint32_t_u_u(4294967292UL, l_2886))) , ((**g_1080) , (((safe_rshift_func_uint64_t_u_u((((safe_rshift_func_uint64_t_u_s(((*g_49) &= (safe_add_func_uint64_t_u_u(18446744073709551615UL, l_2893))), 36)) ^ ((*g_2641) , l_2894)) ^ l_2895), l_2896)) <= l_2897) | (-1L)))) >= 65535UL), g_2898)), l_2899)) > (*g_2202))))) + { /* block id: 1407 */ + union U2 **l_2901 = (void*)0; + union U2 **l_2902 = &g_741; + (*l_2902) = (*g_740); + } + else + { /* block id: 1409 */ + const int32_t l_2903 = 0x23CD8CAFL; + int64_t l_2910 = 0x41A2CC141B5E775DLL; + struct S1 **l_2911 = &l_2759[1]; + uint16_t *l_2920 = (void*)0; + uint16_t *l_2921 = &l_2886; + int32_t l_2924 = 7L; + int32_t l_2925 = 1L; + struct S1 l_2944 = {9UL}; + int8_t l_2948[3]; + uint64_t l_2972 = 0xD5D45057F051989CLL; + int32_t l_2992[5][1][7] = {{{0L,0xD6E6938AL,(-9L),0x877442C7L,3L,(-7L),3L}},{{0L,3L,3L,0L,0xCC9C4FCDL,0x5A8123B2L,(-4L)}},{{0x83DB6E35L,0x5A8123B2L,(-9L),0xCC9C4FCDL,0xCC9C4FCDL,(-9L),0x5A8123B2L}},{{0xCC9C4FCDL,0x83DB6E35L,(-7L),0xD6E6938AL,3L,(-4L),(-4L)}},{{(-7L),0x83DB6E35L,0xCC9C4FCDL,0x83DB6E35L,(-7L),0xD6E6938AL,3L}}}; + uint64_t l_3000[1]; + uint32_t l_3005 = 0xE70390DEL; + int i, j, k; + for (i = 0; i < 3; i++) + l_2948[i] = 0x78L; + for (i = 0; i < 1; i++) + l_3000[i] = 18446744073709551615UL; + if (((l_2903 <= ((((safe_sub_func_int64_t_s_s((((safe_sub_func_uint16_t_u_u(((*l_2921) = (((void*)0 != (*g_2590)) == (safe_add_func_uint16_t_u_u(((*l_2883) = (((l_2910 , 1UL) == (65527UL || (l_2911 != l_2911))) <= (safe_mod_func_uint64_t_u_u((safe_lshift_func_int32_t_s_s(((safe_mod_func_int8_t_s_s((safe_mod_func_uint32_t_u_u(4294967290UL, 0xEE7191C6L)), 0x71L)) ^ l_2910), 14)), l_2910)))), 0UL)))), 0xBE0DL)) , g_1247[0]) <= l_2922), l_2923)) & g_47) | 6UL) ^ l_2910)) == l_2910)) + { /* block id: 1412 */ + uint16_t l_2926 = 0UL; + int8_t *l_2931[6] = {&g_1728,&g_1728,&g_1728,&g_1728,&g_1728,&g_1728}; + int16_t *l_2949 = &l_2922; + int32_t l_2950 = 0xDEE0FEF6L; + uint16_t l_2951 = 2UL; + int i; + l_2926++; + l_2951 |= ((((safe_lshift_func_int8_t_s_u((l_2925 = ((*g_1032) = (**g_1080))), 2)) & (-1L)) || (g_2932 , ((l_2925 & ((*l_2949) = (safe_mul_func_uint16_t_u_u((safe_add_func_uint8_t_u_u(l_2926, (safe_div_func_uint32_t_u_u((((safe_add_func_int8_t_s_s((((+(((safe_sub_func_uint32_t_u_u((l_2925 < (((((l_2944 , ((*l_14) = 18446744073709551609UL)) > (safe_sub_func_int64_t_s_s((!(**g_1080)), 0L))) != (*g_1032)) <= l_2903) , 0x9F49ACCDBE691F91LL)), 0xE905844AL)) != 0x87C5L) && l_2948[0])) <= l_2910) & 0x0A7962A254D9F4E1LL), g_196)) , g_2254) <= 0xAFA60553L), l_2926)))), g_2744[0][6])))) & l_2926))) <= l_2950); + return l_2950; + } + else + { /* block id: 1420 */ + int32_t l_2971 = 0xD559BD70L; + int32_t l_2975 = 1L; + int32_t l_2982 = 2L; + int32_t l_2983 = 1L; + uint32_t l_2984 = 0x46DFABDEL; + int32_t l_3003 = 0x1AD5E9D8L; + int32_t l_3004 = 0x4D14FA34L; + for (g_2274.f2 = 0; (g_2274.f2 <= 2); g_2274.f2 += 1) + { /* block id: 1423 */ + uint16_t l_2961 = 0xEB3EL; + int16_t *l_2966 = &l_2922; + int64_t *l_2973 = &l_2893; + int32_t l_2974[6] = {(-3L),2L,2L,(-3L),2L,2L}; + int16_t l_2976 = 1L; + uint8_t l_2987 = 0x36L; + int i; + l_2974[0] &= (safe_rshift_func_int8_t_s_s((l_2924 &= ((-3L) <= (safe_sub_func_int64_t_s_s(((+(l_2903 ^ ((safe_rshift_func_int8_t_s_u(((*g_49) > ((*l_2973) ^= (safe_div_func_uint64_t_u_u(l_2961, (safe_rshift_func_int8_t_s_s((safe_lshift_func_int16_t_s_s(((*l_2966) = (-1L)), (safe_div_func_int32_t_s_s(l_2961, (safe_div_func_int16_t_s_s((18446744073709551611UL < (((l_2971 , (&g_2374[2] != &g_2378)) | l_2971) >= l_2972)), g_219)))))), l_2910)))))), g_13)) | l_2961))) > l_2961), (*g_2202))))), 2)); + for (l_2806 = 0; (l_2806 <= 7); l_2806 += 1) + { /* block id: 1430 */ + uint16_t l_2977 = 1UL; + int32_t l_2981[1][8]; + int i, j; + for (i = 0; i < 1; i++) + { + for (j = 0; j < 8; j++) + l_2981[i][j] = 0xF6CD12EFL; + } + --l_2977; + for (l_2116.f0 = 0; (l_2116.f0 <= 7); l_2116.f0 += 1) + { /* block id: 1434 */ + int32_t l_2980[4][9] = {{0x2090AF47L,3L,(-8L),0x2090AF47L,1L,1L,0x2090AF47L,(-8L),3L},{0x2090AF47L,3L,(-8L),0x2090AF47L,1L,1L,0x2090AF47L,(-8L),3L},{0x2090AF47L,3L,(-8L),0x2090AF47L,1L,1L,0x2090AF47L,(-8L),3L},{0x2090AF47L,3L,(-8L),0x2090AF47L,1L,1L,1L,0x5620F778L,1L}}; + int i, j; + ++l_2984; + (*g_1481) = 0xAD0C97CDL; + } + ++l_2987; + for (g_2283.f2 = 7; (g_2283.f2 >= 0); g_2283.f2 -= 1) + { /* block id: 1441 */ + int32_t l_2990 = 0L; + int32_t l_2991 = (-9L); + int32_t l_2994 = 0x428B9DC4L; + int32_t l_2996 = 1L; + int32_t l_2997 = (-1L); + int32_t l_2998[6][5] = {{0xFAB9900FL,(-5L),0xFAB9900FL,(-5L),0xFAB9900FL},{(-6L),(-6L),(-6L),(-6L),(-6L)},{0xFAB9900FL,(-5L),0xFAB9900FL,(-5L),0xFAB9900FL},{(-6L),(-6L),(-6L),(-6L),(-6L)},{0xFAB9900FL,(-5L),0xFAB9900FL,(-5L),0xFAB9900FL},{(-6L),(-6L),(-6L),(-6L),(-6L)}}; + int64_t l_2999 = 0L; + int i, j; + --l_3000[0]; + } + } + return l_2975; + } + ++l_3005; + } + (***g_390) = (**g_391); + } + l_3008++; + return (*g_2641); +} + + +/* ------------------------------------------ */ +/* + * reads : g_1057 g_1954.f0 g_334.f0 g_1032 g_554 g_760.f0 g_56 g_148 g_109 g_62 g_2207 g_1081 g_1071 g_898 g_899 g_1620 g_171 g_1551 g_1986.f0 g_49 g_50 g_919 g_2254 g_94 g_75 g_763 g_1621 g_2293 g_1679 g_1648 g_1498 g_2296 g_2297 g_2298 g_2299 g_1335 g_1336 g_1337 g_199 g_1691 g_1421 + * writes: g_1057 g_554 g_2202 g_63 g_2208 g_1621 g_171 g_56 g_2254 g_919 g_2293 g_1498 g_692 g_1251 g_1338 g_72 g_1421 + */ +static int32_t func_2(uint8_t p_3, uint8_t p_4, uint64_t p_5) +{ /* block id: 1065 */ + uint16_t l_2167 = 0x8625L; + int64_t *l_2168 = (void*)0; + uint8_t *l_2169[4] = {&g_217[3][4],&g_217[3][4],&g_217[3][4],&g_217[3][4]}; + int32_t l_2170 = 0x06703C07L; + uint64_t l_2179 = 0x0DDB654FA892F2EELL; + uint8_t l_2180[3][9][9] = {{{1UL,0UL,0x62L,0xCAL,255UL,255UL,0xA8L,0xAAL,0x09L},{254UL,1UL,0x43L,0xA8L,255UL,0x7DL,0xCAL,0UL,255UL},{1UL,255UL,0xA8L,0x3BL,0x0BL,0x1BL,255UL,0x27L,0xA8L},{0x7DL,255UL,0x4EL,1UL,249UL,0xCFL,0x54L,254UL,255UL},{255UL,1UL,0x0FL,0x24L,0x15L,0xCAL,255UL,0xB3L,255UL},{0xA8L,0UL,0x4EL,1UL,0x6AL,0x85L,0x62L,0x95L,254UL},{1UL,255UL,0xA8L,1UL,1UL,0x0FL,0x1BL,1UL,1UL},{0xCFL,0UL,0x43L,0x24L,0x4FL,0x3BL,0x0FL,0UL,0x85L},{255UL,0x12L,0x62L,1UL,1UL,0x09L,0xCFL,0x6AL,0xCFL}},{{0x09L,0x6AL,0x3BL,0x3BL,0x6AL,0x09L,0x7DL,0xE9L,0x24L},{0x54L,246UL,0x1BL,0xA8L,0x15L,0x3BL,0xF2L,0x22L,255UL},{0x4EL,0x95L,0xF2L,0xCAL,249UL,0x0FL,0x7DL,0x12L,0x9BL},{255UL,0x22L,0x85L,255UL,0x0BL,0x85L,0xCFL,0x12L,0x0FL},{0x62L,0xCAL,0x09L,0x54L,255UL,0xCAL,0x0FL,0x22L,8UL},{255UL,255UL,1UL,255UL,255UL,0xCFL,0x1BL,0xE9L,0x0FL},{0xD2L,253UL,254UL,0x62L,254UL,0x1BL,0x62L,0x6AL,0x9BL},{0xD2L,0x49L,8UL,0x1BL,0x22L,0x7DL,255UL,0UL,255UL},{255UL,0x7DL,0x78L,7UL,0x1BL,0UL,0x10L,0x62L,255UL}},{{1UL,255UL,0x80L,0x78L,8UL,6UL,6UL,8UL,0x78L},{0x80L,0x3BL,0x80L,0xD9L,255UL,0x1BL,0UL,1UL,0xDDL},{0x7BL,0x4EL,0x78L,0xB3L,1UL,0x83L,253UL,0x0FL,1UL},{0x10L,255UL,0xB4L,0xD9L,0x62L,0UL,0x9AL,1UL,0UL},{0x6BL,254UL,0UL,0x78L,0x62L,248UL,1UL,0x43L,0x80L},{0UL,8UL,0xB2L,7UL,1UL,0x7BL,255UL,0xF5L,0xA5L},{0x78L,255UL,0x6BL,1UL,255UL,248UL,0xB2L,255UL,253UL},{0xB2L,255UL,0xDDL,1UL,8UL,0UL,0xB2L,0x09L,255UL},{253UL,0x24L,0xB3L,255UL,0x1BL,0x83L,255UL,255UL,0x6BL}}}; + int32_t *l_2187 = &g_56; + struct S1 l_2206[5][6] = {{{0xD212FF81L},{0xD212FF81L},{0xD212FF81L},{0xD212FF81L},{0xD212FF81L},{0xD212FF81L}},{{0xD212FF81L},{0xD212FF81L},{0xD212FF81L},{0xD212FF81L},{0xD212FF81L},{0xD212FF81L}},{{0xD212FF81L},{0xD212FF81L},{0xD212FF81L},{0xD212FF81L},{0xD212FF81L},{0xD212FF81L}},{{0xD212FF81L},{0xD212FF81L},{0xD212FF81L},{0xD212FF81L},{0xD212FF81L},{0xD212FF81L}},{{0xD212FF81L},{0xD212FF81L},{0xD212FF81L},{0xD212FF81L},{0xD212FF81L},{0xD212FF81L}}}; + int32_t l_2221 = 2L; + int32_t l_2247 = 0L; + int8_t l_2248 = 0x54L; + int32_t l_2252 = 1L; + int32_t l_2253 = 0L; + union U2 *l_2269[7][10][3] = {{{(void*)0,&g_2284,&g_2281},{(void*)0,&g_2282,(void*)0},{(void*)0,&g_2274,&g_2281},{&g_2273,&g_2282,&g_2273},{(void*)0,&g_2284,&g_2281},{(void*)0,&g_2282,(void*)0},{(void*)0,&g_2274,&g_2281},{&g_2273,&g_2282,&g_2273},{(void*)0,&g_2284,&g_2281},{(void*)0,&g_2282,(void*)0}},{{(void*)0,&g_2274,&g_2281},{&g_2273,&g_2282,&g_2273},{(void*)0,&g_2284,&g_2281},{(void*)0,&g_2282,(void*)0},{(void*)0,&g_2274,&g_2281},{&g_2273,&g_2282,&g_2273},{(void*)0,&g_2284,&g_2281},{(void*)0,&g_2282,(void*)0},{(void*)0,&g_2274,&g_2281},{&g_2273,&g_2282,&g_2273}},{{(void*)0,&g_2284,&g_2281},{(void*)0,&g_2282,(void*)0},{(void*)0,&g_2274,&g_2281},{&g_2273,&g_2282,&g_2280[0][3][2]},{&g_2277,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0},{&g_2277,&g_2281,(void*)0},{&g_2280[0][3][2],(void*)0,&g_2280[0][3][2]},{&g_2277,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0}},{{&g_2277,&g_2281,(void*)0},{&g_2280[0][3][2],(void*)0,&g_2280[0][3][2]},{&g_2277,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0},{&g_2277,&g_2281,(void*)0},{&g_2280[0][3][2],(void*)0,&g_2280[0][3][2]},{&g_2277,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0},{&g_2277,&g_2281,(void*)0},{&g_2280[0][3][2],(void*)0,&g_2280[0][3][2]}},{{&g_2277,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0},{&g_2277,&g_2281,(void*)0},{&g_2280[0][3][2],(void*)0,&g_2280[0][3][2]},{&g_2277,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0},{&g_2277,&g_2281,(void*)0},{&g_2280[0][3][2],(void*)0,&g_2280[0][3][2]},{&g_2277,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0}},{{&g_2277,&g_2281,(void*)0},{&g_2280[0][3][2],(void*)0,&g_2280[0][3][2]},{&g_2277,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0},{&g_2277,&g_2281,(void*)0},{&g_2280[0][3][2],(void*)0,&g_2280[0][3][2]},{&g_2277,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0},{&g_2277,&g_2281,(void*)0},{&g_2280[0][3][2],(void*)0,&g_2280[0][3][2]}},{{&g_2277,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0},{&g_2277,&g_2281,(void*)0},{&g_2280[0][3][2],(void*)0,&g_2280[0][3][2]},{&g_2277,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0},{&g_2277,&g_2281,(void*)0},{&g_2280[0][3][2],(void*)0,&g_2280[0][3][2]},{&g_2277,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0}}}; + int8_t l_2289[9][6] = {{1L,(-6L),(-6L),1L,1L,(-6L)},{1L,1L,(-6L),(-6L),1L,1L},{1L,(-6L),(-6L),1L,1L,(-6L)},{1L,1L,(-6L),(-6L),1L,1L},{1L,(-6L),(-6L),1L,1L,(-6L)},{1L,1L,(-6L),(-6L),1L,1L},{1L,(-6L),(-6L),1L,1L,(-6L)},{1L,1L,(-6L),(-6L),1L,1L},{1L,(-6L),(-6L),1L,1L,(-6L)}}; + struct S0 *l_2300 = &g_1454[5]; + volatile struct S0 *l_2302[9]; + int i, j, k; + for (i = 0; i < 9; i++) + l_2302[i] = &g_270; + if (((((*g_1032) |= ((l_2167 < (l_2170 &= ((p_5 , &g_232) == l_2168))) , ((safe_add_func_int16_t_s_s(l_2170, (~(l_2170 <= (safe_add_func_uint64_t_u_u((((safe_unary_minus_func_uint16_t_u(((safe_mul_func_uint32_t_u_u((g_1057 ^= (p_5 , ((0x22L || p_4) == l_2179))), (-1L))) && l_2179))) == g_1954.f0) >= g_334[3][3].f0), l_2167)))))) != 1UL))) & 0UL) >= 18446744073709551609UL)) + { /* block id: 1069 */ + int32_t *l_2186 = &g_56; + const int64_t *l_2197 = (void*)0; + int32_t l_2209 = 0xAD6C9FEAL; + struct S1 ***l_2217 = &g_109; + int8_t **l_2220 = (void*)0; + uint16_t ***l_2250 = (void*)0; + uint16_t ****l_2249 = &l_2250; + if (l_2180[2][7][8]) + { /* block id: 1070 */ + uint64_t l_2183[1][5][5]; + union U2 **l_2194 = &g_741; + const int64_t **l_2198 = &l_2197; + const int64_t *l_2200 = &g_2201; + const int64_t **l_2199[5][9][4] = {{{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,&l_2200,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,&l_2200,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,&l_2200,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0}},{{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,&l_2200,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,&l_2200,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,&l_2200,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0}},{{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,&l_2200,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,&l_2200,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,&l_2200,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0}},{{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,&l_2200,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,&l_2200,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,&l_2200,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0}},{{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,&l_2200,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,&l_2200,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0},{(void*)0,(void*)0,&l_2200,(void*)0},{(void*)0,(void*)0,(void*)0,(void*)0}}}; + int32_t l_2204 = (-7L); + struct S1 l_2205 = {0xFED1463EL}; + int i, j, k; + for (i = 0; i < 1; i++) + { + for (j = 0; j < 5; j++) + { + for (k = 0; k < 5; k++) + l_2183[i][j][k] = 0x35B92F13429A001ALL; + } + } + l_2183[0][3][1] |= (safe_lshift_func_int64_t_s_s(p_3, g_1057)); + for (l_2179 = 0; (l_2179 == 1); ++l_2179) + { /* block id: 1074 */ + l_2187 = l_2186; + return p_3; + } + l_2206[1][5] = ((**g_109) = ((g_760.f0 >= ((safe_mod_func_uint16_t_u_u(((safe_div_func_int64_t_s_s(1L, ((((((*l_2186) != (l_2170 = (safe_lshift_func_uint16_t_u_s(((void*)0 != l_2194), p_5)))) | ((safe_add_func_int8_t_s_s((0x66CBL >= ((((*l_2198) = l_2197) == (g_2202 = &g_232)) < 1UL)), (*l_2186))) , l_2183[0][3][1])) , l_2183[0][2][2]) <= l_2204) ^ 9UL))) == (*l_2186)), g_148)) >= 1L)) , l_2205)); + } + else + { /* block id: 1083 */ + uint32_t l_2210 = 0x9CEFAC0FL; + g_2208 = g_2207[2][7]; + l_2210--; + } + l_2221 = ((safe_add_func_int8_t_s_s(0x6AL, (*g_1081))) ^ (safe_add_func_int8_t_s_s(((*g_1032) &= (((((*g_898) == l_2217) & ((p_3 == (safe_rshift_func_uint8_t_u_s(((l_2220 == l_2220) || (((*g_1620) = &l_2167) == &l_2167)), 5))) ^ 5UL)) < 0xE7L) , p_3)), 0x6BL))); + for (g_171 = 0; (g_171 > 1); ++g_171) + { /* block id: 1092 */ + uint32_t l_2228 = 4294967295UL; + l_2187 = &l_2170; + (*l_2186) ^= (((*g_1032) = (safe_lshift_func_int64_t_s_s(((((safe_mod_func_int64_t_s_s(l_2228, ((p_3 < 0xB3L) , (safe_rshift_func_uint32_t_u_s(p_3, (((safe_lshift_func_uint64_t_u_s((((((p_5 == (safe_lshift_func_uint64_t_u_u(((((*l_2187) = (*l_2187)) , ((safe_mul_func_uint8_t_u_u(p_4, (safe_add_func_uint8_t_u_u((((safe_sub_func_uint16_t_u_u((safe_mul_func_int64_t_s_s((g_1551 , (safe_sub_func_int16_t_s_s(((safe_rshift_func_int16_t_s_u(g_1986.f0, 15)) & l_2228), p_5))), 0x388AF46972AC2E06LL)), 0xDEADL)) < 0x73L) | 0xE064E15BL), (-8L))))) != 0xDEL)) && l_2247), 28))) && (*g_49)) <= l_2248) > g_919[4]) > 0x6EE47DEFL), p_4)) | p_5) <= 0xD15776B272A17EAELL)))))) || g_760.f0) , (void*)0) != l_2249), 34))) < 0L); + } + return p_4; + } + else + { /* block id: 1099 */ + int32_t *l_2251[8] = {(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0}; + int32_t l_2290 = 0x00EDFA59L; + int i; + ++g_2254; + (*l_2187) |= 0xD6153177L; + if ((safe_sub_func_int32_t_s_s((p_5 & (((*l_2187) = p_3) != p_4)), 1UL))) + { /* block id: 1103 */ + uint64_t l_2288 = 0x38732B217F77E456LL; + int16_t l_2291 = 4L; + int32_t l_2292 = 0x7B0E9F5CL; + (*l_2187) = ((safe_div_func_uint8_t_u_u((safe_mul_func_uint16_t_u_u(((safe_unary_minus_func_uint8_t_u(g_94[3])) , ((**g_1620) = (((safe_sub_func_uint8_t_u_u(((((-6L) <= ((((safe_div_func_int16_t_s_s(((*g_49) >= (g_75 || ((*l_2187) , ((*g_1032) & ((safe_unary_minus_func_uint32_t_u((p_5 < (((void*)0 == l_2269[6][8][1]) || 0xB0006780L)))) , g_763[0]))))), l_2288)) | 1UL) < (*l_2187)) < p_3)) & l_2288) != l_2289[3][0]), l_2288)) , p_4) & l_2290))), g_554)), l_2288)) == l_2288); + --g_2293; + (**g_1679) = (**g_1679); + } + else + { /* block id: 1108 */ + (*g_2297) = g_2296; + } + (*g_2299) = g_2298; + } + (*g_199) = ((***g_1335) = l_2300); + (*g_1691) = (*g_1691); + return p_3; +} + + +/* ------------------------------------------ */ +/* + * reads : g_790 g_1621 g_919 g_1247 g_1057 g_760.f0 g_1032 g_554 + * writes: g_163 g_148 g_937 g_57 g_626 g_1057 g_47 + */ +static uint32_t func_9(uint64_t p_10, uint32_t p_11, uint32_t p_12) +{ /* block id: 1054 */ + int32_t l_2124 = 0x939D6C76L; + int32_t *l_2125[8][9][3] = {{{&g_75,&g_75,(void*)0},{&g_56,&g_75,&g_75},{(void*)0,&g_809[0],&g_75},{&g_809[0],&g_56,&g_809[0]},{&g_56,(void*)0,&g_75},{(void*)0,&g_56,&g_809[0]},{&g_75,(void*)0,&g_75},{(void*)0,&g_56,&g_809[0]},{&g_56,&g_809[0],&g_75}},{{&g_809[0],&g_75,&g_56},{&g_809[0],&g_75,&g_809[0]},{&g_56,&g_809[0],&g_809[0]},{&g_809[0],&g_75,&g_809[0]},{&g_809[0],&g_75,&g_56},{&g_56,(void*)0,&g_809[0]},{(void*)0,&g_809[0],&g_75},{&g_75,(void*)0,&g_75},{(void*)0,&g_809[0],&g_75}},{{&g_56,&g_809[0],&g_809[0]},{&g_809[0],&g_809[0],&g_56},{(void*)0,&g_75,&g_809[0]},{&g_56,&g_75,&g_809[0]},{&g_75,&g_809[0],&g_809[0]},{(void*)0,&g_75,&g_56},{&g_75,&g_75,&g_75},{&g_809[0],&g_809[0],&g_809[0]},{&g_56,&g_809[0],&g_75}},{{(void*)0,&g_809[0],&g_809[0]},{&g_809[0],(void*)0,&g_75},{(void*)0,&g_809[0],&g_809[0]},{&g_56,(void*)0,&g_75},{&g_809[0],&g_75,&g_75},{&g_75,&g_75,(void*)0},{(void*)0,&g_809[0],&g_809[0]},{&g_75,&g_75,(void*)0},{&g_56,&g_75,&g_75}},{{(void*)0,&g_809[0],&g_75},{&g_809[0],&g_56,&g_809[0]},{&g_56,(void*)0,&g_75},{(void*)0,&g_56,&g_809[0]},{&g_75,(void*)0,&g_75},{(void*)0,&g_56,&g_809[0]},{&g_56,&g_809[0],&g_75},{&g_809[0],&g_75,&g_56},{&g_809[0],&g_75,&g_809[0]}},{{&g_56,&g_809[0],&g_809[0]},{&g_809[0],&g_75,&g_809[0]},{&g_809[0],&g_75,&g_56},{&g_56,(void*)0,&g_809[0]},{(void*)0,&g_809[0],&g_75},{&g_75,(void*)0,&g_75},{(void*)0,&g_809[0],&g_75},{&g_56,&g_809[0],&g_809[0]},{&g_809[0],&g_809[0],&g_56}},{{(void*)0,&g_75,&g_809[0]},{&g_56,&g_75,&g_809[0]},{&g_75,&g_809[0],&g_809[0]},{(void*)0,&g_75,&g_56},{&g_75,&g_75,&g_75},{&g_809[0],&g_809[0],&g_809[0]},{&g_56,&g_809[0],&g_75},{(void*)0,&g_809[0],&g_809[0]},{&g_809[0],(void*)0,&g_75}},{{(void*)0,&g_809[0],(void*)0},{&g_809[0],&g_56,(void*)0},{&g_75,&g_56,(void*)0},{&g_75,&g_75,&g_56},{&g_809[0],(void*)0,&g_809[0]},{&g_809[0],&g_75,&g_56},{&g_809[0],(void*)0,(void*)0},{&g_75,&g_809[0],(void*)0},{&g_809[0],&g_56,(void*)0}}}; + int32_t l_2126 = 0x1B9B9640L; + uint16_t l_2127 = 0x7AACL; + int8_t *l_2151[3]; + int8_t *l_2152 = (void*)0; + int16_t *l_2159[10] = {&g_148,&g_148,&g_148,(void*)0,(void*)0,&g_148,&g_148,&g_148,(void*)0,(void*)0}; + uint64_t *l_2161 = &g_57; + uint64_t *l_2162 = &g_626[6][3][1]; + uint32_t *l_2163 = &g_1057; + int32_t l_2164 = 2L; + int i, j, k; + for (i = 0; i < 3; i++) + l_2151[i] = &g_196; + ++l_2127; + (*g_790) = (void*)0; + l_2164 |= (safe_mod_func_int16_t_s_s((safe_sub_func_int8_t_s_s((p_11 == (g_47 = ((safe_rshift_func_uint16_t_u_s((~(safe_div_func_uint16_t_u_u((*g_1621), (safe_lshift_func_int8_t_s_u((p_11 == ((*l_2163) |= (safe_div_func_int32_t_s_s((safe_mod_func_int32_t_s_s(((safe_mod_func_int64_t_s_s(g_1247[5], ((*l_2162) = (safe_add_func_uint8_t_u_u(((l_2151[0] != l_2152) , (0x01E8L == (safe_lshift_func_uint64_t_u_u(((*l_2161) = (safe_mul_func_int16_t_s_s(((safe_rshift_func_int16_t_s_u((g_937 = (g_148 = p_11)), 1)) >= (!0xEE7416AF0CFC2012LL)), p_12))), 27)))), p_12))))) > p_10), 7L)), p_11)))), p_11))))), g_760.f0)) == p_11))), (*g_1032))), 0x83EDL)); + return p_12; +} + + +/* ------------------------------------------ */ +/* + * reads : g_63.f0 g_790 + * writes: g_63.f0 g_163 + */ +static uint32_t func_16(uint32_t p_17, uint64_t * p_18, struct S1 p_19, uint64_t * const p_20, uint32_t p_21) +{ /* block id: 1046 */ + int32_t *l_2119 = (void*)0; + for (g_63.f0 = (-13); (g_63.f0 == 36); g_63.f0++) + { /* block id: 1049 */ + (*g_790) = l_2119; + } + return p_21; +} + + +/* ------------------------------------------ */ +/* + * reads : + * writes: + */ +static uint64_t * func_22(uint64_t * p_23, uint32_t p_24, int64_t p_25) +{ /* block id: 1044 */ + return p_23; +} + + +/* ------------------------------------------ */ +/* + * reads : g_68 g_56 g_75 g_700 g_741 g_1032 g_554 g_763 g_63.f0 g_50 g_217 g_1421 g_919 g_133 g_47 g_292 g_1435 g_1436 g_49 g_390 g_391 g_109 g_62 g_1454 g_1335 g_1336 g_1337 g_1057 g_153 g_790 g_1481 g_809 g_1488 g_1137.f0 g_63 g_1209.f0 g_1498 g_692 g_1227 g_975.f0 g_158 g_334.f0 g_219 g_1551 g_1081 g_1071 g_937 g_234 g_626 g_1620 g_1630 g_1247 g_1663 g_275 g_1084 g_1668 g_196 g_700.f0 g_1621 g_199 g_72 g_1689 g_1690 g_1691 g_1679 g_1648 g_1312 g_1704 g_1080 g_1488.f2 g_1728 g_987.f0 g_1040 g_1082 g_1079 g_1499.f0 g_2073 g_2078 g_2101 + * writes: g_56 g_75 g_133 g_1057 g_158 g_232 g_919 g_334.f0 g_987 g_63 g_1137 g_1338 g_1466 g_554 g_163 g_809 g_196 g_626 g_1228 g_219 g_57 g_1620 g_1648 g_1663 g_275 g_741 g_1669 g_1679 g_72 g_1421 g_1498 g_47 g_153 g_937 g_334 g_70 g_1488.f2 g_226 g_1881 g_1499.f0 g_1127.f2 g_2101 + */ +static uint64_t * func_26(int16_t p_27) +{ /* block id: 692 */ + uint32_t l_1371 = 0UL; + uint64_t *l_1374 = &g_133; + uint64_t l_1377 = 0UL; + struct S1 ****l_1386 = &g_391; + int32_t l_1445 = 1L; + int32_t ****l_1512[9][9][3] = {{{&g_1229[7][6][0],&g_1229[6][5][0],&g_1229[2][0][0]},{&g_1229[0][0][2],&g_1229[6][5][0],&g_1229[0][0][2]},{&g_1229[6][5][0],&g_1229[7][6][2],&g_1229[6][5][0]},{&g_1229[3][8][0],&g_1229[6][5][0],&g_1229[6][5][0]},{&g_1229[4][6][1],&g_1229[6][5][0],&g_1229[6][9][2]},{&g_1229[5][8][2],(void*)0,&g_1229[6][1][1]},{&g_1229[4][6][1],&g_1229[4][8][0],&g_1229[6][5][0]},{&g_1229[3][8][0],&g_1229[6][5][0],&g_1229[6][5][0]},{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[6][5][0]}},{{&g_1229[0][0][2],(void*)0,&g_1229[0][1][0]},{&g_1229[7][6][0],&g_1229[6][9][2],&g_1229[6][5][0]},{&g_1229[3][4][1],(void*)0,&g_1229[5][9][1]},{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[7][6][0]},{&g_1229[3][0][0],(void*)0,&g_1229[6][5][0]},{(void*)0,&g_1229[7][6][0],&g_1229[6][5][0]},{&g_1229[6][5][0],&g_1229[4][7][0],&g_1229[6][5][0]},{&g_1229[6][9][2],&g_1229[1][6][1],&g_1229[7][6][0]},{&g_1229[1][6][2],(void*)0,&g_1229[5][9][1]}},{{&g_1229[6][5][0],&g_1229[6][8][1],&g_1229[6][5][0]},{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[0][1][0]},{&g_1229[4][9][2],&g_1229[6][5][0],&g_1229[6][5][0]},{(void*)0,&g_1229[2][4][2],&g_1229[6][5][0]},{&g_1229[6][5][0],&g_1229[3][5][1],&g_1229[6][5][0]},{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[6][1][1]},{&g_1229[1][5][1],&g_1229[1][1][2],&g_1229[6][9][2]},{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[6][5][0]},{&g_1229[6][5][0],&g_1229[3][5][1],&g_1229[6][5][0]}},{{&g_1229[6][5][0],&g_1229[2][4][2],&g_1229[0][0][2]},{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[2][0][0]},{&g_1229[1][3][0],&g_1229[6][5][0],&g_1229[6][5][0]},{&g_1229[3][5][1],&g_1229[6][8][1],&g_1229[3][5][1]},{&g_1229[4][1][2],(void*)0,&g_1229[6][5][0]},{&g_1229[4][3][0],&g_1229[1][6][1],&g_1229[5][0][1]},{&g_1229[5][9][1],&g_1229[4][7][0],&g_1229[6][5][0]},{&g_1229[6][5][0],&g_1229[7][6][0],&g_1229[2][1][2]},{&g_1229[5][9][1],(void*)0,&g_1229[0][6][1]}},{{&g_1229[4][3][0],&g_1229[6][5][0],&g_1229[1][1][2]},{&g_1229[4][1][2],(void*)0,&g_1229[1][6][2]},{&g_1229[3][5][1],&g_1229[6][9][2],&g_1229[4][8][0]},{&g_1229[1][3][0],(void*)0,&g_1229[6][5][0]},{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[4][6][1]},{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[1][3][0]},{&g_1229[6][5][0],&g_1229[4][8][0],&g_1229[4][9][2]},{&g_1229[6][5][0],(void*)0,&g_1229[1][3][2]},{&g_1229[1][5][1],&g_1229[6][5][0],&g_1229[4][9][2]}},{{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[1][3][0]},{&g_1229[6][5][0],&g_1229[7][6][2],&g_1229[4][6][1]},{(void*)0,&g_1229[6][5][0],&g_1229[6][5][0]},{&g_1229[4][9][2],&g_1229[6][5][0],&g_1229[4][8][0]},{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[1][6][2]},{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[1][1][2]},{&g_1229[1][6][2],&g_1229[6][5][0],&g_1229[0][6][1]},{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[6][5][0]},{&g_1229[6][5][0],(void*)0,&g_1229[5][8][2]}},{{&g_1229[1][6][1],&g_1229[6][5][0],&g_1229[6][5][0]},{&g_1229[5][9][1],&g_1229[6][5][0],&g_1229[6][1][1]},{&g_1229[2][1][2],&g_1229[3][5][1],&g_1229[6][5][0]},{&g_1229[6][5][0],&g_1229[7][5][1],&g_1229[4][1][2]},{&g_1229[6][5][0],&g_1229[7][6][2],&g_1229[6][5][0]},{(void*)0,(void*)0,(void*)0},{&g_1229[4][3][0],&g_1229[6][5][0],&g_1229[2][1][2]},{&g_1229[1][6][2],&g_1229[6][5][0],&g_1229[1][3][2]},{&g_1229[7][6][0],&g_1229[4][6][1],&g_1229[6][5][0]}},{{(void*)0,&g_1229[4][4][1],&g_1229[0][8][2]},{&g_1229[7][6][0],&g_1229[1][1][2],&g_1229[4][9][2]},{&g_1229[1][6][2],&g_1229[4][7][0],&g_1229[3][4][1]},{&g_1229[4][3][0],&g_1229[7][1][1],(void*)0},{(void*)0,&g_1229[6][7][2],&g_1229[6][5][0]},{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[7][6][2]},{&g_1229[6][5][0],(void*)0,&g_1229[1][3][0]},{&g_1229[2][1][2],&g_1229[6][5][0],&g_1229[6][5][0]},{&g_1229[5][9][1],&g_1229[6][5][0],&g_1229[0][1][0]}},{{&g_1229[1][6][1],&g_1229[6][5][0],&g_1229[3][5][1]},{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[0][1][0]},{&g_1229[6][5][0],&g_1229[1][5][1],&g_1229[6][5][0]},{&g_1229[6][5][0],&g_1229[5][2][0],&g_1229[1][3][0]},{&g_1229[6][8][1],&g_1229[2][0][0],&g_1229[7][6][2]},{&g_1229[0][1][0],(void*)0,&g_1229[6][5][0]},{&g_1229[4][8][0],(void*)0,(void*)0},{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[3][4][1]},{(void*)0,&g_1229[6][5][0],&g_1229[4][9][2]}}}; + uint32_t **l_1519 = &g_563; + const int8_t *l_1523 = &g_196; + struct S0 ***l_1579[3]; + uint64_t l_1695 = 1UL; + union U3 ***l_1836 = &g_1648; + uint8_t l_1874 = 0x16L; + uint16_t *** const l_2061 = &g_1620; + uint64_t l_2105 = 7UL; + uint64_t *l_2108[7][7]; + int i, j, k; + for (i = 0; i < 3; i++) + l_1579[i] = &g_1337; + for (i = 0; i < 7; i++) + { + for (j = 0; j < 7; j++) + l_2108[i][j] = &g_133; + } + l_1371 |= ((*g_68) |= (safe_mod_func_uint64_t_u_u(0x68222EB7FD6C9811LL, 1UL))); + for (g_75 = 29; (g_75 <= (-17)); g_75--) + { /* block id: 697 */ + return l_1374; + } + if (((safe_sub_func_int16_t_s_s((l_1377 | 0x55L), ((((l_1371 , (safe_sub_func_uint16_t_u_u(((((g_1057 = ((l_1377 < ((((safe_lshift_func_uint8_t_u_u((safe_mul_func_int8_t_s_s((((safe_lshift_func_int32_t_s_s(((g_700[0][0][0] , (void*)0) == l_1386), ((((*l_1374) = (((((((~((safe_lshift_func_int32_t_s_s((g_741 != (void*)0), 12)) <= l_1371)) , 0x08L) , p_27) <= (-2L)) <= 0x4BL) || (*g_1032)) != 0x75D7L)) | g_763[0]) == 0x37L))) <= 0xCEB6L) , 0x2CL), 1UL)), 6)) > l_1377) , p_27) >= 9L)) ^ l_1371)) , 0x6441938017F90742LL) ^ 0xF69970F559483C01LL) , 65526UL), l_1371))) < g_63.f0) ^ g_50[1][2][1]) , p_27))) < g_217[2][6])) + { /* block id: 702 */ + int8_t l_1432[5][5][10] = {{{0x6CL,0x0DL,0x8EL,1L,0L,1L,0x7EL,(-2L),(-1L),0x47L},{0x47L,0L,1L,0xBCL,7L,(-1L),1L,0x82L,(-7L),0xC3L},{0x92L,(-1L),0x26L,(-1L),0x9FL,(-2L),0L,0L,0L,0L},{0xA9L,(-8L),0x67L,0x67L,(-8L),0xA9L,0xACL,1L,0xC3L,0x0DL},{0x41L,(-6L),9L,0x23L,0xBCL,0x6BL,0x53L,(-2L),0x8EL,(-5L)}},{{0x41L,0x37L,0x20L,1L,9L,0xA9L,(-5L),1L,7L,0x6BL},{0xA9L,(-5L),1L,7L,0x6BL,(-2L),(-1L),7L,0x5AL,1L},{0x92L,0x6CL,0xC3L,0x11L,0xC3L,(-1L),0xA7L,(-8L),8L,0x5AL},{0x47L,0xEEL,0x5EL,0L,(-7L),1L,9L,0x92L,(-9L),0x9FL},{0x6CL,(-1L),(-1L),0x1FL,1L,0xDBL,0xDDL,0xACL,0x8BL,0x11L}},{{(-6L),0xAEL,(-2L),0x8EL,0xBCL,0L,1L,(-1L),0x1FL,0x67L},{(-9L),0x8EL,0x37L,(-8L),0x1FL,(-8L),0x37L,0x8EL,(-9L),(-1L)},{0L,0L,0xAEL,0x7EL,0x0CL,0x37L,0x59L,0x15L,(-5L),0L},{0x20L,0x8EL,0L,0x7EL,(-1L),0xBCL,0x82L,(-2L),(-9L),(-2L)},{0x8EL,0x15L,8L,(-8L),0xC3L,0xD5L,0xACL,(-9L),0x1FL,0x92L}},{{0x26L,(-9L),0x8BL,0x8EL,6L,0x15L,0x6CL,(-7L),(-8L),0L},{0L,(-6L),0x92L,(-1L),0L,0x5AL,(-1L),(-2L),1L,0x9FL},{(-2L),1L,0x33L,0x41L,0x82L,(-1L),0xA9L,0x11L,0x53L,0x82L},{1L,0xBCL,7L,(-1L),1L,0x82L,(-7L),0xC3L,(-1L),1L},{(-6L),(-1L),0L,0x8EL,0xA9L,(-1L),(-1L),0xA9L,0x8EL,0L}},{{0x92L,0x92L,0x0DL,(-2L),8L,1L,0xB1L,0x8BL,0x23L,0xCCL},{1L,(-2L),(-8L),0L,(-5L),(-5L),0xB1L,1L,0x15L,0xC8L},{1L,0x92L,0xD5L,9L,0xCCL,(-6L),(-1L),0x8EL,0xB1L,0x20L},{0x0CL,(-1L),0L,7L,1L,(-10L),(-7L),0xABL,0x82L,(-1L)},{0x7EL,0xBCL,0L,6L,(-1L),0x6BL,0xA9L,8L,0xCCL,(-8L)}}}; + int32_t l_1434 = 0x4082CD23L; + uint8_t l_1446 = 249UL; + uint32_t **l_1465[10] = {(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0}; + uint32_t *** const l_1464 = &l_1465[4]; + struct S1 l_1493 = {0x95462461L}; + const struct S1 * const *l_1529 = &g_901[2]; + const struct S1 * const * const *l_1528 = &l_1529; + uint32_t *l_1537 = &g_63.f0; + int32_t l_1546 = 0xE48635F2L; + union U2 *l_1658 = &g_1127; + int32_t *** const *l_1667[7][1][4] = {{{&g_1229[2][8][1],&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[6][5][0]}},{{&g_1229[5][6][0],&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[5][6][0]}},{{&g_1229[6][5][0],&g_1229[5][6][0],&g_1229[2][8][1],&g_1229[6][5][0]}},{{&g_1229[6][5][0],&g_1229[2][8][1],&g_1229[6][5][0],&g_1229[6][5][0]}},{{&g_1229[5][6][0],&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[6][5][0]}},{{&g_1229[2][8][1],&g_1229[2][8][1],&g_1229[6][5][0],&g_1229[6][5][0]}},{{&g_1229[6][5][0],&g_1229[5][6][0],&g_1229[6][5][0],&g_1229[5][6][0]}}}; + uint16_t l_1682 = 9UL; + int32_t l_1696 = 0x654C20B1L; + int8_t **l_1700[2][9][7] = {{{&g_1032,&g_1032,&g_1032,&g_1032,&g_1032,&g_1032,&g_1032},{&g_1032,&g_1032,&g_1032,(void*)0,(void*)0,&g_1032,&g_1032},{&g_1032,&g_1032,&g_1032,&g_1032,(void*)0,&g_1032,&g_1032},{&g_1032,&g_1032,&g_1032,&g_1032,&g_1032,(void*)0,&g_1032},{&g_1032,&g_1032,&g_1032,&g_1032,&g_1032,&g_1032,&g_1032},{&g_1032,&g_1032,&g_1032,(void*)0,&g_1032,&g_1032,&g_1032},{&g_1032,&g_1032,&g_1032,&g_1032,&g_1032,&g_1032,&g_1032},{(void*)0,&g_1032,&g_1032,&g_1032,&g_1032,&g_1032,&g_1032},{&g_1032,&g_1032,&g_1032,&g_1032,&g_1032,&g_1032,&g_1032}},{{&g_1032,&g_1032,&g_1032,&g_1032,&g_1032,&g_1032,&g_1032},{&g_1032,&g_1032,&g_1032,&g_1032,&g_1032,&g_1032,&g_1032},{&g_1032,(void*)0,&g_1032,&g_1032,(void*)0,&g_1032,&g_1032},{(void*)0,&g_1032,&g_1032,(void*)0,&g_1032,&g_1032,&g_1032},{&g_1032,&g_1032,&g_1032,&g_1032,&g_1032,&g_1032,&g_1032},{&g_1032,&g_1032,&g_1032,&g_1032,(void*)0,&g_1032,&g_1032},{&g_1032,(void*)0,&g_1032,&g_1032,&g_1032,&g_1032,&g_1032},{(void*)0,&g_1032,&g_1032,&g_1032,(void*)0,&g_1032,&g_1032},{&g_1032,&g_1032,&g_1032,&g_1032,&g_1032,(void*)0,&g_1032}}}; + int8_t ***l_1699 = &l_1700[0][2][4]; + int8_t ****l_1698 = &l_1699; + const uint16_t l_1710 = 0xE3F1L; + int8_t l_1723[3][9][5] = {{{0x02L,0xD6L,0x47L,0x80L,0xA0L},{0x02L,0xB9L,2L,2L,0xB9L},{0x02L,0xA0L,0x80L,0x47L,0xD6L},{0x02L,7L,5L,0L,0x1BL},{0x02L,0x1BL,0L,5L,7L},{0x02L,0xD6L,0x47L,0x80L,0xA0L},{0x02L,0xB9L,2L,2L,0xB9L},{0x02L,0xA0L,0x80L,0x47L,0xD6L},{0x02L,7L,5L,0L,0x1BL}},{{0x02L,0x1BL,0L,5L,7L},{0x02L,0xD6L,0x47L,0x80L,0xA0L},{0x02L,0xB9L,2L,2L,0xB9L},{0x02L,0xA0L,0x80L,0x47L,0xD6L},{0x02L,7L,5L,0L,0x1BL},{0x02L,0xDEL,0xA0L,0xD6L,0x69L},{(-1L),(-3L),0x1BL,7L,0x10L},{(-1L),0L,0xB9L,0xB9L,0L},{(-1L),0x10L,7L,0x1BL,(-3L)}},{{(-1L),0x69L,0xD6L,0xA0L,0xDEL},{(-1L),0xDEL,0xA0L,0xD6L,0x69L},{(-1L),(-3L),0x1BL,7L,0x10L},{(-1L),0L,0xB9L,0xB9L,0L},{(-1L),0x10L,7L,0x1BL,(-3L)},{(-1L),0x69L,0xD6L,0xA0L,0xDEL},{(-1L),0xDEL,0xA0L,0xD6L,0x69L},{(-1L),(-3L),0x1BL,7L,0x10L},{(-1L),0L,0xB9L,0xB9L,0L}}}; + int32_t l_1760 = 0x93EFEA41L; + uint8_t l_1761 = 0x4DL; + uint8_t l_1765 = 0UL; + int32_t l_1827 = 0xD55D2D43L; + union U3 ***l_1834 = &g_1648; + struct S0 ***l_1841 = &g_1337; + int64_t l_1868 = 0x8474CDE146BAA11ALL; + uint16_t * const *l_1880 = &g_1621; + uint16_t * const * const *l_1879[2]; + uint16_t * const * const **l_1878[5]; + int i, j, k; + for (i = 0; i < 2; i++) + l_1879[i] = &l_1880; + for (i = 0; i < 5; i++) + l_1878[i] = &l_1879[0]; +lbl_1661: + for (g_133 = 0; (g_133 != 50); g_133++) + { /* block id: 705 */ + int32_t l_1407 = 0x0FAE9F3BL; + uint32_t l_1480 = 0x7289B2E5L; + for (l_1377 = 0; (l_1377 >= 50); l_1377 = safe_add_func_uint8_t_u_u(l_1377, 1)) + { /* block id: 708 */ + uint16_t l_1408 = 1UL; + struct S0 *l_1457 = &g_128[5][2][0]; + uint32_t *l_1472 = &g_1057; + int32_t **l_1479 = &g_163; + int32_t l_1500 = 0xCABE59D6L; + uint32_t **l_1520[2][10][4] = {{{(void*)0,&g_563,&g_563,(void*)0},{(void*)0,&g_563,&g_563,(void*)0},{(void*)0,&g_563,&g_563,(void*)0},{(void*)0,&g_563,&g_563,(void*)0},{(void*)0,&g_563,&g_563,(void*)0},{(void*)0,&g_563,&g_563,(void*)0},{(void*)0,&g_563,&g_563,(void*)0},{(void*)0,&g_563,&g_563,(void*)0},{(void*)0,&g_563,&g_563,(void*)0},{(void*)0,&g_563,&g_563,(void*)0}},{{(void*)0,&g_563,&g_563,(void*)0},{(void*)0,&g_563,&g_563,(void*)0},{(void*)0,&g_563,&g_563,(void*)0},{(void*)0,&g_563,&g_563,(void*)0},{(void*)0,&g_563,&g_563,(void*)0},{(void*)0,&g_563,&g_563,(void*)0},{(void*)0,&g_563,&g_563,(void*)0},{(void*)0,&g_563,&g_563,(void*)0},{(void*)0,&g_563,&g_563,(void*)0},{(void*)0,&g_563,&g_563,(void*)0}}}; + int i, j, k; + for (g_158 = 0; (g_158 != 10); g_158 = safe_add_func_int8_t_s_s(g_158, 5)) + { /* block id: 711 */ + uint16_t *l_1422 = &g_919[4]; + int32_t l_1429 = (-5L); + uint32_t *l_1430 = &l_1371; + uint32_t *l_1431 = &g_334[3][3].f0; + if ((safe_div_func_int8_t_s_s((safe_add_func_int16_t_s_s((safe_lshift_func_uint8_t_u_s((safe_unary_minus_func_uint64_t_u(((safe_lshift_func_uint8_t_u_s(0x08L, (safe_add_func_uint8_t_u_u((((((l_1407 > ((--l_1408) , ((*l_1431) = ((*l_1430) = (safe_sub_func_int64_t_s_s(l_1371, ((safe_add_func_uint64_t_u_u((p_27 > (g_232 = (-3L))), (safe_mul_func_uint64_t_u_u((safe_mul_func_uint32_t_u_u(((safe_mul_func_int64_t_s_s(((g_1421 , g_75) == ((*l_1422)--)), 1L)) == ((safe_div_func_uint16_t_u_u((safe_mod_func_int16_t_s_s(0x5447L, 0x13F7L)), g_217[1][6])) != 0x1EL)), l_1429)), g_133)))) >= p_27))))))) != l_1432[1][3][9]) > l_1432[1][3][9]) & g_47) <= l_1377), (*g_1032))))) < 0x7A240AC4L))), (*g_1032))), p_27)), p_27))) + { /* block id: 717 */ + int32_t *l_1433[5] = {&g_56,&g_56,&g_56,&g_56,&g_56}; + int i; + l_1434 = ((*g_292) |= l_1408); + (*g_1436) = g_1435; + } + else + { /* block id: 721 */ + int32_t *l_1437 = &g_56; + int32_t *l_1438 = &l_1407; + int32_t *l_1439 = &g_75; + int32_t *l_1440 = (void*)0; + int32_t *l_1441 = &g_75; + int32_t *l_1442 = &g_75; + int32_t *l_1443 = &g_75; + int32_t *l_1444[6] = {&g_75,&g_75,&l_1434,&g_75,&g_75,&l_1434}; + int i; + l_1446--; + (*l_1439) &= (0x7F1718226131FAB0LL < (*g_49)); + l_1434 = (safe_lshift_func_uint64_t_u_u(((safe_rshift_func_int32_t_s_s(l_1407, 27)) < l_1445), 33)); + } + if (l_1432[1][1][0]) + { /* block id: 726 */ + struct S1 l_1453 = {0x64DCEF99L}; + (****g_390) = l_1453; + if (p_27) + break; + } + else + { /* block id: 729 */ + struct S0 *l_1455[9] = {&g_128[1][3][0],&g_128[1][3][0],&g_128[1][3][0],&g_128[1][3][0],&g_128[1][3][0],&g_128[1][3][0],&g_128[1][3][0],&g_128[1][3][0],&g_128[1][3][0]}; + struct S0 *l_1456 = &g_1137; + int i; + (*l_1456) = g_1454[4]; + } + } + (***g_1335) = l_1457; + if ((p_27 | (safe_add_func_uint32_t_u_u((((void*)0 != &l_1457) < (l_1446 < 0L)), l_1446)))) + { /* block id: 734 */ + struct S1 ***l_1462 = &g_109; + int32_t l_1463 = (-10L); + for (g_232 = 0; (g_232 < 7); g_232 = safe_add_func_uint16_t_u_u(g_232, 8)) + { /* block id: 737 */ + l_1463 = ((*g_390) != (l_1462 = (*l_1386))); + g_1466 = l_1464; + } + if (p_27) + continue; + } + else + { /* block id: 743 */ + uint64_t *l_1467 = &g_57; + return l_1467; + } + if ((l_1434 = ((p_27 , (safe_sub_func_uint32_t_u_u((1UL == (l_1407 || (((*l_1472) &= 4294967295UL) > ((((safe_add_func_uint64_t_u_u((safe_rshift_func_uint8_t_u_u((((g_153 == ((((*g_1032) = l_1432[4][1][7]) , &g_1336) != &g_1336)) , 0xE38C803AL) || 0xD5774C57L), 4)), p_27)) , l_1479) == l_1479) | 1UL)))), l_1480))) >= (*g_292)))) + { /* block id: 749 */ + uint64_t l_1482[3]; + struct S1 *l_1485 = &g_63; + int i; + for (i = 0; i < 3; i++) + l_1482[i] = 0x84EFD5DBA9710534LL; + for (l_1434 = 0; (l_1434 <= 2); l_1434 += 1) + { /* block id: 752 */ + (*g_790) = &l_1434; + if (p_27) + break; + } + (*g_1481) ^= p_27; + for (g_196 = 0; (g_196 >= 0); g_196 -= 1) + { /* block id: 759 */ + uint64_t *l_1494 = &g_626[2][2][2]; + uint16_t *l_1495 = &g_919[4]; + int32_t l_1496[1]; + uint8_t *l_1497 = &l_1446; + int i, j; + for (i = 0; i < 1; i++) + l_1496[i] = 9L; + if ((*g_292)) + break; + l_1482[2] = (*g_68); + l_1500 &= (((((*l_1497) |= ((safe_sub_func_uint32_t_u_u(((*l_1472) = ((void*)0 != l_1485)), (safe_rshift_func_int32_t_s_u((g_1488 , (0xFACEE09BL < ((((safe_mul_func_uint16_t_u_u(((*l_1495) = ((g_1137.f0 , ((((****g_390) , (safe_sub_func_int32_t_s_s((((((*l_1485) = l_1493) , (*g_49)) && (((*l_1494) = 0UL) <= g_1209[0].f0)) == p_27), p_27))) <= p_27) , (void*)0)) != &g_148)), 65535UL)) < 0x808C9DFEL) < 0xF380FB42240647DBLL) || l_1496[0]))), l_1496[0])))) != l_1408)) <= 0L) , (void*)0) != g_1498); + } + } + else + { /* block id: 769 */ + int32_t *l_1501 = &l_1445; + int32_t *l_1502 = &l_1434; + int32_t ****l_1511[6][9][3] = {{{&g_1229[2][5][1],&g_1229[6][5][0],&g_1229[6][5][0]},{&g_1229[5][8][1],&g_1229[0][7][0],&g_1229[6][5][0]},{(void*)0,&g_1229[2][5][1],&g_1229[6][5][0]},{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[6][5][0]},{&g_1229[6][5][0],&g_1229[2][5][1],&g_1229[0][1][1]},{(void*)0,&g_1229[0][7][0],&g_1229[6][5][0]},{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[6][5][0]},{&g_1229[6][5][0],(void*)0,&g_1229[6][5][0]},{(void*)0,(void*)0,&g_1229[6][5][0]}},{{&g_1229[6][5][0],&g_1229[0][8][2],&g_1229[5][8][1]},{(void*)0,(void*)0,&g_1229[6][5][0]},{&g_1229[6][5][0],(void*)0,&g_1229[6][5][0]},{&g_1229[6][5][0],(void*)0,&g_1229[6][5][0]},{&g_1229[7][6][1],&g_1229[7][6][1],&g_1229[5][8][1]},{&g_1229[6][5][0],(void*)0,&g_1229[6][5][0]},{&g_1229[0][8][2],(void*)0,&g_1229[0][7][0]},{&g_1229[6][5][0],(void*)0,&g_1229[6][5][0]},{&g_1229[7][6][1],&g_1229[0][8][2],&g_1229[0][7][0]}},{{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[6][5][0]},{&g_1229[6][5][0],&g_1229[0][8][2],&g_1229[5][8][1]},{(void*)0,(void*)0,&g_1229[6][5][0]},{&g_1229[6][5][0],(void*)0,&g_1229[6][5][0]},{&g_1229[6][5][0],(void*)0,&g_1229[6][5][0]},{&g_1229[7][6][1],&g_1229[7][6][1],&g_1229[5][8][1]},{&g_1229[6][5][0],(void*)0,&g_1229[6][5][0]},{&g_1229[0][8][2],(void*)0,&g_1229[0][7][0]},{&g_1229[6][5][0],(void*)0,&g_1229[6][5][0]}},{{&g_1229[7][6][1],&g_1229[0][8][2],&g_1229[0][7][0]},{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[6][5][0]},{&g_1229[6][5][0],&g_1229[0][8][2],&g_1229[5][8][1]},{(void*)0,(void*)0,&g_1229[6][5][0]},{&g_1229[6][5][0],(void*)0,&g_1229[6][5][0]},{&g_1229[6][5][0],(void*)0,&g_1229[6][5][0]},{&g_1229[7][6][1],&g_1229[7][6][1],&g_1229[5][8][1]},{&g_1229[6][5][0],(void*)0,&g_1229[6][5][0]},{&g_1229[0][8][2],(void*)0,&g_1229[0][7][0]}},{{&g_1229[6][5][0],(void*)0,&g_1229[6][5][0]},{&g_1229[7][6][1],&g_1229[0][8][2],&g_1229[0][7][0]},{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[6][5][0]},{&g_1229[6][5][0],&g_1229[0][8][2],&g_1229[5][8][1]},{(void*)0,(void*)0,&g_1229[6][5][0]},{&g_1229[6][5][0],(void*)0,&g_1229[6][5][0]},{&g_1229[6][5][0],(void*)0,&g_1229[6][5][0]},{&g_1229[7][6][1],&g_1229[7][6][1],&g_1229[5][8][1]},{&g_1229[6][5][0],(void*)0,&g_1229[6][5][0]}},{{&g_1229[0][8][2],(void*)0,&g_1229[0][7][0]},{&g_1229[6][5][0],(void*)0,&g_1229[6][5][0]},{&g_1229[7][6][1],&g_1229[0][8][2],&g_1229[0][7][0]},{&g_1229[6][5][0],&g_1229[6][5][0],&g_1229[6][5][0]},{&g_1229[6][5][0],&g_1229[0][8][2],&g_1229[5][8][1]},{(void*)0,(void*)0,&g_1229[6][5][0]},{&g_1229[6][5][0],(void*)0,&g_1229[6][5][0]},{&g_1229[6][5][0],(void*)0,&g_1229[6][5][0]},{&g_1229[7][6][1],&g_1229[7][6][1],&g_1229[5][8][1]}}}; + uint8_t *l_1524 = &g_219; + int16_t l_1525 = 1L; + int i, j, k; + (*l_1502) = (g_692 , ((*l_1501) = (-3L))); + (*l_1501) |= (safe_mul_func_uint16_t_u_u((safe_lshift_func_int64_t_s_s((-1L), (p_27 <= ((safe_div_func_int16_t_s_s(((((*g_1227) = l_1511[4][3][0]) == l_1512[2][4][2]) < ((((safe_div_func_int8_t_s_s((safe_sub_func_int16_t_s_s(((safe_mul_func_uint32_t_u_u((l_1519 != (l_1520[0][7][0] = l_1519)), (((*l_1524) = (((safe_rshift_func_uint32_t_u_u(((void*)0 != l_1523), g_919[4])) <= 0L) || p_27)) && p_27))) | 0xD40AD63BL), g_1057)), (-8L))) <= l_1525) ^ g_975.f0) || p_27)), l_1432[1][3][9])) >= 1L)))), 0xBDCDL)); + } + } + } + if (((((l_1528 != &l_1529) == ((safe_mod_func_uint8_t_u_u(p_27, l_1446)) == (!(safe_mod_func_int8_t_s_s((-8L), 251UL))))) , (--(*l_1537))) <= (p_27 >= (l_1546 &= (l_1434 = (((safe_mul_func_uint8_t_u_u((safe_add_func_int32_t_s_s((65535UL != (++g_919[4])), p_27)), g_158)) , p_27) & g_334[3][3].f0)))))) + { /* block id: 783 */ + uint8_t l_1582[9][9] = {{0x00L,255UL,255UL,0x00L,0UL,0x00L,255UL,255UL,0x00L},{0x13L,0xAEL,7UL,0xAEL,0x13L,255UL,9UL,0x6FL,9UL},{255UL,0UL,255UL,255UL,0UL,255UL,0UL,255UL,255UL},{0x13L,255UL,9UL,0x6FL,9UL,255UL,0x13L,0xAEL,7UL},{0x00L,0UL,0x00L,255UL,255UL,0x00L,0UL,0x00L,255UL},{0xC7L,0xAEL,9UL,0x63L,0x63L,0x63L,9UL,0xAEL,0xC7L},{1UL,0x00L,0UL,0x00L,255UL,255UL,0x00L,0UL,0x00L},{0xC7L,255UL,0x63L,0xEAL,0x13L,0x63L,0x13L,0xEAL,0x63L},{255UL,255UL,0x00L,0UL,0x00L,255UL,255UL,0x00L,0UL}}; + uint32_t **l_1615 = &g_563; + int32_t *l_1657 = &l_1445; + struct S0 *l_1670 = &g_692; + int32_t l_1681 = 0x1AC2F0F7L; + union U3 * const l_1694 = &g_836; + int8_t *****l_1697[1][3][7] = {{{&g_1312,&g_1312,&g_1312,&g_1312,&g_1312,&g_1312,&g_1312},{&g_1312,&g_1312,&g_1312,&g_1312,&g_1312,&g_1312,&g_1312},{&g_1312,&g_1312,&g_1312,&g_1312,&g_1312,&g_1312,&g_1312}}}; + int32_t l_1701[7][2][8] = {{{0xDC85C32EL,0xDC85C32EL,1L,2L,(-2L),(-1L),0x93A364DFL,(-1L)},{0x65DD30DAL,0xFC8EF192L,0xBCFABD90L,(-9L),0xFC6EC840L,0xBB0E816AL,0xF577F024L,(-1L)}},{{0xFC8EF192L,0xAFADDCE6L,0xC7134EB5L,2L,(-1L),0xEE9C0E6BL,0x088C588AL,0xBB0E816AL},{8L,(-7L),0x863D79FFL,0xDC85C32EL,0x93A364DFL,0x5420C501L,0xA5A7199CL,0x93A364DFL}},{{(-1L),0xFC6EC840L,0xF577F024L,(-1L),0xA5A7199CL,(-1L),(-9L),0x893242CFL},{0xFC8EF192L,0x81C83E87L,(-1L),0x088C588AL,0xF577F024L,0xAFADDCE6L,0x893242CFL,0xAFADDCE6L}},{{(-2L),(-6L),0x30776882L,(-6L),(-2L),(-4L),8L,(-1L)},{(-1L),0xFC6EC840L,0x65DD30DAL,0xBB0E816AL,7L,(-1L),0x81C83E87L,(-6L)}},{{0x893242CFL,9L,0x65DD30DAL,(-2L),9L,0xEE9C0E6BL,8L,0x0C593A47L},{7L,6L,0x30776882L,(-1L),(-6L),1L,0x893242CFL,0xDC85C32EL}},{{(-9L),0xFC8EF192L,(-1L),(-4L),0xDC85C32EL,0xC7134EB5L,(-9L),7L},{(-7L),(-1L),0xF577F024L,(-2L),0xBB0E816AL,0x0C593A47L,0xA5A7199CL,0x81C83E87L}},{{(-1L),0x088C588AL,0x863D79FFL,(-1L),(-1L),0x863D79FFL,0x088C588AL,(-1L)},{9L,(-1L),0xC7134EB5L,0x81C83E87L,0xDC85C32EL,0x283A5D1FL,0xF577F024L,6L}}}; + int i, j, k; + if (p_27) + { /* block id: 784 */ + int32_t l_1559 = 5L; + struct S0 ***l_1580 = &g_1337; + int32_t l_1585 = (-3L); + uint16_t **l_1623[5]; + union U3 **l_1646 = (void*)0; + union U3 **l_1647 = &g_1498; + int8_t *l_1680[8][10][1] = {{{(void*)0},{&g_196},{(void*)0},{&g_196},{&g_196},{(void*)0},{&g_196},{&g_196},{&g_196},{&g_196}},{{&g_196},{(void*)0},{&g_196},{&g_196},{(void*)0},{&g_196},{(void*)0},{&g_196},{&g_196},{(void*)0}},{{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{(void*)0},{&g_196},{&g_196},{(void*)0},{&g_196}},{{(void*)0},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196}},{{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196}},{{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196}},{{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196}},{{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196},{&g_196}}}; + struct S1 l_1685 = {0xBFDFF23AL}; + int i, j, k; + for (i = 0; i < 5; i++) + l_1623[i] = (void*)0; + for (g_219 = 0; (g_219 >= 39); g_219++) + { /* block id: 787 */ + int32_t ** const *l_1614 = &g_790; + int32_t ** const **l_1613 = &l_1614; + int32_t ** const ***l_1612 = &l_1613; + int8_t **l_1654 = &g_1032; + for (g_57 = 0; (g_57 > 52); g_57 = safe_add_func_uint32_t_u_u(g_57, 3)) + { /* block id: 790 */ + struct S1 *l_1558[2]; + int32_t l_1581 = 0x05445ACDL; + uint32_t ** const l_1616 = &g_563; + uint32_t *l_1617 = &g_334[3][3].f0; + uint16_t ***l_1622 = &g_1620; + union U3 **l_1645 = &g_1498; + union U3 ***l_1644[6]; + int64_t *l_1649[6] = {&g_1499.f0,&g_1499.f0,&g_1499.f0,&g_1499.f0,&g_1499.f0,&g_1499.f0}; + int32_t l_1650 = 0x1435635BL; + int i; + for (i = 0; i < 2; i++) + l_1558[i] = &g_63; + for (i = 0; i < 6; i++) + l_1644[i] = &l_1645; + l_1582[7][4] &= (((*l_1537) = (0L <= (g_1551 , (safe_mod_func_uint32_t_u_u((((safe_mod_func_int32_t_s_s(0xE17A819AL, ((safe_lshift_func_int8_t_s_u(((l_1558[1] != (void*)0) ^ l_1559), 3)) , l_1559))) && (safe_rshift_func_uint16_t_u_u((safe_div_func_uint8_t_u_u((safe_div_func_int8_t_s_s((((p_27 >= (safe_div_func_int64_t_s_s(((safe_sub_func_uint16_t_u_u((safe_rshift_func_uint64_t_u_s(((safe_mul_func_int16_t_s_s(((((!((safe_sub_func_int32_t_s_s(((safe_mul_func_uint64_t_u_u(((l_1579[1] != l_1580) == l_1581), 1L)) , 0x127A62D7L), l_1581)) , p_27)) | 0xE0L) || (*g_1081)) != p_27), l_1493.f0)) , l_1432[1][3][9]), p_27)), 0xD53DL)) && (*g_49)), g_158))) > g_937) ^ p_27), p_27)), l_1559)), l_1493.f0))) || p_27), p_27))))) , 0L); + l_1585 = (safe_div_func_uint64_t_u_u(l_1546, 0x49492AB1E84C9302LL)); + l_1434 = (safe_sub_func_int64_t_s_s(((--(*l_1537)) >= (((*l_1617) ^= ((((safe_lshift_func_uint8_t_u_u((safe_sub_func_int64_t_s_s(p_27, 0x5D7E5D80C41E6018LL)), 1)) > (safe_add_func_int16_t_s_s((safe_mul_func_uint32_t_u_u(p_27, p_27)), ((((safe_div_func_int16_t_s_s(((safe_lshift_func_uint8_t_u_u(((l_1581 = (safe_div_func_uint32_t_u_u(p_27, (safe_add_func_uint16_t_u_u((((safe_mul_func_int16_t_s_s(((safe_mod_func_int32_t_s_s((((void*)0 != l_1612) || (((*g_1032) = p_27) == (l_1432[2][1][2] >= l_1585))), 2UL)) ^ g_234[0][2]), 0xF3B6L)) >= g_809[0]) <= p_27), 0xDFF3L))))) < 0x2C145CCDL), g_626[7][2][0])) && p_27), l_1546)) , l_1615) == l_1616) < p_27)))) ^ 0xD9L) & p_27)) != 0xEA5899D2L)), g_75)); + l_1650 ^= ((safe_sub_func_int32_t_s_s(((((*l_1622) = g_1620) == l_1623[0]) & (*g_1481)), ((safe_rshift_func_uint64_t_u_s(((safe_lshift_func_uint32_t_u_s((safe_add_func_uint32_t_u_u(g_1630, ((safe_sub_func_int64_t_s_s((g_232 = (((((safe_add_func_int32_t_s_s(((((~((safe_div_func_uint32_t_u_u((safe_sub_func_uint32_t_u_u(p_27, (safe_mod_func_int16_t_s_s((((*l_1537) = (l_1559 <= (safe_sub_func_uint64_t_u_u(((l_1646 = (p_27 , &g_1498)) != (g_1648 = l_1647)), 0x1D4932DF378304C0LL)))) > 0xF3B1D0C5L), g_1247[2])))), p_27)) || l_1585)) && l_1582[7][4]) & 0UL) , p_27), l_1581)) & 0x3FDBEF8FL) != l_1582[4][2]) , p_27) | 4294967289UL)), l_1432[1][3][9])) | 0x0DB8L))), 7)) <= p_27), g_626[5][2][2])) & l_1493.f0))) ^ l_1581); + } + if ((!((safe_rshift_func_int32_t_s_u(p_27, ((void*)0 != l_1654))) || (safe_div_func_int16_t_s_s(g_1071, p_27))))) + { /* block id: 806 */ + union U2 *l_1660[2][1][6] = {{{&g_1127,&g_1127,&g_161[1],&g_1127,&g_1127,&g_161[1]}},{{&g_1127,&g_1127,&g_161[1],&g_1127,&g_1127,&g_161[1]}}}; + int i, j, k; + (*g_790) = &l_1434; + l_1657 = &l_1585; + l_1660[0][0][5] = l_1658; + if (g_63.f0) + goto lbl_1661; + } + else + { /* block id: 811 */ + uint64_t l_1662 = 18446744073709551612UL; + l_1662 ^= (*l_1657); + ++g_1663[8][7][0]; + } + if (p_27) + continue; + } + for (g_275 = 0; (g_275 <= 2); g_275 += 1) + { /* block id: 819 */ + union U2 *l_1666 = &g_161[0]; + int32_t *l_1674 = &g_809[0]; + int32_t *l_1676[7]; + int i; + for (i = 0; i < 7; i++) + l_1676[i] = &l_1445; + (*g_1084) = l_1666; + (*g_1668) = l_1667[3][0][2]; + (***g_1335) = l_1670; + for (g_196 = 0; (g_196 <= 2); g_196 += 1) + { /* block id: 825 */ + int8_t *l_1673 = &l_1432[1][3][9]; + int32_t *l_1675 = (void*)0; + union U3 ***l_1678 = &l_1646; + union U3 ****l_1677[3]; + int i; + for (i = 0; i < 3; i++) + l_1677[i] = &l_1678; + (*l_1657) ^= (((safe_lshift_func_uint8_t_u_u((p_27 < (((((*l_1673) |= ((*g_1032) = (*g_1032))) , l_1674) != (l_1676[3] = l_1675)) | 0xBB88L)), ((((((g_1679 = &g_1648) != (void*)0) ^ ((0xF027D5CAL != ((g_700[0][0][2].f0 , 4L) != 0L)) | p_27)) , p_27) , (void*)0) != l_1680[3][3][0]))) > (*g_1621)) != p_27); + (*g_790) = l_1674; + return &g_50[1][2][1]; + } + } + l_1682--; + (****l_1386) = l_1685; + } + else + { /* block id: 837 */ + uint8_t l_1686 = 255UL; + int32_t *l_1693 = (void*)0; + l_1686++; + (*g_1689) = (*g_199); + if (g_275) + goto lbl_1692; +lbl_1692: + (*g_1691) = g_1690[0]; + (*g_790) = l_1693; + } + l_1696 |= (l_1694 != ((**g_1679) = (l_1695 , (void*)0))); + l_1701[2][0][1] |= ((l_1698 = g_1312) == (void*)0); + for (g_47 = 4; (g_47 > (-11)); g_47 = safe_sub_func_int32_t_s_s(g_47, 6)) + { /* block id: 850 */ + struct S0 *l_1705 = (void*)0; + struct S0 *l_1706[10] = {&g_987,&g_987,&g_987,&g_987,&g_987,&g_987,&g_987,&g_987,&g_987,&g_987}; + struct S0 *l_1707 = &g_70; + int i; + for (g_153 = 0; g_153 < 8; g_153 += 1) + { + for (g_937 = 0; g_937 < 10; g_937 += 1) + { + struct S1 tmp = {0x43DCE0D9L}; + g_334[g_153][g_937] = tmp; + } + } + (*l_1707) = g_1704[4]; + } + } + else + { /* block id: 854 */ + struct S1 ***l_1724 = &g_109; + int32_t l_1725 = 6L; + int8_t l_1762[10]; + int32_t l_1764[6]; + int32_t *l_1773 = &l_1725; + uint16_t l_1781 = 0xFB04L; + uint32_t l_1784 = 0xBC863C13L; + int i; + for (i = 0; i < 10; i++) + l_1762[i] = 0xD2L; + for (i = 0; i < 6; i++) + l_1764[i] = 0xE42B3BBCL; + if (p_27) + { /* block id: 855 */ + int32_t *****l_1715 = (void*)0; + l_1725 = (safe_rshift_func_int16_t_s_u(l_1710, (((0L != (safe_mod_func_int16_t_s_s(((safe_sub_func_uint32_t_u_u(0x144EDB76L, (g_63.f0 = (((((((void*)0 != l_1715) <= ((*g_1032) = (safe_lshift_func_int32_t_s_u((p_27 <= ((((safe_add_func_int8_t_s_s(((((safe_add_func_int32_t_s_s(((**g_1620) == (((!(((*g_1621) & (p_27 , (**g_1620))) >= l_1723[2][5][3])) , (void*)0) != l_1724)), 0UL)) , 0x9CL) == (*g_1081)) & 8UL), l_1725)) != 0x10E7A5DEL) && (-9L)) && 0x4401L)), p_27)))) < p_27) < p_27) , l_1725) ^ (-6L))))) != 1UL), 65535UL))) || (**g_1080)) != l_1725))); + } + else + { /* block id: 859 */ + int32_t l_1763 = (-4L); + for (g_1488.f2 = 0; (g_1488.f2 != (-14)); g_1488.f2 = safe_sub_func_int64_t_s_s(g_1488.f2, 7)) + { /* block id: 862 */ + int16_t l_1729[9][8][3] = {{{0x8FFEL,(-1L),9L},{3L,0x8993L,7L},{0x51C3L,0x1EF3L,(-1L)},{(-6L),0x151BL,0x3127L},{(-1L),0x232BL,(-6L)},{(-1L),(-10L),1L},{(-10L),3L,1L},{0x8BF4L,1L,0x825EL}},{{1L,0L,0x8993L},{0x6697L,0xD824L,(-1L)},{(-1L),1L,(-10L)},{(-1L),1L,0x1928L},{0x22E0L,0xD824L,0L},{0xF0D8L,0L,(-2L)},{0x1EF3L,1L,1L},{0x805DL,3L,(-1L)}},{{0L,(-10L),(-9L)},{1L,0x232BL,0x8BF4L},{1L,0x151BL,0xEB65L},{7L,0x1EF3L,0L},{0x7203L,0x8993L,0xFCC1L},{(-1L),(-1L),8L},{0xB386L,0x8BF4L,0xEDE9L},{3L,0xC146L,5L}},{{0x7CCAL,0xFCC1L,1L},{(-1L),3L,5L},{0x9E4EL,0x4344L,0xEDE9L},{(-1L),0xD8EEL,8L},{2L,0x51C3L,0xFCC1L},{(-5L),0x6697L,0L},{0x232BL,3L,0xEB65L},{0x3127L,9L,0x8BF4L}},{{1L,0x8C51L,(-9L)},{1L,0x22E0L,(-1L)},{0xC146L,0x361BL,1L},{0x85ACL,(-1L),(-2L)},{(-1L),(-1L),0L},{0xB62EL,(-2L),0x1928L},{0x3127L,0x85ACL,0x1928L},{0x3127L,(-2L),0x5E17L}},{{0x9B00L,(-1L),0x7203L},{0x5E17L,0xC146L,(-1L)},{(-2L),0x4871L,3L},{0x6A93L,0x0115L,0xD824L},{0x151BL,0xFCC1L,0x8FFEL},{(-6L),5L,0x7880L},{0x7880L,0L,0x232BL},{0x7A44L,(-5L),0xEDE9L}},{{0x0115L,0xB7A9L,0xB7A9L},{0x5860L,3L,1L},{1L,0xF0D8L,(-6L)},{0xFCC1L,0xEB65L,(-2L)},{0x232BL,(-1L),0x6697L},{1L,0xEB65L,1L},{1L,0xF0D8L,0x9E4EL},{0x8BF4L,3L,0x4B73L}},{{1L,0xB7A9L,5L},{0xEB65L,(-5L),0x0882L},{0x4344L,0L,1L},{7L,5L,0xEB65L},{0xC146L,0xFCC1L,0x805DL},{0xB15FL,0x0115L,0x7CCAL},{2L,0x4871L,0L},{0x0FA2L,0xC146L,1L}},{{1L,(-1L),0xFB11L},{(-9L),(-2L),0x3F95L},{(-1L),0x85ACL,0x3F95L},{0x22E0L,(-5L),0xFB11L},{0x0882L,0x232BL,1L},{0x9E4EL,1L,0L},{1L,(-1L),0x7CCAL},{0x1928L,(-9L),0x805DL}}}; + int32_t l_1739 = 0x4C6439FBL; + int i, j, k; + l_1729[3][5][0] = g_1728; + for (l_1695 = 0; (l_1695 <= 3); l_1695 += 1) + { /* block id: 866 */ + uint8_t *l_1738 = &l_1446; + int16_t *l_1740 = &g_937; + struct S0 *l_1743[4] = {&g_1454[4],&g_1454[4],&g_1454[4],&g_1454[4]}; + int32_t l_1744 = 0xD365A795L; + int i, j; + l_1744 = ((0x7EL <= ((safe_rshift_func_int32_t_s_u((safe_add_func_int16_t_s_s(g_217[(l_1695 + 1)][(l_1695 + 6)], (safe_rshift_func_int64_t_s_u(((((safe_add_func_uint8_t_u_u((l_1739 = ((*l_1738) = g_763[0])), (p_27 , p_27))) | (((g_987.f0 ^ (l_1725 ^ ((*l_1740) = g_50[7][3][0]))) && ((safe_lshift_func_int64_t_s_u(((l_1743[2] != (void*)0) != p_27), 12)) < g_217[(l_1695 + 1)][(l_1695 + 6)])) | p_27)) & 6UL) & 0UL), 19)))), 23)) == p_27)) != l_1729[3][5][0]); + l_1762[4] = (((*g_1081) ^ (safe_sub_func_uint16_t_u_u((safe_div_func_int64_t_s_s(((((safe_rshift_func_uint32_t_u_u((((safe_add_func_uint16_t_u_u(l_1739, (((((p_27 == p_27) | ((((~4294967293UL) > ((*l_1738) &= (safe_div_func_uint16_t_u_u(p_27, p_27)))) <= ((safe_div_func_int8_t_s_s(p_27, (safe_rshift_func_uint8_t_u_s(((((l_1760 ^ l_1729[0][3][1]) , 0x7B2434B412CD231BLL) | p_27) < p_27), (*g_1032))))) , l_1761)) & 4UL)) ^ g_1247[0]) || g_763[0]) < l_1729[3][5][0]))) , &g_153) == (void*)0), 29)) <= g_275) >= 0UL) , l_1739), 0x0082230FD7D79EA6LL)), l_1725))) < 0x744EA9BBL); + ++l_1765; + } + (*g_1040) = &l_1763; + return &g_171; + } + } + for (l_1695 = (-14); (l_1695 <= 2); l_1695 = safe_add_func_uint32_t_u_u(l_1695, 7)) + { /* block id: 881 */ + int32_t l_1774[9] = {0x0D739129L,0xF563B1EEL,0x0D739129L,0x0D739129L,0xF563B1EEL,0x0D739129L,0x0D739129L,0xF563B1EEL,0x0D739129L}; + int32_t l_1775 = 0xA818E238L; + int32_t l_1778 = (-1L); + int i; + for (g_153 = 11; (g_153 != (-17)); g_153--) + { /* block id: 884 */ + int32_t *l_1772 = (void*)0; + int32_t l_1776 = 0x4355EEE4L; + int32_t l_1777 = 5L; + int32_t l_1779 = 0xF3A1817FL; + int32_t l_1780 = 0x4701FC84L; + l_1772 = (void*)0; + l_1773 = l_1772; + l_1781++; + if (l_1775) + break; + } + } + (*g_790) = &l_1764[4]; + l_1784++; + } + if (p_27) + { /* block id: 894 */ + int32_t *l_1789 = &g_809[0]; + int16_t l_1828 = 0x6D87L; + const struct S1 l_1831 = {0xB4257694L}; + union U3 * const l_1843[1] = {&g_1499}; + union U2 *l_1867[2][2]; + int32_t l_1869[5]; + int i, j; + for (i = 0; i < 2; i++) + { + for (j = 0; j < 2; j++) + l_1867[i][j] = &g_679; + } + for (i = 0; i < 5; i++) + l_1869[i] = (-10L); + for (g_1488.f2 = 0; (g_1488.f2 >= (-10)); g_1488.f2--) + { /* block id: 897 */ + int32_t *l_1807 = &g_1127.f2; + int32_t l_1808 = 1L; + uint32_t **l_1809 = (void*)0; + union U3 ***l_1835 = (void*)0; + uint32_t l_1837 = 0UL; + int32_t l_1870[2]; + int i; + for (i = 0; i < 2; i++) + l_1870[i] = 0xA2CBE9BFL; + } + l_1874--; + } + else + { /* block id: 951 */ + int32_t l_1877 = 0x32EF1ECAL; + g_1881 = (l_1877 , l_1878[3]); + } + } + else + { /* block id: 954 */ + int8_t *****l_1894 = (void*)0; + int32_t l_1895[2]; + int32_t l_1931 = 0x10267816L; + uint8_t l_1932[10]; + uint64_t l_1996 = 18446744073709551615UL; + int16_t l_2002 = 0xF4E9L; + int32_t *l_2036[7][5] = {{&l_1931,&l_1931,&g_75,&g_56,&g_75},{&g_56,&g_56,&l_1895[0],&g_75,&l_1895[0]},{&l_1931,&l_1931,&g_75,&g_56,&g_75},{&g_56,&g_56,&l_1895[0],&g_75,&l_1895[0]},{&l_1931,&l_1931,&g_75,&g_56,&g_75},{&g_56,&g_56,&l_1895[0],&g_75,&l_1895[0]},{&l_1931,&l_1931,&g_75,&g_56,&g_75}}; + const struct S0 **l_2064 = &g_72; + const struct S0 ***l_2063 = &l_2064; + const struct S0 ****l_2062 = &l_2063; + uint32_t l_2067 = 0xF8B00C13L; + uint32_t l_2094[8] = {0UL,4294967295UL,0UL,4294967295UL,0UL,4294967295UL,0UL,4294967295UL}; + int i, j; + for (i = 0; i < 2; i++) + l_1895[i] = 0x410216F1L; + for (i = 0; i < 10; i++) + l_1932[i] = 1UL; + for (l_1371 = 0; (l_1371 <= 1); l_1371 += 1) + { /* block id: 957 */ + const int16_t l_1886[10][4] = {{0L,0xFC46L,0xFC46L,0L},{0xFC46L,0L,0xFC46L,0xFC46L},{0L,0L,0xD48AL,0L},{0L,0xFC46L,0xFC46L,0L},{0xFC46L,0L,0xFC46L,0xFC46L},{0L,0L,0xD48AL,0L},{0L,0xFC46L,0xFC46L,0L},{0xFC46L,0L,0xFC46L,0xFC46L},{0xFC46L,0xFC46L,0L,0xFC46L},{0xFC46L,0xD48AL,0xD48AL,0xFC46L}}; + int32_t l_1970 = 0xF67834E3L; + int32_t l_1971 = (-1L); + int32_t l_1972 = 0L; + int32_t l_1973[10][8] = {{0xEA30DD80L,0L,0xEA30DD80L,(-3L),1L,(-3L),0xEA30DD80L,0L},{1L,(-3L),0xEA30DD80L,0L,0xEA30DD80L,(-3L),1L,(-3L)},{1L,0L,(-1L),0L,1L,0L,1L,0L},{0xEA30DD80L,0L,0xEA30DD80L,(-3L),1L,(-3L),0xEA30DD80L,0L},{1L,(-3L),0xEA30DD80L,0L,0xEA30DD80L,(-3L),1L,(-3L)},{1L,0L,(-1L),0L,1L,0L,1L,0L},{0xEA30DD80L,0L,0xEA30DD80L,(-3L),1L,(-3L),0xEA30DD80L,0L},{1L,(-3L),0xEA30DD80L,0L,0xEA30DD80L,(-3L),1L,(-3L)},{1L,0L,(-1L),0L,1L,0L,1L,0L},{0xEA30DD80L,0L,0xEA30DD80L,(-3L),1L,(-3L),0xEA30DD80L,0L}}; + uint64_t l_1975 = 18446744073709551614UL; + struct S1 l_2000 = {0xD4C4C1F6L}; + uint32_t l_2033 = 4294967295UL; + int i, j; + l_1895[0] = ((safe_rshift_func_int8_t_s_s(((((l_1886[2][2] , (!((safe_rshift_func_uint32_t_u_u(0x4CCAC8FCL, (p_27 > l_1886[2][2]))) < ((safe_sub_func_uint32_t_u_u((((g_1704[(l_1371 + 1)] , g_1704[(l_1371 + 1)].f0) == p_27) && (p_27 == ((g_554 , &g_1312) != l_1894))), 0xAA2828B5L)) >= 1L)))) | p_27) & 0x8346L) > 6L), 2)) | l_1886[6][2]); + } + l_2036[6][1] = &l_1895[1]; + if ((*g_292)) + { /* block id: 1020 */ + const int8_t l_2051 = 0x5DL; + int64_t *l_2054 = (void*)0; + int64_t *l_2055 = &g_1499.f0; + int32_t l_2056 = (-9L); + l_2056 |= (safe_mul_func_int32_t_s_s((safe_div_func_uint16_t_u_u((((*l_1374) = (((safe_lshift_func_int8_t_s_s(((safe_add_func_int32_t_s_s(0xCFEFFDD8L, 4294967291UL)) > (safe_mul_func_int16_t_s_s(((safe_rshift_func_uint8_t_u_u((safe_lshift_func_uint8_t_u_u((p_27 >= 255UL), 4)), ((****g_1082) , (0xCF57BD49L == (((l_2051 , g_50[1][2][1]) && (((((*l_2055) &= (safe_lshift_func_int16_t_s_u(l_2051, (**g_1620)))) == g_554) >= p_27) & 0x902EDCCFL)) , 0x06D322C3L))))) | 0x62L), g_1247[0]))), p_27)) < p_27) && p_27)) ^ (-4L)), 0xB9B2L)), p_27)); + } + else + { /* block id: 1024 */ + uint32_t l_2059[6][3] = {{1UL,1UL,7UL},{0x5ABCD0C2L,0x4F48F8CFL,4294967293UL},{0xEF97DA92L,1UL,0xEF97DA92L},{0xEF97DA92L,0x5ABCD0C2L,1UL},{0x5ABCD0C2L,0xEF97DA92L,0xEF97DA92L},{1UL,0xEF97DA92L,4294967293UL}}; + int32_t l_2060 = 0x650E2F9EL; + int64_t l_2065 = 1L; + int32_t l_2066 = 1L; + struct S1 l_2095 = {0UL}; + int32_t l_2097 = 0x780AA849L; + int32_t l_2098[5]; + int i, j; + for (i = 0; i < 5; i++) + l_2098[i] = 0xA961F706L; + l_2066 |= (l_2065 = (((((****g_1082) > p_27) > g_1663[8][7][0]) ^ ((((l_2060 = (p_27 ^ (safe_lshift_func_int64_t_s_u(l_2059[4][1], 57)))) != ((void*)0 == l_2061)) == ((&g_1336 == l_2062) , p_27)) & p_27)) != g_63.f0)); + if ((0x2CFAEA1449893E23LL ^ (*g_49))) + { /* block id: 1028 */ + l_2067--; + return &g_133; + } + else + { /* block id: 1031 */ + uint8_t l_2070 = 255UL; + int32_t *l_2079 = (void*)0; + int32_t *l_2080 = (void*)0; + int32_t *l_2081 = &g_1127.f2; + int32_t l_2096 = 0xC255C251L; + int32_t l_2099 = 0x8059A9A1L; + int32_t l_2100 = 0x054613D0L; + int32_t l_2104 = 0xA44D6A85L; + l_2070++; + l_2060 &= ((g_2073 , (l_2066 = (((void*)0 == (*g_1335)) & (((safe_lshift_func_uint32_t_u_u(((((safe_mul_func_int32_t_s_s((g_2078 , (p_27 && (((*l_2081) = (p_27 && (-4L))) , (safe_add_func_uint32_t_u_u(((safe_sub_func_int32_t_s_s(((safe_lshift_func_int8_t_s_u(((safe_div_func_int64_t_s_s(((safe_sub_func_uint8_t_u_u(((safe_sub_func_uint16_t_u_u(((**g_1620) = p_27), 0xE552L)) >= (-7L)), g_809[0])) < p_27), l_2094[1])) , (-1L)), 5)) < p_27), 0x8AA0CF92L)) & (*g_1081)), 0x5026629FL))))), (-7L))) , l_2095) , 4294967295UL) == (-2L)), 19)) <= 1L) || 0xEE8BL)))) < p_27); + g_2101--; + l_2105--; + } + } + } + return l_2108[2][5]; +} + + +/* ------------------------------------------ */ +/* + * reads : g_1057 g_63.f0 g_1071 g_790 g_163 g_75 g_217 g_906 g_1079 g_1082 g_1084 g_836.f2 g_109 g_62 g_1080 g_1081 g_162 g_390 g_391 g_919 g_56 g_275 g_1116 g_809 g_334.f0 g_741 g_49 g_763 g_700.f0 g_937 g_626 g_1137 g_1138 g_1032 g_48 g_57 g_554 g_47 g_50 g_347 g_196 g_133 g_13 g_148 g_1209 g_153 g_270 g_128 g_1305 g_1312 g_276.f0 g_1335 g_171 g_94 + * writes: g_1057 g_836.f2 g_63.f0 g_217 g_906 g_1079 g_741 g_275 g_75 g_1005 g_334.f0 g_50 g_763 g_554 g_679.f2 g_196 g_163 g_133 g_692 g_1312 g_148 g_153 g_158 + */ +static int16_t func_30(uint64_t p_31) +{ /* block id: 2 */ + struct S1 l_172 = {4294967293UL}; + int32_t l_364 = (-10L); + struct S1 ***l_389[4]; + struct S1 ****l_388[4][6] = {{&l_389[1],&l_389[1],&l_389[2],&l_389[2],&l_389[1],&l_389[1]},{&l_389[2],&l_389[1],&l_389[2],&l_389[1],&l_389[2],&l_389[2]},{&l_389[0],&l_389[1],&l_389[1],&l_389[0],&l_389[1],&l_389[0]},{&l_389[0],&l_389[1],&l_389[0],&l_389[1],&l_389[1],&l_389[0]}}; + int32_t l_394 = (-1L); + int32_t l_395 = 1L; + int32_t l_397 = 0xA50664DFL; + int32_t l_398 = 0L; + int32_t l_402 = 1L; + int32_t l_409[8][5] = {{(-8L),(-8L),(-5L),0x6DA56A92L,0x85E88D1CL},{6L,0L,0L,6L,(-8L)},{6L,0x6DA56A92L,0x80A79286L,0x80A79286L,0x6DA56A92L},{(-8L),0L,0x80A79286L,(-5L),(-5L)},{0L,(-8L),0L,0x80A79286L,(-5L)},{0x6DA56A92L,6L,(-5L),6L,0x6DA56A92L},{0L,6L,(-8L),0x6DA56A92L,(-8L)},{(-8L),(-8L),(-5L),0x6DA56A92L,0x85E88D1CL}}; + uint16_t l_429 = 0UL; + int32_t **l_434 = (void*)0; + int32_t ***l_433[9] = {&l_434,&l_434,&l_434,&l_434,&l_434,&l_434,&l_434,&l_434,&l_434}; + int16_t l_475 = 6L; + int64_t *l_529 = &g_232; + int32_t l_545[4][10] = {{(-9L),(-9L),(-9L),(-9L),(-9L),(-9L),(-9L),(-9L),(-9L),(-9L)},{(-9L),(-9L),(-9L),(-9L),(-9L),(-9L),(-9L),(-9L),(-9L),(-9L)},{(-9L),(-9L),(-9L),(-9L),(-9L),(-9L),(-9L),(-9L),(-9L),(-9L)},{(-9L),(-9L),(-9L),(-9L),(-9L),(-9L),(-9L),(-9L),(-9L),(-9L)}}; + int32_t l_547 = (-1L); + uint64_t *l_575[8][6] = {{&g_57,&g_50[1][2][1],&g_50[1][2][1],&g_57,&g_133,&g_133},{&g_133,&g_57,&g_57,&g_57,&g_133,&g_171},{&g_57,&g_133,&g_171,&g_171,&g_133,&g_57},{&g_50[1][2][1],&g_57,&g_133,&g_133,&g_133,&g_57},{&g_133,&g_50[1][2][1],&g_171,&g_57,&g_57,&g_171},{&g_133,&g_133,&g_57,&g_133,&g_57,&g_133},{&g_50[1][2][1],&g_133,&g_50[1][2][1],&g_171,&g_57,&g_57},{&g_57,&g_50[1][2][1],&g_50[1][2][1],&g_57,&g_133,&g_133}}; + const int32_t *l_627 = &l_395; + int64_t l_649[4][6][2] = {{{7L,7L},{0x9C5268C5D724EB6ELL,0xD999E7DA5EE7AB9ALL},{1L,0x58CF5B2E159407CALL},{0L,0x8C0ECA768F9A0262LL},{0xDA04F5018737E6D1LL,0L},{0x9A19C746039BC216LL,0x0C978D107DC8F233LL}},{{0x9A19C746039BC216LL,0L},{0xDA04F5018737E6D1LL,0x8C0ECA768F9A0262LL},{0L,0x58CF5B2E159407CALL},{1L,0xD999E7DA5EE7AB9ALL},{0x9C5268C5D724EB6ELL,7L},{7L,0L}},{{0x44257EF90C40A65ELL,(-1L)},{0L,0x9A19C746039BC216LL},{(-9L),0x1F3381FBCB653DE0LL},{0xD999E7DA5EE7AB9ALL,0x4A53F7346734966FLL},{0L,9L},{0x1F3381FBCB653DE0LL,9L}},{{0L,0x4A53F7346734966FLL},{0xD999E7DA5EE7AB9ALL,0x1F3381FBCB653DE0LL},{(-9L),0x9A19C746039BC216LL},{0L,(-1L)},{0x44257EF90C40A65ELL,0L},{7L,7L}}}; + const uint32_t l_674 = 4UL; + uint32_t l_703 = 0xFC159BADL; + int8_t l_784 = 0x8FL; + uint32_t *l_881 = &g_763[0]; + union U2 *l_918[6][6][6] = {{{&g_161[1],&g_161[1],&g_161[1],&g_161[1],(void*)0,&g_161[1]},{(void*)0,&g_161[1],&g_161[0],&g_161[1],&g_161[1],&g_161[1]},{&g_161[1],(void*)0,&g_161[0],(void*)0,&g_161[1],&g_161[1]},{(void*)0,(void*)0,&g_161[1],(void*)0,&g_161[1],(void*)0},{(void*)0,&g_161[1],(void*)0,(void*)0,(void*)0,(void*)0},{&g_161[1],&g_161[1],&g_161[1],&g_161[1],(void*)0,&g_161[1]}},{{(void*)0,&g_161[1],&g_161[0],&g_161[1],&g_161[1],&g_161[1]},{&g_161[1],(void*)0,&g_161[0],(void*)0,&g_161[1],&g_161[1]},{(void*)0,(void*)0,&g_161[1],(void*)0,&g_161[1],(void*)0},{(void*)0,&g_161[1],(void*)0,(void*)0,(void*)0,(void*)0},{&g_161[1],&g_161[1],&g_161[1],&g_161[1],(void*)0,&g_161[1]},{(void*)0,&g_679,&g_161[1],&g_161[1],&g_679,(void*)0}},{{&g_161[1],(void*)0,&g_161[1],(void*)0,&g_161[1],(void*)0},{&g_161[1],(void*)0,(void*)0,&g_161[1],&g_679,&g_161[1]},{&g_161[1],&g_679,&g_161[1],(void*)0,(void*)0,&g_161[1]},{&g_161[1],&g_161[1],(void*)0,&g_161[1],(void*)0,(void*)0},{(void*)0,&g_679,&g_161[1],&g_161[1],&g_679,(void*)0},{&g_161[1],(void*)0,&g_161[1],(void*)0,&g_161[1],(void*)0}},{{&g_161[1],(void*)0,(void*)0,&g_161[1],&g_679,&g_161[1]},{&g_161[1],&g_679,&g_161[1],(void*)0,(void*)0,&g_161[1]},{&g_161[1],&g_161[1],(void*)0,&g_161[1],(void*)0,(void*)0},{(void*)0,&g_679,&g_161[1],&g_161[1],&g_679,(void*)0},{&g_161[1],(void*)0,&g_161[1],(void*)0,&g_161[1],(void*)0},{&g_161[1],(void*)0,(void*)0,&g_161[1],&g_679,&g_161[1]}},{{&g_161[1],&g_679,&g_161[1],(void*)0,(void*)0,&g_161[1]},{&g_161[1],&g_161[1],(void*)0,&g_161[1],(void*)0,(void*)0},{(void*)0,&g_679,&g_161[1],&g_161[1],&g_679,(void*)0},{&g_161[1],(void*)0,&g_161[1],(void*)0,&g_161[1],(void*)0},{&g_161[1],(void*)0,(void*)0,&g_161[1],&g_679,&g_161[1]},{&g_161[1],&g_679,&g_161[1],(void*)0,(void*)0,&g_161[1]}},{{&g_161[1],&g_161[1],(void*)0,&g_161[1],(void*)0,(void*)0},{(void*)0,&g_679,&g_161[1],&g_161[1],&g_679,(void*)0},{&g_161[1],(void*)0,&g_161[1],(void*)0,&g_161[1],(void*)0},{&g_161[1],(void*)0,(void*)0,&g_161[1],&g_679,&g_161[1]},{&g_161[1],&g_679,&g_161[1],(void*)0,(void*)0,&g_161[1]},{&g_161[1],&g_161[1],(void*)0,&g_161[1],(void*)0,(void*)0}}}; + int32_t l_1001 = (-4L); + struct S0 *l_1004[4] = {&g_1005,&g_1005,&g_1005,&g_1005}; + int16_t l_1200[8][8] = {{0x6EF8L,8L,0x8E2CL,0x44F2L,0x8E2CL,8L,0x6EF8L,0x8E2CL},{9L,0xB7C4L,0x5EECL,9L,0xA386L,0xEABAL,0xB7C4L,0xB7C4L},{0x8E2CL,0xA386L,0xCDF0L,0xCDF0L,0xA386L,0x8E2CL,9L,0x44F2L},{9L,9L,0xEB69L,0xB7C4L,0x8E2CL,0xEB69L,0xA386L,0xEB69L},{0x6EF8L,0xB7C4L,1L,0xB7C4L,0x6EF8L,0xB7C4L,0xEB69L,9L},{0x5EECL,0x8E2CL,0xEABAL,0x057DL,0xEB69L,0x5EECL,0x5EECL,0xEB69L},{0xCDF0L,0xEABAL,0xEABAL,0xCDF0L,0xB994L,1L,0xEB69L,0xEABAL},{0xEB69L,8L,0xA386L,9L,8L,9L,8L,9L}}; + int16_t l_1238 = 0xB2C7L; + int8_t *** const *l_1310 = (void*)0; + int32_t **** const *l_1321[6]; + int32_t l_1345 = 0xD2F614B2L; + union U3 *l_1346[9][5] = {{&g_836,(void*)0,&g_836,(void*)0,&g_836},{&g_836,&g_836,&g_836,&g_836,&g_836},{&g_836,&g_836,&g_836,(void*)0,&g_836},{&g_836,&g_836,(void*)0,&g_836,&g_836},{&g_836,&g_836,&g_836,(void*)0,(void*)0},{&g_836,&g_836,&g_836,(void*)0,(void*)0},{&g_836,&g_836,&g_836,&g_836,&g_836},{&g_836,&g_836,&g_836,&g_836,(void*)0},{&g_836,&g_836,&g_836,&g_836,&g_836}}; + uint16_t *l_1363 = &g_919[8]; + uint16_t **l_1362 = &l_1363; + uint32_t *l_1367 = &g_334[3][3].f0; + int16_t *l_1368 = &g_153; + int i, j, k; + for (i = 0; i < 4; i++) + l_389[i] = &g_109; + for (i = 0; i < 6; i++) + l_1321[i] = &g_1228; + if (p_31) + { /* block id: 3 */ + int64_t l_44[9] = {0x55B65AB4D258D033LL,(-6L),0x55B65AB4D258D033LL,(-6L),0x55B65AB4D258D033LL,(-6L),0x55B65AB4D258D033LL,(-6L),0x55B65AB4D258D033LL}; + uint64_t * const l_54 = &g_50[2][4][1]; + struct S0 *l_371 = &g_70; + struct S0 **l_370 = &l_371; + struct S1 *l_393[5] = {&g_334[3][3],&g_334[3][3],&g_334[3][3],&g_334[3][3],&g_334[3][3]}; + int32_t l_396 = 0xFD2A935EL; + int32_t l_404 = (-1L); + int32_t l_408 = 0x2B7B50C5L; + int32_t l_410 = 6L; + int32_t l_411 = 0x83BFA716L; + int32_t l_413 = (-8L); + int32_t l_414 = 4L; + uint64_t l_415 = 0x44300DDB63E37F81LL; + int32_t l_427 = 0x56753B81L; + int32_t l_428 = 0x8B0039A6L; + int32_t **l_484 = &g_163; + int32_t l_548 = 0x7A56EFE5L; + int32_t l_549 = 3L; + int32_t l_550 = 1L; + int32_t l_551 = 0x442D0EE0L; + int32_t l_552 = 1L; + int32_t l_553 = 0x78A24B4AL; + int32_t l_555[4][5][7] = {{{0xFF8045ECL,0x948B536AL,(-5L),0x948B536AL,0xFF8045ECL,0x948B536AL,(-5L)},{1L,4L,(-8L),(-8L),4L,1L,0xDA4DE453L},{1L,0xA6A92AC8L,1L,0x948B536AL,1L,0xA6A92AC8L,1L},{1L,(-8L),0xDA4DE453L,4L,4L,0xDA4DE453L,(-8L)},{0xFF8045ECL,0xA6A92AC8L,(-5L),0xA6A92AC8L,0xFF8045ECL,0xA6A92AC8L,(-5L)}},{{4L,4L,0xDA4DE453L,(-8L),1L,1L,(-8L)},{1L,0x948B536AL,1L,0xA6A92AC8L,1L,0x948B536AL,1L},{4L,(-8L),(-8L),4L,1L,0xDA4DE453L,0xDA4DE453L},{0xFF8045ECL,0x948B536AL,(-5L),0x948B536AL,0xFF8045ECL,0x948B536AL,(-5L)},{1L,4L,(-8L),(-8L),4L,1L,0xDA4DE453L}},{{1L,0xA6A92AC8L,1L,0x948B536AL,1L,0xA6A92AC8L,1L},{1L,(-8L),0xDA4DE453L,4L,4L,0xDA4DE453L,(-8L)},{0xFF8045ECL,0xA6A92AC8L,(-5L),0xA6A92AC8L,0xFF8045ECL,0xA6A92AC8L,(-5L)},{4L,4L,0xDA4DE453L,(-8L),1L,1L,(-8L)},{1L,0x948B536AL,1L,0xA6A92AC8L,1L,0x948B536AL,1L}},{{4L,(-8L),(-8L),4L,1L,0xDA4DE453L,0xDA4DE453L},{0xFF8045ECL,0x948B536AL,(-5L),0x948B536AL,0xFF8045ECL,0x948B536AL,(-5L)},{1L,4L,(-8L),(-8L),4L,1L,0xDA4DE453L},{1L,0xA6A92AC8L,1L,0x948B536AL,1L,0xA6A92AC8L,1L},{1L,(-8L),0xDA4DE453L,4L,4L,0xDA4DE453L,(-8L)}}}; + uint32_t *l_564 = (void*)0; + uint32_t l_604 = 0x13A9F2F3L; + int16_t l_644 = (-1L); + uint32_t l_712 = 0x78C9D662L; + int32_t l_813 = 0x7913D635L; + uint16_t l_827 = 1UL; + int8_t l_861 = (-1L); + const struct S1 ***l_904 = &g_900; + const struct S1 **** const l_903 = &l_904; + const struct S1 **** const *l_902 = &l_903; + uint16_t l_934 = 65527UL; + const int32_t *l_940 = &l_409[3][2]; + struct S1 **l_961[4] = {&l_393[4],&l_393[4],&l_393[4],&l_393[4]}; + uint32_t l_1055 = 4294967288UL; + int i, j, k; + } + else + { /* block id: 521 */ + struct S1 *****l_1056[1]; + int32_t l_1062[2]; + int8_t **l_1098 = &g_1032; + int8_t ***l_1097 = &l_1098; + int8_t ****l_1096 = &l_1097; + uint32_t l_1187 = 4294967295UL; + int32_t l_1216 = 0x28A188F0L; + uint8_t l_1248 = 0x8BL; + union U2 *l_1269 = (void*)0; + uint16_t l_1296 = 65526UL; + uint32_t *l_1302 = &l_703; + int8_t *** const **l_1311 = &l_1310; + int8_t *****l_1313 = &g_1312; + int16_t *l_1314 = &g_148; + int16_t *l_1322 = &g_153; + struct S0 ** const **l_1344 = (void*)0; + int i; + for (i = 0; i < 1; i++) + l_1056[i] = &l_388[2][2]; + for (i = 0; i < 2; i++) + l_1062[i] = 0L; +lbl_1086: + g_1057 |= (0xB281L > ((void*)0 == l_1056[0])); +lbl_1115: + for (l_784 = 17; (l_784 >= 4); l_784--) + { /* block id: 525 */ + uint8_t l_1070 = 0x22L; + int16_t l_1085 = 0xEAB8L; + struct S1 *l_1087 = &g_334[3][3]; + for (g_836.f2 = 0; (g_836.f2 <= 21); g_836.f2++) + { /* block id: 528 */ + uint32_t *l_1067 = &g_63.f0; + uint8_t *l_1076 = &g_217[1][8]; + union U2 *l_1083 = &g_161[1]; + l_1062[0] ^= 9L; + if ((safe_add_func_int8_t_s_s(((safe_rshift_func_uint32_t_u_s(((*l_1067)--), (l_1070 < g_1071))) < 5UL), ((*l_1076) |= (safe_lshift_func_uint16_t_u_u(l_1062[0], (safe_div_func_int32_t_s_s(l_1070, (**g_790))))))))) + { /* block id: 532 */ + for (g_906 = 0; (g_906 <= 11); g_906++) + { /* block id: 535 */ + (*g_1082) = g_1079[1]; + } + } + else + { /* block id: 538 */ + (*g_1084) = l_1083; + } + if (p_31) + continue; + if (l_1085) + break; + } + if (g_836.f2) + goto lbl_1086; + l_1087 = (*g_109); + } + for (l_703 = 0; (l_703 <= 8); l_703 += 1) + { /* block id: 549 */ + uint8_t l_1091 = 0xDAL; + int32_t l_1111 = 0L; + uint32_t **l_1140 = (void*)0; + uint32_t l_1143 = 0xE5E5EFDDL; + int32_t l_1176[9][8] = {{0L,0x716B28A5L,0L,(-7L),0L,0x716B28A5L,0L,1L},{(-1L),0x7A1433B0L,0xC41B7D05L,(-7L),0L,5L,0xAAEFE5BBL,0xD9F27F3FL},{1L,(-7L),0L,9L,0L,9L,0L,(-7L)},{(-1L),0x716B28A5L,1L,0xD9F27F3FL,0L,9L,(-1L),1L},{0L,(-7L),0xC41B7D05L,0x7A1433B0L,(-1L),5L,(-1L),0x7A1433B0L},{1L,0x7A1433B0L,1L,9L,0xAAEFE5BBL,0x716B28A5L,0L,0x7A1433B0L},{0xAAEFE5BBL,0x716B28A5L,0L,0x7A1433B0L,0L,1L,0xAAEFE5BBL,1L},{0xAAEFE5BBL,0xD9F27F3FL,0xC41B7D05L,0xD9F27F3FL,0xAAEFE5BBL,5L,0L,(-7L)},{1L,0xD9F27F3FL,0L,9L,(-1L),1L,0L,0xD9F27F3FL}}; + const struct S0 ** volatile *l_1182 = &g_71; + int32_t l_1245 = (-1L); + int32_t ****l_1267 = &l_433[7]; + uint64_t l_1268 = 18446744073709551610UL; + int i, j; + if ((((safe_lshift_func_int8_t_s_s(0xC1L, 7)) , (+l_1091)) == ((((void*)0 == &l_918[0][0][4]) <= ((****g_1082) && (1L ^ (((l_1062[0] , l_1062[0]) ^ p_31) | l_1062[0])))) < (*g_163)))) + { /* block id: 550 */ + int8_t ** const *l_1101[4]; + int8_t ** const **l_1100[1]; + int i; + for (i = 0; i < 4; i++) + l_1101[i] = &l_1098; + for (i = 0; i < 1; i++) + l_1100[i] = &l_1101[3]; + for (l_784 = 3; (l_784 >= 0); l_784 -= 1) + { /* block id: 553 */ + int8_t *****l_1099 = &l_1096; + int i; + if (((safe_rshift_func_uint32_t_u_s(((safe_div_func_uint32_t_u_u((((*l_1099) = l_1096) == l_1100[0]), (**g_162))) && 18446744073709551615UL), 12)) > (((safe_unary_minus_func_int16_t_s((safe_unary_minus_func_int64_t_s((((((l_389[l_784] = l_389[l_784]) == (*g_390)) <= 6UL) >= p_31) > ((safe_div_func_uint64_t_u_u(p_31, g_919[2])) & (-1L))))))) == 0xCDL) , (**g_790)))) + { /* block id: 556 */ + int32_t l_1106 = 0x18A2393CL; + uint32_t *l_1107 = &g_63.f0; + uint16_t *l_1110 = &g_275; + (*g_163) = (l_1062[0] > ((*l_1110) &= (l_1106 , (g_56 ^ ((*l_1107)++))))); + return p_31; + } + else + { /* block id: 561 */ + uint64_t l_1112 = 0UL; + l_1112++; + if (g_63.f0) + goto lbl_1115; + } + } + g_1005 = g_1116; + return p_31; + } + else + { /* block id: 568 */ + union U2 *l_1126 = &g_1127; + int64_t l_1141 = (-1L); + int8_t l_1142 = 0x8BL; + for (g_906 = 0; (g_906 <= 2); g_906 += 1) + { /* block id: 571 */ + uint64_t l_1123[5][4] = {{0UL,18446744073709551611UL,0UL,18446744073709551611UL},{0UL,18446744073709551611UL,0UL,18446744073709551611UL},{0UL,18446744073709551611UL,0UL,18446744073709551611UL},{0UL,18446744073709551611UL,0UL,18446744073709551611UL},{0UL,18446744073709551611UL,0UL,18446744073709551611UL}}; + uint32_t *l_1124 = &g_1057; + union U2 **l_1125 = &l_918[4][1][2]; + int8_t *l_1130 = &g_196; + int i, j; + for (l_1091 = 0; (l_1091 <= 2); l_1091 += 1) + { /* block id: 574 */ + uint16_t l_1117 = 0UL; + int32_t l_1118[8][1][2] = {{{(-4L),0xC076973CL}},{{(-4L),0xC076973CL}},{{(-4L),0xC076973CL}},{{(-4L),0xC076973CL}},{{(-4L),0xC076973CL}},{{(-4L),0xC076973CL}},{{(-4L),0xC076973CL}},{{(-4L),0xC076973CL}}}; + int i, j, k; + l_1111 |= ((**g_790) = l_1117); + l_1118[5][0][0] = (-1L); + if (l_1062[0]) + break; + } + if ((safe_sub_func_int16_t_s_s(((((p_31 = ((((safe_lshift_func_uint16_t_u_s((((p_31 && (g_809[0] | (((*l_881) ^= ((((*l_1124) = l_1123[4][2]) == (g_334[3][3].f0 |= ((void*)0 != &g_234[0][2]))) & ((*g_49) = (((*l_1125) = (*g_1084)) == (l_1126 = g_741))))) , (-1L)))) ^ (safe_mod_func_int32_t_s_s((&l_784 != l_1130), 0x7506DD04L))) < p_31), 0)) , g_700[0][0][2].f0) || 0xD581L) | g_937)) && (-1L)) > 0x1BL) != g_626[5][2][2]), l_1123[0][3]))) + { /* block id: 587 */ + struct S1 l_1139 = {0x36C3B729L}; + int i, j; + (**g_790) &= ((safe_lshift_func_uint64_t_u_u((((safe_sub_func_uint16_t_u_u(p_31, (safe_mod_func_int8_t_s_s(((****l_1096) = (l_1123[2][3] , ((g_1137 , g_1138) == (l_1139 , l_1140)))), (((void*)0 != (*l_1097)) | l_1123[3][0]))))) > 9UL) , 0xEB69A4FD8C11713FLL), 42)) ^ l_1141); + } + else + { /* block id: 590 */ + --l_1143; + if (p_31) + continue; + (*g_163) |= (!(g_48 , (248UL < p_31))); + } + } + for (l_364 = 2; (l_364 >= 0); l_364 -= 1) + { /* block id: 598 */ + uint16_t *l_1188 = (void*)0; + int32_t l_1199 = (-1L); + uint32_t l_1215 = 8UL; + for (g_679.f2 = 2; (g_679.f2 >= 0); g_679.f2 -= 1) + { /* block id: 601 */ + uint32_t *l_1165 = &g_1057; + uint8_t *l_1179 = &g_217[0][0]; + int32_t l_1180 = 0xFEAE5176L; + (*g_163) &= ((safe_mul_func_int64_t_s_s((safe_div_func_int8_t_s_s((**g_1080), (safe_sub_func_uint8_t_u_u((safe_sub_func_int8_t_s_s((safe_div_func_int32_t_s_s(((l_1142 == ((0UL & ((safe_mod_func_int64_t_s_s((safe_lshift_func_uint32_t_u_u(((safe_rshift_func_uint8_t_u_s((((++(*l_1165)) > (p_31 , 0x6190AB00L)) <= ((safe_mod_func_uint64_t_u_u(((safe_lshift_func_uint16_t_u_s((((*l_1179) = ((safe_mod_func_int16_t_s_s((l_1142 , (safe_sub_func_int32_t_s_s(((p_31 > (l_1176[0][6] != (safe_add_func_uint32_t_u_u(l_1062[0], g_57)))) < l_1062[0]), p_31))), g_763[0])) > l_1141)) & (*g_1032)), g_56)) != l_1062[0]), l_1062[0])) ^ (*g_1032))), (*g_1032))) , p_31), l_1180)), g_47)) != (*g_1032))) | 0xE7F50003FDF3DBBDLL)) >= g_63.f0), 0xDEBF1808L)), p_31)), g_50[6][1][0])))), 0x3B321D9BAD47B456LL)) <= 0xA74E911876C997C1LL); + if ((**g_347)) + continue; + } + for (g_196 = 0; (g_196 <= 2); g_196 += 1) + { /* block id: 609 */ + (*g_790) = &l_1062[1]; + l_1182 = &g_199; + return l_1142; + } + for (g_133 = 0; (g_133 <= 2); g_133 += 1) + { /* block id: 616 */ + uint32_t *l_1183[2][8] = {{&g_1057,&g_63.f0,&g_1057,&g_63.f0,&g_1057,&g_63.f0,&g_1057,&g_63.f0},{&g_1057,&g_63.f0,&g_1057,&g_63.f0,&g_1057,&g_63.f0,&g_1057,&g_63.f0}}; + int32_t l_1186 = 0L; + uint8_t *l_1210 = &l_1091; + struct S0 *l_1217 = &g_692; + int i, j; + l_1200[0][0] ^= ((*g_163) = (((l_1183[1][2] != &g_154) <= ((g_1057 = (safe_mul_func_int64_t_s_s(l_1186, (l_1187 && (&l_429 != l_1188))))) <= ((~0UL) != ((safe_unary_minus_func_int16_t_s(((safe_add_func_int16_t_s_s((safe_sub_func_uint16_t_u_u(g_13, (safe_mul_func_int8_t_s_s(((safe_unary_minus_func_uint32_t_u(((~g_148) <= p_31))) < p_31), (*l_627))))), g_47)) == l_1199))) , p_31)))) != l_1186)); + l_1216 |= (l_1062[1] &= (safe_mod_func_int16_t_s_s(((((safe_mod_func_uint16_t_u_u((&p_31 != (void*)0), p_31)) < (safe_sub_func_int8_t_s_s((((p_31 < ((*g_163) = (safe_mul_func_uint8_t_u_u((g_1209[0] , ((*l_1210)++)), g_937)))) | ((g_153 != (*g_1032)) | (safe_div_func_uint64_t_u_u(l_1186, l_1215)))) != 1L), (*g_1032)))) , g_270) , 0xDC83L), g_50[2][4][2]))); + (*l_1217) = g_128[1][3][0]; + } + } + } + for (l_1187 = 0; l_1187 < 4; l_1187 += 1) + { + l_389[l_1187] = &g_109; + } + for (l_1111 = 2; (l_1111 >= 0); l_1111 -= 1) + { /* block id: 631 */ + int16_t *l_1230 = &l_475; + int16_t *l_1231 = &g_47; + int32_t l_1232 = (-4L); + uint32_t l_1237 = 4294967288UL; + int32_t l_1240 = 0x3A667F28L; + int32_t l_1241 = 0x5A92E096L; + int32_t l_1244[9]; + union U2 **l_1270 = &g_741; + int i; + for (i = 0; i < 9; i++) + l_1244[i] = 0xE7BE2BA0L; + } + return g_1116.f0; + } + if ((safe_rshift_func_int8_t_s_s(((safe_mod_func_int64_t_s_s(((((l_1216 || ((*l_1302)++)) == ((g_1305 , ((safe_mod_func_int16_t_s_s(((*l_1314) = (safe_mul_func_int16_t_s_s((-1L), (((*l_1311) = l_1310) == ((*l_1313) = g_1312))))), (safe_div_func_uint8_t_u_u((safe_rshift_func_uint8_t_u_s(((safe_mul_func_int16_t_s_s(((*l_1322) = (l_1321[1] != l_1321[1])), 0xD1D6L)) == ((p_31 , (void*)0) != &g_50[1][2][1])), l_1062[0])), p_31)))) == p_31)) , g_276.f0)) > p_31) > 0L), g_56)) , l_1248), 5))) + { /* block id: 677 */ + struct S1 * const *l_1328 = &g_66; + struct S1 * const **l_1327[1][10][3] = {{{&l_1328,&l_1328,&l_1328},{&l_1328,&l_1328,&l_1328},{&l_1328,&l_1328,&l_1328},{&l_1328,&l_1328,(void*)0},{&l_1328,&l_1328,&l_1328},{(void*)0,&l_1328,&l_1328},{&l_1328,&l_1328,&l_1328},{&l_1328,(void*)0,&l_1328},{&l_1328,&l_1328,&l_1328},{&l_1328,&l_1328,&l_1328}}}; + struct S1 * const ***l_1326 = &l_1327[0][4][0]; + struct S1 * const ****l_1325[8] = {&l_1326,&l_1326,&l_1326,&l_1326,&l_1326,&l_1326,&l_1326,&l_1326}; + struct S0 **l_1341[6][6][3] = {{{&g_1338[0],&g_1338[2],&g_1338[2]},{&l_1004[0],&g_1338[0],&g_1338[0]},{&l_1004[2],&l_1004[0],&l_1004[0]},{&g_1338[0],&l_1004[1],(void*)0},{&g_1338[0],&g_1338[0],&l_1004[0]},{&g_1338[2],&l_1004[0],&l_1004[1]}},{{&l_1004[1],&l_1004[0],&l_1004[0]},{&g_1338[2],&l_1004[0],&g_1338[0]},{&g_1338[1],&g_1338[0],(void*)0},{(void*)0,&l_1004[1],&l_1004[0]},{&l_1004[0],&l_1004[0],&g_1338[1]},{&l_1004[1],&g_1338[0],&l_1004[0]}},{{&l_1004[1],&g_1338[2],(void*)0},{&l_1004[0],&g_1338[2],&g_1338[0]},{&g_1338[0],(void*)0,&g_1338[0]},{&l_1004[0],&l_1004[0],(void*)0},{&g_1338[0],&l_1004[2],&l_1004[0]},{&g_1338[0],(void*)0,&g_1338[1]}},{{&l_1004[0],&l_1004[1],&l_1004[0]},{&g_1338[0],&l_1004[0],(void*)0},{&g_1338[2],(void*)0,&g_1338[0]},{&l_1004[0],&g_1338[1],&l_1004[0]},{(void*)0,&l_1004[0],&l_1004[1]},{&l_1004[0],&g_1338[0],&l_1004[0]}},{{&g_1338[2],&g_1338[0],(void*)0},{&g_1338[0],&l_1004[0],&l_1004[0]},{&l_1004[0],&g_1338[0],&g_1338[0]},{&g_1338[0],&g_1338[0],&g_1338[2]},{&g_1338[0],&g_1338[0],&l_1004[0]},{&l_1004[0],&g_1338[0],&l_1004[0]}},{{&g_1338[0],&g_1338[0],&g_1338[2]},{&l_1004[0],&g_1338[0],&g_1338[2]},{&l_1004[1],&g_1338[0],&g_1338[0]},{&l_1004[1],&g_1338[0],(void*)0},{&l_1004[0],&l_1004[0],(void*)0},{(void*)0,&g_1338[0],(void*)0}}}; + struct S0 *** const l_1340 = &l_1341[4][5][0]; + struct S0 *** const *l_1339 = &l_1340; + int i, j, k; + (*g_163) = ((safe_sub_func_uint8_t_u_u(g_275, ((l_1325[2] != (void*)0) && (safe_sub_func_uint32_t_u_u(((l_1062[0] & (-1L)) ^ (safe_lshift_func_int32_t_s_s(p_31, 14))), 0xD288F954L))))) >= ((safe_sub_func_uint64_t_u_u(((l_1339 = g_1335) != (((safe_rshift_func_uint8_t_u_s(((g_919[5] == (*g_49)) < (*l_627)), l_1062[1])) != g_196) , l_1344)), p_31)) || l_1248)); + if (g_75) + goto lbl_1086; + } + else + { /* block id: 681 */ + union U3 **l_1347 = &l_1346[2][0]; + (**g_790) &= l_1345; + (*l_1347) = l_1346[2][0]; + } + } + (**g_790) ^= (p_31 != (((*l_1368) = (((((safe_mul_func_int32_t_s_s((safe_rshift_func_int64_t_s_s((safe_div_func_int64_t_s_s((safe_add_func_int64_t_s_s((safe_unary_minus_func_int8_t_s(p_31)), (0xB902A768L < (((safe_unary_minus_func_uint16_t_u((((safe_mod_func_uint16_t_u_u((&l_1346[2][0] == &l_1346[6][0]), (safe_mul_func_uint64_t_u_u((&g_158 == ((*l_1362) = (void*)0)), (*g_49))))) , (g_158 = (~(safe_mod_func_uint8_t_u_u((((*l_1367) = 4294967291UL) >= 4UL), 246UL))))) > 0UL))) || g_148) ^ p_31)))), p_31)), g_919[4])), p_31)) == 0x5AL) != (*g_1032)) > 0xC7E92BE7L) != (*l_627))) | g_171)); + return g_94[5]; +} + + +/* ------------------------------------------ */ +/* + * reads : g_148 g_49 g_50 g_57 g_196 g_56 g_94 g_75 g_68 g_199 g_171 g_47 g_219 g_133 g_225 g_234 g_217 g_158 g_63.f0 g_270 g_226 g_276 g_279 g_232 g_66 g_63 g_292 g_293 g_162 g_337 g_154 g_347 g_161.f0 g_65 + * writes: g_148 g_133 g_158 g_196 g_75 g_72 g_63.f0 g_217 g_219 g_57 g_226 g_234 g_47 g_153 g_163 g_275 g_232 g_128 g_50 g_56 g_171 g_334 g_66 + */ +static const int32_t func_32(uint32_t p_33, uint64_t * p_34, uint64_t * const p_35, struct S1 p_36, uint64_t * p_37) +{ /* block id: 90 */ + struct S1 ** volatile *l_174 = (void*)0; + int32_t l_193[1]; + const uint8_t l_194[7][5] = {{8UL,8UL,8UL,8UL,8UL},{8UL,8UL,8UL,8UL,8UL},{8UL,8UL,8UL,8UL,8UL},{8UL,8UL,8UL,8UL,8UL},{8UL,8UL,8UL,8UL,8UL},{8UL,8UL,8UL,8UL,8UL},{8UL,8UL,8UL,8UL,8UL}}; + uint32_t l_197 = 0xDE5E56C9L; + uint32_t l_319[2][3][9] = {{{4294967289UL,4294967288UL,0x912836B3L,4294967288UL,4294967289UL,0xDE7662D7L,0xDE7662D7L,4294967289UL,4294967288UL},{0x18116297L,1UL,0x18116297L,1UL,0x4FBB8765L,0x4FBB8765L,1UL,0x18116297L,1UL},{0x5A0E175AL,0UL,0xDE7662D7L,0x912836B3L,0x912836B3L,0xDE7662D7L,0UL,0x5A0E175AL,0UL}},{{1UL,0x3F634CE5L,1UL,1UL,0x3F634CE5L,1UL,0x4FBB8765L,1UL,0x3F634CE5L},{4294967288UL,4294967289UL,4294967289UL,0UL,0x7394197AL,0xDE7662D7L,0x7394197AL,0UL,4294967289UL},{4294967295UL,4294967295UL,1UL,1UL,1UL,1UL,1UL,4294967295UL,4294967295UL}}}; + int i, j, k; + for (i = 0; i < 1; i++) + l_193[i] = 0x9BA30310L; + l_174 = &g_65; + for (g_148 = 0; (g_148 <= 1); g_148 += 1) + { /* block id: 94 */ + int8_t l_186 = (-1L); + int32_t l_200 = 0xE99ADD51L; + struct S0 *l_223 = &g_70; + struct S0 * const *l_222 = &l_223; + int32_t l_227[4][8] = {{0L,0L,0L,0L,0L,0L,0L,0L},{0xEABE1C99L,0L,0xEABE1C99L,0xEABE1C99L,0L,0xEABE1C99L,0xEABE1C99L,0L},{0L,0xEABE1C99L,0xEABE1C99L,0L,0xEABE1C99L,0xEABE1C99L,0L,0xEABE1C99L},{0L,0L,0L,0L,0L,0L,0L,0L}}; + uint8_t l_255[1]; + int16_t *l_289 = &g_47; + int32_t **l_359 = (void*)0; + int32_t ***l_358 = &l_359; + int32_t ****l_357[3]; + int i, j; + for (i = 0; i < 1; i++) + l_255[i] = 1UL; + for (i = 0; i < 3; i++) + l_357[i] = &l_358; + for (g_133 = 0; (g_133 <= 3); g_133 += 1) + { /* block id: 97 */ + int32_t **l_182[10][1][4] = {{{(void*)0,&g_163,&g_163,(void*)0}},{{&g_163,&g_163,&g_163,&g_163}},{{&g_163,&g_163,&g_163,&g_163}},{{&g_163,&g_163,&g_163,&g_163}},{{(void*)0,&g_163,(void*)0,&g_163}},{{(void*)0,&g_163,&g_163,(void*)0}},{{&g_163,&g_163,&g_163,&g_163}},{{&g_163,&g_163,&g_163,&g_163}},{{&g_163,&g_163,&g_163,&g_163}},{{(void*)0,&g_163,(void*)0,&g_163}}}; + uint16_t *l_183 = &g_158; + int8_t *l_195 = &g_196; + int32_t *l_221 = (void*)0; + int32_t l_230[8][8][4] = {{{0x15ADF492L,(-2L),(-9L),0x149C64D6L},{0xA0215C44L,1L,0x22876F92L,(-1L)},{0x40DDB9D4L,1L,2L,(-1L)},{0x6E9F9F4BL,0xA15EDD2BL,0x15ADF492L,0xDB490537L},{(-8L),0x680F40A1L,4L,0x09B8FF13L},{0xDA8E2CCAL,0xE3912886L,0xDA8E2CCAL,2L},{0x22876F92L,(-9L),(-2L),1L},{5L,0xDB490537L,5L,(-9L)}},{{0x680F40A1L,1L,5L,0x6953CCBCL},{5L,0xA0215C44L,(-2L),2L},{0x22876F92L,8L,0xDA8E2CCAL,6L},{0xDA8E2CCAL,6L,4L,5L},{(-8L),0x22876F92L,0x15ADF492L,8L},{0x6E9F9F4BL,4L,2L,0L},{0x40DDB9D4L,0x6E9F9F4BL,0x22876F92L,0xE3912886L},{0xA0215C44L,(-9L),(-9L),0xA0215C44L}},{{0x15ADF492L,3L,4L,0x22876F92L},{0x11731A21L,0x6953CCBCL,1L,(-2L)},{(-9L),0xDA8E2CCAL,0x0483999EL,(-2L)},{(-10L),0x6953CCBCL,0x48C06950L,0x22876F92L},{0x149C64D6L,3L,0x40DDB9D4L,0xA0215C44L},{(-2L),(-9L),0x149C64D6L,0xE3912886L},{8L,0x6E9F9F4BL,0xA0215C44L,0L},{0x09B8FF13L,4L,0x72009605L,8L}},{{0x6953CCBCL,0x22876F92L,0xA15EDD2BL,5L},{(-2L),0xDB490537L,0x48C06950L,0xDB490537L},{1L,0L,0xDB490537L,0x15ADF492L},{0x15ADF492L,(-10L),0x22876F92L,0x680F40A1L},{0x149C64D6L,6L,5L,0x09B8FF13L},{0x149C64D6L,0x72009605L,0x22876F92L,5L},{0x15ADF492L,0x09B8FF13L,0xDB490537L,0x6E9F9F4BL},{1L,0x22876F92L,0x48C06950L,0x6953CCBCL}},{{2L,0x0483999EL,1L,0x72009605L},{0x680F40A1L,1L,(-1L),1L},{0x6953CCBCL,0xDA8E2CCAL,(-10L),(-9L)},{0L,5L,1L,1L},{0x40DDB9D4L,0x40DDB9D4L,0xC32E7B3CL,0xE00048D7L},{1L,8L,(-2L),5L},{0xA15EDD2BL,(-9L),0x149C64D6L,(-2L)},{0xA0215C44L,(-9L),5L,5L}},{{(-9L),8L,1L,0xE00048D7L},{3L,0x40DDB9D4L,0xA0215C44L,1L},{(-10L),5L,2L,(-9L)},{0xC32E7B3CL,0xDA8E2CCAL,0x15ADF492L,1L},{4L,1L,3L,0x72009605L},{0xE00048D7L,0x0483999EL,(-2L),0x6953CCBCL},{0x11731A21L,0x22876F92L,0x11731A21L,0x6E9F9F4BL},{2L,0x09B8FF13L,0x40DDB9D4L,5L}},{{8L,0x72009605L,4L,0x09B8FF13L},{0x0483999EL,6L,4L,0x680F40A1L},{8L,(-10L),0x40DDB9D4L,0x15ADF492L},{2L,0L,0x11731A21L,0xDB490537L},{0x11731A21L,0xDB490537L,(-2L),4L},{0xE00048D7L,2L,3L,0L},{4L,1L,0x15ADF492L,0x48C06950L},{0xC32E7B3CL,4L,2L,0x22876F92L}},{{(-10L),0xA0215C44L,0xA0215C44L,(-10L)},{3L,5L,1L,2L},{(-9L),0x680F40A1L,5L,2L},{0xA0215C44L,0x11731A21L,0x149C64D6L,2L},{0xA15EDD2BL,0x680F40A1L,(-2L),2L},{1L,5L,0xC32E7B3CL,(-10L)},{0x40DDB9D4L,0xA0215C44L,1L,0x22876F92L},{0L,4L,(-10L),0x48C06950L}}}; + int i, j, k; + g_75 ^= (safe_rshift_func_int32_t_s_u(((p_36.f0 | (safe_unary_minus_func_uint32_t_u(((((safe_lshift_func_int16_t_s_s((safe_add_func_uint16_t_u_u(((*l_183) = (((void*)0 == l_182[7][0][3]) | p_33)), (safe_mul_func_int8_t_s_s(((l_186 = 0x8862L) == ((*g_49) >= 0UL)), ((*l_195) &= (safe_mul_func_int16_t_s_s(((safe_add_func_uint64_t_u_u((safe_add_func_uint64_t_u_u(l_193[0], l_194[3][0])), 0x01D9BD75CEE96C84LL)) && 255UL), g_57))))))), g_56)) < p_36.f0) < l_197) , g_94[5])))) , 0xA1B903DAL), 9)); + if ((*g_68)) + continue; + if (p_36.f0) + { /* block id: 103 */ + const struct S0 *l_198 = &g_70; + int8_t *l_205 = &l_186; + uint32_t *l_215 = &g_63.f0; + uint8_t *l_216 = &g_217[2][6]; + int32_t l_218[9][8][3] = {{{(-1L),0xA0CDF28EL,0xA0CDF28EL},{(-9L),0xC6678C47L,0xECEDD2ABL},{(-1L),0xA0CDF28EL,0xA0CDF28EL},{(-9L),0xC6678C47L,0xECEDD2ABL},{(-1L),0xA0CDF28EL,0xA0CDF28EL},{(-9L),0xC6678C47L,0xECEDD2ABL},{(-1L),0xA0CDF28EL,0xA0CDF28EL},{(-9L),0xC6678C47L,0xECEDD2ABL}},{{(-1L),0xA0CDF28EL,0xA0CDF28EL},{(-9L),0xC6678C47L,0xECEDD2ABL},{(-1L),0xA0CDF28EL,0xA0CDF28EL},{(-9L),0xC6678C47L,0xECEDD2ABL},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)}},{{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)}},{{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)}},{{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)}},{{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)}},{{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)}},{{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)}},{{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)},{0xA0CDF28EL,9L,9L},{0xECEDD2ABL,0xF161F6DFL,(-10L)}}}; + int i, j, k; + (*g_199) = l_198; + l_200 = (2UL ^ (0xD2L > 1UL)); + g_219 ^= (safe_rshift_func_int16_t_s_u((safe_unary_minus_func_int8_t_s(((*l_205) = ((p_33 | ((*l_195) = (!(*p_35)))) > g_57)))), ((*g_68) | (+(((g_75 < (safe_lshift_func_int32_t_s_s((((safe_sub_func_uint32_t_u_u(8UL, (3L >= (safe_rshift_func_uint32_t_u_u((((*l_216) = ((safe_lshift_func_uint64_t_u_s((((*l_215) = g_50[0][1][3]) || p_36.f0), p_33)) < g_47)) & 0x3BL), l_218[5][3][2]))))) , p_33) & 255UL), 2))) > (*p_37)) == p_33))))); + for (g_57 = 0; (g_57 <= 1); g_57 += 1) + { /* block id: 113 */ + int32_t *l_220 = (void*)0; + int i, j, k; + l_221 = l_220; + if (g_50[(g_133 + 4)][g_133][(g_148 + 2)]) + continue; + return p_36.f0; + } + } + else + { /* block id: 118 */ + l_193[0] &= (l_222 == &l_223); + } + if ((*g_68)) + break; + for (g_158 = 0; (g_158 <= 3); g_158 += 1) + { /* block id: 124 */ + const int32_t *l_224 = &g_75; + int32_t l_229 = 0x0527778EL; + int32_t l_231 = 9L; + int32_t l_233 = 0xEEA15874L; + for (g_219 = 0; (g_219 <= 1); g_219 += 1) + { /* block id: 127 */ + int64_t l_228 = 1L; + (*g_225) = l_224; + --g_234[0][2]; + } + l_193[0] |= p_33; + return (*l_224); + } + } + (*g_225) = (void*)0; + for (g_47 = 0; (g_47 <= 3); g_47 += 1) + { /* block id: 138 */ + int16_t *l_243 = &g_153; + int32_t l_249 = (-1L); + uint16_t *l_250 = (void*)0; + uint16_t *l_251 = &g_158; + int32_t l_282 = 8L; + int32_t l_322[9] = {(-2L),0xEE09CF0BL,0xEE09CF0BL,(-2L),0xEE09CF0BL,0xEE09CF0BL,(-2L),0xEE09CF0BL,0xEE09CF0BL}; + struct S1 l_335[1] = {{0x6E9846EEL}}; + const uint16_t *l_349 = (void*)0; + uint32_t l_352 = 0x805FF6CDL; + int i; + if (((safe_mod_func_uint8_t_u_u((((((safe_rshift_func_uint32_t_u_u(p_36.f0, (safe_mul_func_uint16_t_u_u(((4294967295UL >= p_33) ^ p_33), ((*l_243) = p_33))))) , (safe_unary_minus_func_uint64_t_u((65531UL == (g_234[4][0] > g_217[2][6]))))) & ((safe_sub_func_uint8_t_u_u((safe_rshift_func_uint8_t_u_u(((((((*l_251) ^= (((p_33 == 0L) , l_249) & l_186)) >= l_200) , g_133) != (*p_37)) ^ 9UL), 0)), p_36.f0)) != p_36.f0)) < (-1L)) && l_249), 246UL)) & p_33)) + { /* block id: 141 */ + uint64_t l_252 = 18446744073709551615UL; + for (g_75 = 0; (g_75 <= 1); g_75 += 1) + { /* block id: 144 */ + l_252 &= (-3L); + return (*g_68); + } + } + else + { /* block id: 148 */ + uint32_t *l_258 = &g_63.f0; + int32_t **l_271 = &g_163; + int32_t *l_272 = (void*)0; + int32_t *l_273 = &l_200; + uint16_t *l_274 = &g_275; + uint8_t *l_290 = (void*)0; + uint8_t *l_291 = &g_219; + if (((g_158 && 0x31B7860BB8B317F3LL) == ((safe_div_func_uint16_t_u_u((l_255[0] = l_249), ((safe_lshift_func_int32_t_s_s(0x2D07DAD9L, 19)) ^ ((*l_258)--)))) && (+((*l_274) = (safe_mul_func_int16_t_s_s((safe_rshift_func_int32_t_s_u(((*l_273) = ((safe_mod_func_uint64_t_u_u((((safe_rshift_func_int16_t_s_s(p_33, (((((*l_271) = (g_270 , l_258)) == &l_193[0]) && ((*g_225) == &g_56)) == (*p_37)))) & 0xDD833FBFL) , (*p_35)), g_171)) != g_217[1][5])), p_33)), 0xC03DL))))))) + { /* block id: 154 */ + for (g_232 = 0; (g_232 <= 1); g_232 += 1) + { /* block id: 157 */ + int i, j, k; + g_128[(g_47 + 2)][(g_148 + 2)][g_148] = g_276; + (*l_273) &= (safe_lshift_func_uint16_t_u_s((0xF5C83813D3AF03E8LL == ((g_279 , g_94[g_47]) , (g_50[(g_232 + 3)][g_232][(g_232 + 2)] &= (safe_add_func_uint16_t_u_u(g_94[(g_232 + 3)], 6L))))), 11)); + if (l_282) + break; + (*l_273) = (l_197 || l_249); + } + } + else + { /* block id: 164 */ + return p_36.f0; + } + if (p_33) + continue; + (*l_273) = ((((safe_sub_func_int32_t_s_s(p_33, ((g_276.f0 != g_217[2][6]) ^ 0x67L))) & (*p_34)) == l_255[0]) < ((*g_66) , (safe_div_func_int64_t_s_s(((safe_mod_func_uint8_t_u_u((g_158 , ((*l_291) ^= ((l_289 == &g_153) & g_133))), p_36.f0)) != p_33), 0x2A97E7C0EF8D422ALL)))); + } + (*g_292) &= l_200; + for (g_63.f0 = 0; (g_63.f0 <= 3); g_63.f0 += 1) + { /* block id: 174 */ + int64_t *l_317 = (void*)0; + int64_t *l_318[2][8] = {{&g_232,&g_232,&g_232,&g_232,&g_232,&g_232,&g_232,&g_232},{&g_232,&g_232,&g_232,&g_232,&g_232,&g_232,&g_232,&g_232}}; + int32_t *l_320 = (void*)0; + int32_t *l_321 = &g_56; + int32_t *l_323 = &l_193[0]; + int32_t *l_324 = &g_56; + int32_t *l_325 = &l_193[0]; + int32_t *l_326 = &l_227[1][4]; + int32_t *l_327 = (void*)0; + int32_t *l_328 = &l_193[0]; + int32_t *l_329 = &l_322[6]; + int32_t *l_330[1][2]; + uint32_t l_331 = 4294967295UL; + int i, j, k; + for (i = 0; i < 1; i++) + { + for (j = 0; j < 2; j++) + l_330[i][j] = &l_193[0]; + } + (*l_321) ^= (g_293 , (safe_lshift_func_uint32_t_u_s(p_36.f0, ((safe_mod_func_uint8_t_u_u((((((safe_unary_minus_func_int8_t_s((safe_sub_func_int8_t_s_s((safe_lshift_func_int16_t_s_s(0x41BFL, 15)), ((safe_div_func_int8_t_s_s((l_282 <= (safe_mod_func_uint64_t_u_u((safe_div_func_uint32_t_u_u(((0x00C5AB965B3739AFLL && (l_227[0][2] = (safe_rshift_func_uint64_t_u_s(((*p_37) ^= ((safe_mul_func_int8_t_s_s(0x61L, l_193[0])) | (safe_mod_func_uint64_t_u_u((*g_49), (safe_mod_func_uint64_t_u_u(g_57, p_36.f0)))))), g_50[1][2][1])))) > l_193[0]), 0x70371D9BL)), g_63.f0))), l_255[0])) < p_33))))) & g_158) ^ l_319[1][0][4]) > p_36.f0) >= g_232), p_33)) <= (-9L))))); + l_331--; + p_36 = (g_334[3][3] = (*g_66)); + for (g_133 = 0; (g_133 <= 1); g_133 += 1) + { /* block id: 183 */ + int8_t *l_342 = &l_186; + (*g_162) = &l_227[1][4]; + (*g_337) = l_335[0]; + if ((((safe_mod_func_uint32_t_u_u(((((*l_342) ^= (safe_sub_func_int32_t_s_s(l_319[0][0][7], (p_33 < g_154)))) > l_319[1][0][4]) & (l_227[1][4] >= 0x19070582L)), ((p_33 && (g_57 <= 0x8F33L)) || l_194[0][4]))) , (*g_49)) , 0x4368FA08L)) + { /* block id: 187 */ + int32_t *l_343 = &l_322[3]; + int32_t **l_344 = (void*)0; + int32_t **l_345 = (void*)0; + (*g_347) = l_343; + return p_36.f0; + } + else + { /* block id: 190 */ + const uint16_t *l_348 = &g_158; + int32_t l_350 = 9L; + int32_t l_351 = 0x8F6F16FDL; + int32_t **l_355 = &l_330[0][1]; + int32_t **l_356 = &l_321; + int32_t *****l_361 = &l_357[2]; + (*l_321) = ((l_348 != (l_349 = l_348)) | g_161[1].f0); + l_352++; + (*l_356) = ((*l_355) = &l_227[1][4]); + (*l_361) = l_357[2]; + } + } + for (g_232 = 1; (g_232 >= 0); g_232 -= 1) + { /* block id: 201 */ + if (l_194[3][0]) + break; + } + } + } + } + (**l_174) = &p_36; + return l_193[0]; +} + + +/* ------------------------------------------ */ +/* + * reads : g_47 g_62 g_65 g_68 g_56 g_71 g_70 g_63.f0 g_57 g_50 g_75 g_94 g_48.f0 g_13 g_72 g_128 g_66 g_154 g_159 g_161 g_162 g_163 g_158 + * writes: g_47 g_57 g_62 g_66 g_56 g_72 g_63.f0 g_70 g_75 g_94 g_109 g_133 g_50 g_148 g_154 g_158 g_163 + */ +static uint64_t * func_38(uint32_t p_39, uint64_t * p_40) +{ /* block id: 9 */ + uint16_t l_80 = 0x395FL; + uint32_t l_81 = 0UL; + int32_t l_84 = 4L; + int32_t l_86[5][6][6] = {{{0x379EBF7AL,0x71667F30L,0x71667F30L,0x379EBF7AL,0x235E97BCL,0xB93C35E3L},{0xBBEE733DL,0x205434A3L,0L,0xDFC5AECEL,0L,1L},{0x55718CB2L,(-5L),(-1L),0x6D442F44L,0L,0x39EBEB9EL},{0x5970AEDAL,0x205434A3L,0x6BD8041EL,0x8B3ED55EL,0x235E97BCL,0x9C58AC2CL},{0x8EE533B9L,0x71667F30L,0L,0L,(-4L),9L},{0x6BD8041EL,1L,0xCAA3E211L,0xA35296D3L,0L,(-5L)}},{{0x510FED72L,0xE9565209L,0L,9L,0x330C07BBL,(-4L)},{0x205434A3L,0x510FED72L,0x5970AEDAL,0L,0xE9565209L,0L},{0xBBEE733DL,0x39EBEB9EL,0x330C07BBL,0x39EBEB9EL,0xBBEE733DL,9L},{0L,(-5L),1L,(-1L),0L,0xDFC5AECEL},{0x9B3387B9L,0x379EBF7AL,0x6BD8041EL,(-5L),1L,0xDFC5AECEL},{1L,0xEA876B16L,1L,0L,0xCAA3E211L,9L}},{{1L,0x6BD8041EL,0x330C07BBL,0xB93C35E3L,0L,0L},{0x4C462F11L,1L,0x5970AEDAL,9L,(-1L),(-4L)},{0x39EBEB9EL,0x4C462F11L,0L,0x205434A3L,0L,(-5L)},{0xBBEE733DL,0x9C58AC2CL,0xCAA3E211L,0x55718CB2L,0xB93C35E3L,9L},{0x9C58AC2CL,(-5L),0L,0L,(-5L),0x9C58AC2CL},{0L,0xDFC5AECEL,0x6BD8041EL,0L,0x8EE533B9L,0x39EBEB9EL}},{{0xE9565209L,0x5970AEDAL,(-1L),0L,1L,1L},{0xE9565209L,0L,0L,0L,0L,0xB93C35E3L},{0L,0x8EE533B9L,0x71667F30L,0L,0L,(-4L)},{0x9C58AC2CL,0L,0x510FED72L,0x55718CB2L,1L,0x8B3ED55EL},{0xBBEE733DL,0L,0xE195E041L,0x205434A3L,0x8B3ED55EL,0L},{0x39EBEB9EL,(-5L),0xB6C63C42L,9L,0xA35296D3L,0x379EBF7AL}},{{0x4C462F11L,0x55718CB2L,0x6BD8041EL,0xB93C35E3L,0x6BD8041EL,0x55718CB2L},{1L,0x9B3387B9L,9L,0L,0xE195E041L,0xB6C63C42L},{1L,0x235E97BCL,1L,(-5L),0L,0xA35296D3L},{0x9B3387B9L,0x235E97BCL,0x4C462F11L,(-1L),0xE195E041L,(-4L)},{0L,0x9B3387B9L,0xEA876B16L,0x39EBEB9EL,0x6BD8041EL,0xBBEE733DL},{0xBBEE733DL,0x4C462F11L,1L,0x5970AEDAL,9L,(-1L)}}}; + uint32_t l_103[4][4] = {{0x4483B597L,4294967294UL,0x4481F50DL,0x4481F50DL},{7UL,7UL,0x4483B597L,0x4481F50DL},{0UL,4294967294UL,0UL,0x4483B597L},{0UL,0x4483B597L,0x4483B597L,0UL}}; + struct S1 **l_110 = (void*)0; + int16_t *l_146 = &g_47; + int i, j, k; + for (g_47 = 0; (g_47 <= 27); g_47 = safe_add_func_int16_t_s_s(g_47, 3)) + { /* block id: 12 */ + const struct S0 *l_69 = &g_70; + int32_t *l_85 = &g_75; + int32_t *l_87 = (void*)0; + int32_t *l_88 = &g_56; + int32_t *l_89 = &g_75; + int32_t *l_90 = &l_84; + int32_t *l_91 = &l_84; + int32_t *l_92 = &l_86[1][3][2]; + int32_t *l_93[3]; + struct S1 ***l_138 = &l_110; + int i; + for (i = 0; i < 3; i++) + l_93[i] = (void*)0; + for (g_57 = 0; (g_57 <= 3); g_57 += 1) + { /* block id: 15 */ + struct S1 **l_64 = &g_62[1][0][1]; + int32_t l_67 = 0xBB6FCE13L; + (*g_65) = ((*l_64) = g_62[1][0][1]); + if (g_47) + break; + (*g_68) ^= l_67; + (*g_71) = l_69; + for (g_63.f0 = 0; (g_63.f0 <= 3); g_63.f0 += 1) + { /* block id: 23 */ + struct S0 *l_73 = &g_70; + int i, j, k; + (*l_73) = g_70; + if (g_50[g_63.f0][(g_57 + 2)][g_63.f0]) + continue; + for (g_56 = 3; (g_56 >= 0); g_56 -= 1) + { /* block id: 28 */ + for (l_67 = 0; (l_67 <= 1); l_67 += 1) + { /* block id: 31 */ + int32_t *l_74 = &g_75; + int32_t **l_82[8][3] = {{&l_74,&l_74,&l_74},{&l_74,&l_74,&l_74},{&l_74,&l_74,&l_74},{(void*)0,&l_74,(void*)0},{&l_74,&l_74,&l_74},{&l_74,&l_74,&l_74},{&l_74,&l_74,&l_74},{(void*)0,&l_74,(void*)0}}; + int32_t *l_83 = &g_75; + int i, j, k; + (*l_74) ^= 0xE74272ABL; + (*l_74) = (safe_mul_func_uint8_t_u_u((safe_rshift_func_uint8_t_u_u(g_50[(g_57 + 4)][g_57][g_56], l_80)), l_81)); + l_83 = &g_75; + if ((*g_68)) + continue; + } + } + } + } + g_94[5]++; + for (l_80 = 0; (l_80 == 37); l_80 = safe_add_func_uint64_t_u_u(l_80, 9)) + { /* block id: 43 */ + int32_t **l_101 = (void*)0; + struct S0 *l_116[2]; + int32_t l_135[5] = {0xB0B14FC1L,0xB0B14FC1L,0xB0B14FC1L,0xB0B14FC1L,0xB0B14FC1L}; + struct S1 * const l_140 = (void*)0; + int i; + for (i = 0; i < 2; i++) + l_116[i] = &g_70; + for (g_75 = (-23); (g_75 > 23); g_75 = safe_add_func_int8_t_s_s(g_75, 7)) + { /* block id: 46 */ + int32_t ***l_102 = &l_101; + struct S0 *l_104 = &g_70; + (*l_102) = l_101; + (*l_90) |= (*g_68); + if (l_103[1][3]) + break; + l_104 = l_104; + } + for (l_84 = 3; (l_84 >= 0); l_84 -= 1) + { /* block id: 54 */ + struct S1 **l_108 = &g_62[0][0][7]; + struct S1 ***l_107[9][10][2] = {{{(void*)0,&l_108},{&l_108,(void*)0},{&l_108,&l_108},{&l_108,(void*)0},{&l_108,&l_108},{(void*)0,(void*)0},{(void*)0,&l_108},{&l_108,&l_108},{&l_108,&l_108},{&l_108,(void*)0}},{{(void*)0,(void*)0},{&l_108,&l_108},{(void*)0,&l_108},{&l_108,&l_108},{(void*)0,&l_108},{&l_108,(void*)0},{(void*)0,(void*)0},{&l_108,&l_108},{&l_108,&l_108},{&l_108,&l_108}},{{(void*)0,(void*)0},{(void*)0,&l_108},{&l_108,(void*)0},{&l_108,&l_108},{&l_108,(void*)0},{&l_108,&l_108},{(void*)0,(void*)0},{(void*)0,&l_108},{&l_108,&l_108},{&l_108,&l_108}},{{&l_108,(void*)0},{(void*)0,(void*)0},{&l_108,&l_108},{(void*)0,&l_108},{&l_108,&l_108},{(void*)0,&l_108},{&l_108,(void*)0},{(void*)0,(void*)0},{&l_108,&l_108},{&l_108,&l_108}},{{&l_108,&l_108},{(void*)0,(void*)0},{(void*)0,&l_108},{&l_108,(void*)0},{&l_108,&l_108},{&l_108,(void*)0},{&l_108,&l_108},{(void*)0,(void*)0},{(void*)0,&l_108},{&l_108,&l_108}},{{&l_108,&l_108},{&l_108,(void*)0},{(void*)0,(void*)0},{&l_108,&l_108},{(void*)0,&l_108},{&l_108,&l_108},{(void*)0,&l_108},{&l_108,(void*)0},{(void*)0,(void*)0},{&l_108,&l_108}},{{&l_108,&l_108},{&l_108,&l_108},{(void*)0,(void*)0},{(void*)0,&l_108},{&l_108,(void*)0},{&l_108,&l_108},{&l_108,(void*)0},{&l_108,&l_108},{(void*)0,(void*)0},{(void*)0,&l_108}},{{(void*)0,(void*)0},{(void*)0,(void*)0},{&l_108,(void*)0},{&l_108,&l_108},{(void*)0,&l_108},{&l_108,&l_108},{&l_108,&l_108},{&l_108,&l_108},{(void*)0,&l_108},{&l_108,(void*)0}},{{&l_108,(void*)0},{(void*)0,(void*)0},{(void*)0,&l_108},{(void*)0,&l_108},{&l_108,(void*)0},{&l_108,&l_108},{&l_108,&l_108},{&l_108,&l_108},{&l_108,(void*)0},{&l_108,&l_108}}}; + int32_t l_134 = 0x2AA60D7DL; + int32_t l_150[7][8] = {{0x9FBB45EBL,0x9FBB45EBL,1L,0x9FBB45EBL,0x9FBB45EBL,1L,0x9FBB45EBL,0x9FBB45EBL},{8L,0x9FBB45EBL,8L,8L,0x9FBB45EBL,8L,8L,0x9FBB45EBL},{0x9FBB45EBL,8L,8L,0x9FBB45EBL,8L,8L,0x9FBB45EBL,8L},{0x9FBB45EBL,0x9FBB45EBL,1L,0x9FBB45EBL,0x9FBB45EBL,1L,0x9FBB45EBL,0x9FBB45EBL},{8L,0x9FBB45EBL,8L,8L,0x9FBB45EBL,8L,8L,0x9FBB45EBL},{0x9FBB45EBL,8L,8L,0x9FBB45EBL,8L,8L,0x9FBB45EBL,8L},{0x9FBB45EBL,0x9FBB45EBL,1L,0x9FBB45EBL,0x9FBB45EBL,1L,0x9FBB45EBL,0x9FBB45EBL}}; + int i, j, k; + (*l_89) &= (safe_add_func_int16_t_s_s((p_39 , (((g_109 = (void*)0) == l_110) ^ (((((safe_add_func_int16_t_s_s((safe_rshift_func_int16_t_s_s(p_39, (((g_48.f0 < 0xD29DL) , (p_39 || g_13)) <= (*l_90)))), l_86[1][3][2])) || p_39) > p_39) , g_48.f0) != g_47))), g_57)); + if (((void*)0 != &g_47)) + { /* block id: 57 */ + struct S1 l_145 = {4294967286UL}; + int32_t l_152[6] = {(-5L),(-5L),(-5L),(-5L),(-5L),(-5L)}; + int32_t ***l_160 = &l_101; + int i, j, k; + l_135[4] &= (+(((l_116[1] == (*g_71)) == (safe_rshift_func_uint16_t_u_s(0x2F62L, (~((*p_40) != (*p_40)))))) && (safe_mul_func_int16_t_s_s(((safe_mod_func_int32_t_s_s((safe_lshift_func_int8_t_s_s((((safe_mod_func_uint16_t_u_u((((((g_128[1][3][0] , (g_47 , (safe_rshift_func_uint64_t_u_u((g_50[(l_84 + 1)][(l_84 + 2)][l_84] = (((safe_div_func_int32_t_s_s((*g_68), ((*l_89) |= (((g_133 = p_39) , 255UL) ^ 252UL)))) , p_39) | 3UL)), 48)))) == l_134) && 0xCBEDFB48L) , g_63.f0) > p_39), 7UL)) | 0xCBD7L) && p_39), 7)), p_39)) >= 1UL), g_47)))); + for (g_75 = 0; (g_75 <= 3); g_75 += 1) + { /* block id: 64 */ + struct S1 ****l_139 = &l_138; + int16_t *l_147 = &g_148; + int32_t l_149 = 0L; + int32_t l_151[10] = {0L,1L,1L,0L,(-5L),0L,1L,1L,0L,(-5L)}; + uint16_t *l_157 = &g_158; + int i; + (*g_68) = ((g_75 & (safe_rshift_func_int8_t_s_s((((*l_139) = l_138) == &l_108), (l_140 != ((safe_lshift_func_int16_t_s_s(((*l_147) = (((((*p_40) = (safe_mod_func_int16_t_s_s((&g_47 == (l_145 , l_146)), 3UL))) , p_39) >= 4294967294UL) == 0xE7EAL)), g_94[5])) , (*g_65)))))) || p_39); + g_154++; + if (l_86[3][5][2]) + continue; + (*g_68) &= (p_39 ^ (((*l_157) = 0x2912L) != ((((g_159 != l_160) , (*l_139)) == (void*)0) > l_150[3][2]))); + } + if (p_39) + continue; + } + else + { /* block id: 75 */ + int32_t **l_165 = &l_85; + int32_t l_166[10] = {0x25BB58BCL,2L,2L,0x25BB58BCL,0L,0x25BB58BCL,2L,2L,0x25BB58BCL,0L}; + int i; + (*g_162) = (g_161[1] , &l_86[2][3][1]); + (*g_162) = (void*)0; + (*l_165) = (*g_162); + for (g_158 = 0; (g_158 <= 3); g_158 += 1) + { /* block id: 81 */ + uint16_t l_167 = 0UL; + l_167++; + (*l_88) = l_80; + } + } + } + } + } + return &g_50[1][2][1]; +} + + +/* ------------------------------------------ */ +/* + * reads : g_57 + * writes: g_57 + */ +static uint64_t * func_41(int32_t p_42, uint64_t * const p_43) +{ /* block id: 6 */ + int32_t *l_55[9] = {&g_56,&g_56,&g_56,&g_56,&g_56,&g_56,&g_56,&g_56,&g_56}; + int i; + --g_57; + return &g_50[3][5][2]; +} + + + + +/* ---------------------------------------- */ +int main (int argc, char* argv[]) +{ + int i, j, k; + int print_hash_value = 0; + if (argc == 2 && strcmp(argv[1], "1") == 0) print_hash_value = 1; + platform_main_begin(); + crc32_gentab(); + func_1(); + transparent_crc(g_13, "g_13", print_hash_value); + for (i = 0; i < 3; i++) + { + transparent_crc(g_15[i], "g_15[i]", print_hash_value); + if (print_hash_value) printf("index = [%d]\n", i); + + } + transparent_crc(g_47, "g_47", print_hash_value); + transparent_crc(g_48.f0, "g_48.f0", print_hash_value); + for (i = 0; i < 8; i++) + { + for (j = 0; j < 6; j++) + { + for (k = 0; k < 4; k++) + { + transparent_crc(g_50[i][j][k], "g_50[i][j][k]", print_hash_value); + if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k); + + } + } + } + transparent_crc(g_56, "g_56", print_hash_value); + transparent_crc(g_57, "g_57", print_hash_value); + transparent_crc(g_63.f0, "g_63.f0", print_hash_value); + transparent_crc(g_70.f0, "g_70.f0", print_hash_value); + transparent_crc(g_75, "g_75", print_hash_value); + for (i = 0; i < 8; i++) + { + transparent_crc(g_94[i], "g_94[i]", print_hash_value); + if (print_hash_value) printf("index = [%d]\n", i); + + } + for (i = 0; i < 8; i++) + { + for (j = 0; j < 6; j++) + { + for (k = 0; k < 2; k++) + { + transparent_crc(g_128[i][j][k].f0, "g_128[i][j][k].f0", print_hash_value); + if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k); + + } + } + } + transparent_crc(g_133, "g_133", print_hash_value); + transparent_crc(g_148, "g_148", print_hash_value); + transparent_crc(g_153, "g_153", print_hash_value); + transparent_crc(g_154, "g_154", print_hash_value); + transparent_crc(g_158, "g_158", print_hash_value); + for (i = 0; i < 3; i++) + { + transparent_crc(g_161[i].f0, "g_161[i].f0", print_hash_value); + if (print_hash_value) printf("index = [%d]\n", i); + + } + transparent_crc(g_171, "g_171", print_hash_value); + transparent_crc(g_196, "g_196", print_hash_value); + for (i = 0; i < 5; i++) + { + for (j = 0; j < 10; j++) + { + transparent_crc(g_217[i][j], "g_217[i][j]", print_hash_value); + if (print_hash_value) printf("index = [%d][%d]\n", i, j); + + } + } + transparent_crc(g_219, "g_219", print_hash_value); + transparent_crc(g_232, "g_232", print_hash_value); + for (i = 0; i < 8; i++) + { + for (j = 0; j < 3; j++) + { + transparent_crc(g_234[i][j], "g_234[i][j]", print_hash_value); + if (print_hash_value) printf("index = [%d][%d]\n", i, j); + + } + } + transparent_crc(g_270.f0, "g_270.f0", print_hash_value); + transparent_crc(g_275, "g_275", print_hash_value); + transparent_crc(g_276.f0, "g_276.f0", print_hash_value); + transparent_crc(g_279.f0, "g_279.f0", print_hash_value); + transparent_crc(g_293.f0, "g_293.f0", print_hash_value); + for (i = 0; i < 8; i++) + { + for (j = 0; j < 10; j++) + { + transparent_crc(g_334[i][j].f0, "g_334[i][j].f0", print_hash_value); + if (print_hash_value) printf("index = [%d][%d]\n", i, j); + + } + } + transparent_crc(g_554, "g_554", print_hash_value); + for (i = 0; i < 10; i++) + { + for (j = 0; j < 5; j++) + { + for (k = 0; k < 5; k++) + { + transparent_crc(g_626[i][j][k], "g_626[i][j][k]", print_hash_value); + if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k); + + } + } + } + transparent_crc(g_692.f0, "g_692.f0", print_hash_value); + for (i = 0; i < 2; i++) + { + for (j = 0; j < 1; j++) + { + for (k = 0; k < 3; k++) + { + transparent_crc(g_700[i][j][k].f0, "g_700[i][j][k].f0", print_hash_value); + if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k); + + } + } + } + transparent_crc(g_760.f0, "g_760.f0", print_hash_value); + for (i = 0; i < 1; i++) + { + transparent_crc(g_763[i], "g_763[i]", print_hash_value); + if (print_hash_value) printf("index = [%d]\n", i); + + } + for (i = 0; i < 1; i++) + { + transparent_crc(g_809[i], "g_809[i]", print_hash_value); + if (print_hash_value) printf("index = [%d]\n", i); + + } + transparent_crc(g_906, "g_906", print_hash_value); + for (i = 0; i < 9; i++) + { + transparent_crc(g_919[i], "g_919[i]", print_hash_value); + if (print_hash_value) printf("index = [%d]\n", i); + + } + transparent_crc(g_937, "g_937", print_hash_value); + transparent_crc(g_975.f0, "g_975.f0", print_hash_value); + transparent_crc(g_987.f0, "g_987.f0", print_hash_value); + transparent_crc(g_1005.f0, "g_1005.f0", print_hash_value); + transparent_crc(g_1043.f0, "g_1043.f0", print_hash_value); + transparent_crc(g_1057, "g_1057", print_hash_value); + transparent_crc(g_1071, "g_1071", print_hash_value); + transparent_crc(g_1116.f0, "g_1116.f0", print_hash_value); + transparent_crc(g_1137.f0, "g_1137.f0", print_hash_value); + for (i = 0; i < 7; i++) + { + transparent_crc(g_1209[i].f0, "g_1209[i].f0", print_hash_value); + if (print_hash_value) printf("index = [%d]\n", i); + + } + for (i = 0; i < 7; i++) + { + transparent_crc(g_1247[i], "g_1247[i]", print_hash_value); + if (print_hash_value) printf("index = [%d]\n", i); + + } + transparent_crc(g_1251.f0, "g_1251.f0", print_hash_value); + transparent_crc(g_1305.f0, "g_1305.f0", print_hash_value); + transparent_crc(g_1421.f0, "g_1421.f0", print_hash_value); + transparent_crc(g_1435.f0, "g_1435.f0", print_hash_value); + for (i = 0; i < 6; i++) + { + transparent_crc(g_1454[i].f0, "g_1454[i].f0", print_hash_value); + if (print_hash_value) printf("index = [%d]\n", i); + + } + transparent_crc(g_1499.f0, "g_1499.f0", print_hash_value); + transparent_crc(g_1551.f0, "g_1551.f0", print_hash_value); + transparent_crc(g_1630, "g_1630", print_hash_value); + for (i = 0; i < 9; i++) + { + for (j = 0; j < 10; j++) + { + for (k = 0; k < 2; k++) + { + transparent_crc(g_1663[i][j][k], "g_1663[i][j][k]", print_hash_value); + if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k); + + } + } + } + for (i = 0; i < 5; i++) + { + transparent_crc(g_1690[i].f0, "g_1690[i].f0", print_hash_value); + if (print_hash_value) printf("index = [%d]\n", i); + + } + for (i = 0; i < 8; i++) + { + transparent_crc(g_1704[i].f0, "g_1704[i].f0", print_hash_value); + if (print_hash_value) printf("index = [%d]\n", i); + + } + transparent_crc(g_1728, "g_1728", print_hash_value); + transparent_crc(g_1797.f0, "g_1797.f0", print_hash_value); + transparent_crc(g_1939, "g_1939", print_hash_value); + transparent_crc(g_1954.f0, "g_1954.f0", print_hash_value); + transparent_crc(g_1986.f0, "g_1986.f0", print_hash_value); + transparent_crc(g_1991, "g_1991", print_hash_value); + transparent_crc(g_2073.f0, "g_2073.f0", print_hash_value); + transparent_crc(g_2078.f0, "g_2078.f0", print_hash_value); + transparent_crc(g_2101, "g_2101", print_hash_value); + transparent_crc(g_2201, "g_2201", print_hash_value); + transparent_crc(g_2203, "g_2203", print_hash_value); + for (i = 0; i < 9; i++) + { + for (j = 0; j < 10; j++) + { + transparent_crc(g_2207[i][j].f0, "g_2207[i][j].f0", print_hash_value); + if (print_hash_value) printf("index = [%d][%d]\n", i, j); + + } + } + transparent_crc(g_2208.f0, "g_2208.f0", print_hash_value); + transparent_crc(g_2254, "g_2254", print_hash_value); + for (i = 0; i < 8; i++) + { + for (j = 0; j < 7; j++) + { + for (k = 0; k < 4; k++) + { + transparent_crc(g_2270[i][j][k].f0, "g_2270[i][j][k].f0", print_hash_value); + if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k); + + } + } + } + transparent_crc(g_2272.f0, "g_2272.f0", print_hash_value); + transparent_crc(g_2273.f0, "g_2273.f0", print_hash_value); + for (i = 0; i < 5; i++) + { + transparent_crc(g_2275[i].f0, "g_2275[i].f0", print_hash_value); + if (print_hash_value) printf("index = [%d]\n", i); + + } + transparent_crc(g_2276.f0, "g_2276.f0", print_hash_value); + transparent_crc(g_2277.f0, "g_2277.f0", print_hash_value); + transparent_crc(g_2279.f0, "g_2279.f0", print_hash_value); + for (i = 0; i < 4; i++) + { + for (j = 0; j < 5; j++) + { + for (k = 0; k < 8; k++) + { + transparent_crc(g_2280[i][j][k].f0, "g_2280[i][j][k].f0", print_hash_value); + if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k); + + } + } + } + transparent_crc(g_2281.f0, "g_2281.f0", print_hash_value); + transparent_crc(g_2282.f0, "g_2282.f0", print_hash_value); + transparent_crc(g_2284.f0, "g_2284.f0", print_hash_value); + for (i = 0; i < 6; i++) + { + for (j = 0; j < 3; j++) + { + transparent_crc(g_2286[i][j].f0, "g_2286[i][j].f0", print_hash_value); + if (print_hash_value) printf("index = [%d][%d]\n", i, j); + + } + } + for (i = 0; i < 9; i++) + { + for (j = 0; j < 5; j++) + { + for (k = 0; k < 1; k++) + { + transparent_crc(g_2287[i][j][k].f0, "g_2287[i][j][k].f0", print_hash_value); + if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k); + + } + } + } + transparent_crc(g_2293, "g_2293", print_hash_value); + transparent_crc(g_2296.f0, "g_2296.f0", print_hash_value); + transparent_crc(g_2298.f0, "g_2298.f0", print_hash_value); + transparent_crc(g_2350.f0, "g_2350.f0", print_hash_value); + transparent_crc(g_2393.f0, "g_2393.f0", print_hash_value); + transparent_crc(g_2467.f0, "g_2467.f0", print_hash_value); + transparent_crc(g_2533.f0, "g_2533.f0", print_hash_value); + transparent_crc(g_2535, "g_2535", print_hash_value); + for (i = 0; i < 1; i++) + { + transparent_crc(g_2582[i], "g_2582[i]", print_hash_value); + if (print_hash_value) printf("index = [%d]\n", i); + + } + transparent_crc(g_2592.f0, "g_2592.f0", print_hash_value); + transparent_crc(g_2621, "g_2621", print_hash_value); + for (i = 0; i < 2; i++) + { + for (j = 0; j < 9; j++) + { + transparent_crc(g_2744[i][j], "g_2744[i][j]", print_hash_value); + if (print_hash_value) printf("index = [%d][%d]\n", i, j); + + } + } + transparent_crc(g_2792.f0, "g_2792.f0", print_hash_value); + for (i = 0; i < 7; i++) + { + for (j = 0; j < 3; j++) + { + transparent_crc(g_2805[i][j], "g_2805[i][j]", print_hash_value); + if (print_hash_value) printf("index = [%d][%d]\n", i, j); + + } + } + transparent_crc(g_2815.f0, "g_2815.f0", print_hash_value); + for (i = 0; i < 4; i++) + { + transparent_crc(g_2845[i], "g_2845[i]", print_hash_value); + if (print_hash_value) printf("index = [%d]\n", i); + + } + transparent_crc(g_2898, "g_2898", print_hash_value); + transparent_crc(g_2932.f0, "g_2932.f0", print_hash_value); + platform_main_end(crc32_context ^ 0xFFFFFFFFUL, print_hash_value); + return 0; +} + +/************************ statistics ************************* +XXX max struct depth: 1 +breakdown: + depth: 0, occurrence: 812 + depth: 1, occurrence: 50 +XXX total union variables: 18 + +XXX non-zero bitfields defined in structs: 3 +XXX zero bitfields defined in structs: 0 +XXX const bitfields defined in structs: 0 +XXX volatile bitfields defined in structs: 2 +XXX structs with bitfields in the program: 106 +breakdown: + indirect level: 0, occurrence: 43 + indirect level: 1, occurrence: 30 + indirect level: 2, occurrence: 10 + indirect level: 3, occurrence: 9 + indirect level: 4, occurrence: 12 + indirect level: 5, occurrence: 2 +XXX full-bitfields structs in the program: 25 +breakdown: + indirect level: 0, occurrence: 25 +XXX times a bitfields struct's address is taken: 105 +XXX times a bitfields struct on LHS: 3 +XXX times a bitfields struct on RHS: 61 +XXX times a single bitfield on LHS: 0 +XXX times a single bitfield on RHS: 37 + +XXX max expression depth: 37 +breakdown: + depth: 1, occurrence: 443 + depth: 2, occurrence: 103 + depth: 3, occurrence: 10 + depth: 4, occurrence: 6 + depth: 5, occurrence: 2 + depth: 6, occurrence: 2 + depth: 7, occurrence: 1 + depth: 8, occurrence: 1 + depth: 9, occurrence: 2 + depth: 12, occurrence: 1 + depth: 13, occurrence: 1 + depth: 14, occurrence: 1 + depth: 15, occurrence: 3 + depth: 16, occurrence: 5 + depth: 17, occurrence: 3 + depth: 18, occurrence: 4 + depth: 19, occurrence: 4 + depth: 20, occurrence: 4 + depth: 21, occurrence: 4 + depth: 22, occurrence: 2 + depth: 23, occurrence: 2 + depth: 24, occurrence: 6 + depth: 25, occurrence: 6 + depth: 26, occurrence: 4 + depth: 27, occurrence: 2 + depth: 28, occurrence: 1 + depth: 29, occurrence: 4 + depth: 30, occurrence: 2 + depth: 31, occurrence: 1 + depth: 32, occurrence: 1 + depth: 33, occurrence: 1 + depth: 34, occurrence: 4 + depth: 37, occurrence: 1 + +XXX total number of pointers: 607 + +XXX times a variable address is taken: 1467 +XXX times a pointer is dereferenced on RHS: 278 +breakdown: + depth: 1, occurrence: 215 + depth: 2, occurrence: 46 + depth: 3, occurrence: 5 + depth: 4, occurrence: 11 + depth: 5, occurrence: 1 +XXX times a pointer is dereferenced on LHS: 365 +breakdown: + depth: 1, occurrence: 317 + depth: 2, occurrence: 34 + depth: 3, occurrence: 11 + depth: 4, occurrence: 3 +XXX times a pointer is compared with null: 48 +XXX times a pointer is compared with address of another variable: 13 +XXX times a pointer is compared with another pointer: 18 +XXX times a pointer is qualified to be dereferenced: 10029 + +XXX max dereference level: 5 +breakdown: + level: 0, occurrence: 0 + level: 1, occurrence: 1225 + level: 2, occurrence: 326 + level: 3, occurrence: 92 + level: 4, occurrence: 66 + level: 5, occurrence: 107 +XXX number of pointers point to pointers: 258 +XXX number of pointers point to scalars: 278 +XXX number of pointers point to structs: 50 +XXX percent of pointers has null in alias set: 27 +XXX average alias set size: 1.4 + +XXX times a non-volatile is read: 2071 +XXX times a non-volatile is write: 1166 +XXX times a volatile is read: 222 +XXX times read thru a pointer: 46 +XXX times a volatile is write: 71 +XXX times written thru a pointer: 6 +XXX times a volatile is available for access: 8.39e+03 +XXX percentage of non-volatile access: 91.7 + +XXX forward jumps: 3 +XXX backward jumps: 6 + +XXX stmts: 416 +XXX max block depth: 5 +breakdown: + depth: 0, occurrence: 30 + depth: 1, occurrence: 37 + depth: 2, occurrence: 70 + depth: 3, occurrence: 85 + depth: 4, occurrence: 92 + depth: 5, occurrence: 102 + +XXX percentage a fresh-made variable is used: 18.4 +XXX percentage an existing variable is used: 81.6 +FYI: the random generator makes assumptions about the integer size. See platform.info for more details. +XXX total OOB instances added: 0 +********************* end of statistics **********************/ +