Package tarball: ignore heavy useless files

The easy way of RBP defined vs. undefined merge is implemented (if a
block is defined with RBP undef, we tolerate merging upon it with a
defined RBP by losing this information).

.gitignore

@@ -23,3 +23,5 @@ setup.log
 *.plugin
 ml_dwarf_write.bin
 tmp.marshal
+dwarfsynth.tar.gz
+tmp

DwarfSynth/Main.ml

@@ -1,8 +1,12 @@
 open Std
 
-let main ?no_rbp_undef:(no_rbp_undef=false) outfile proj =
+let main
+    ?no_rbp_undef:(no_rbp_undef=false)
+    ?timers:(timers=false)
+    outfile
+    proj =
   let pre_dwarf = proj
-                  |> Simplest.of_proj no_rbp_undef
+                  |> Simplest.of_proj no_rbp_undef timers
                   |> Simplest.clean_lost_track_subs in
   Format.printf "%a" Frontend.pp_pre_dwarf_readelf pre_dwarf;
   let pre_c_dwarf = PreCBinding.convert_pre_c pre_dwarf in

DwarfSynth/Simplest.ml

@@ -40,11 +40,13 @@ exception InvalidSub
 exception UnexpectedRbpSet
 
 type synthesis_settings = {
-    mutable no_rbp_undef: bool
+  mutable no_rbp_undef: bool;
+  mutable timers: bool
 }
 
 let __settings = {
-  no_rbp_undef = false
+  no_rbp_undef = false;
+  timers = false
 }
 
 let pp_cfa_pos ppx = function
@@ -83,6 +85,12 @@ let pp_option_of sub_pp ppx = function
   | None -> Format.fprintf ppx "None"
   | Some x -> Format.fprintf ppx "Some %a" sub_pp x
 
+let timer_probe probe_name =
+  if __settings.timers then (
+    let time = Unix.gettimeofday () in
+    Format.eprintf "~~TIME~~ %s [%f]@." probe_name time
+  )
+
 let opt_addr_of term =
   (** Get the address of a term as an option, if it has one*)
   BStd.Term.get_attr term BStd.address
@@ -176,6 +184,59 @@ let build_next_instr sub_ranges (disasm: BStd.disasm): AddrSet.t AddrMap.t =
     )
   in
 
+  let block_following_set block sub_first_addr sub_last_addr last_addr =
+    (** Set of addresses that are successors of this block
+
+        This set is the set of the addresses of blocks pointed by an output
+        edge of this block. We filter this set so that it only contains
+        addresses inside the subroutine, and take care of keeping only the
+        return edge of calls.
+    *)
+
+    let blk_outputs =
+       BStd.Graphs.Cfg.Node.outputs block cfg
+       |> BStd.Seq.fold
+         ~init:AddrSet.empty
+         ~f:(fun set edge -> AddrSet.union
+                (block_addresses
+                   (BStd.Graphs.Cfg.Edge.dst edge))
+                set)
+       |> AddrSet.filter (fun addr ->
+           sub_first_addr <= addr
+           && addr <= sub_last_addr)
+       (* ^ We must ensure the landing address belongs to the current
+          subroutine for our purpose *)
+    in
+
+    let terminator = BStd.Block.terminator block in
+    (* `terminator` is the only jump-ish instruction in `block` *)
+
+    (match BStd.Insn.is BStd.Insn.call terminator with
+     | true ->
+       (* `terminator` is a call: we mustn't include the callee as a successor
+          of this block. *)
+
+       (* Only one output: the one that is closest to `last_addr`, forwards. *)
+
+       (match AddrSet.find_first_opt
+                (fun x -> Int64.(last_addr < x)) blk_outputs with
+       | Some ret_addr ->
+         let delta = Int64.sub ret_addr last_addr |> Int64.to_int in
+         if delta >= 32 then
+           assert false (* FIXME maybe no return *)
+         else (
+           (AddrSet.singleton ret_addr)
+         )
+       | None -> AddrSet.empty (* assume no return *)
+       )
+
+     | false ->
+       (* `terminator` is not a call, all this block's outputs are correct
+          successors *)
+       blk_outputs
+    )
+  in
+
   let build_of_block cur_map block =
     (try
        (* First, check that this block belongs to a subroutine *)
@@ -197,19 +258,8 @@ let build_next_instr sub_ranges (disasm: BStd.disasm): AddrSet.t AddrMap.t =
        (* Then the set of possible destinations for the block terminator *)
        (match last_addr with
         | Some last_addr ->
-          let following_set = BStd.Graphs.Cfg.Node.outputs block cfg
+          let following_set = block_following_set
-                              |> BStd.Seq.fold
+              block sub_first_addr sub_last_addr last_addr in
-                                ~init:AddrSet.empty
-                                ~f:(fun set edge -> AddrSet.union
-                                       (block_addresses
-                                          (BStd.Graphs.Cfg.Edge.dst edge))
-                                       set)
-                              |> AddrSet.filter (fun addr ->
-                                  sub_first_addr <= addr
-                                  && addr <= sub_last_addr)
-                                (* ^ We must ensure the landing address belongs
-                                   to the current subroutine for our purpose *)
-          in
           AddrMap.add last_addr following_set cur_map
         | None -> cur_map
        )
@@ -222,6 +272,11 @@ let build_next_instr sub_ranges (disasm: BStd.disasm): AddrSet.t AddrMap.t =
     ~init:AddrMap.empty
     ~f:build_of_block
 
+type rbp_pop_state =
+  | SomePop of BStd.tid
+  | SomeRbpUse
+  | NoPop
+
 let find_rbp_pop_set cfg entry =
   (** Returns a BStd.Tid.Set.t of the terms actually "popping" %rbp, that is,
       the terms that should trigger a change to RbpUndef of the %rbp register.
@@ -231,6 +286,8 @@ let find_rbp_pop_set cfg entry =
       ii) that are the last of this kind in the subroutine's CFG (ie. such that
         there is not another instruction matching (i) that is reachable through
         the CFG from the current instruction).
+      iii) that are the last references to %rbp in a `Def` in the subroutine's
+        CFG (cf (ii)).
   *)
 
   let def_is_rbp_pop def =
@@ -260,20 +317,30 @@ let find_rbp_pop_set cfg entry =
     )
   in
 
+  let def_uses_rbp def =
+    let def_vars = BStd.Var.Set.add
+        (BStd.Def.free_vars def)
+        (BStd.Def.lhs def) in
+    BStd.Var.Set.exists def_vars (fun var -> match Regs.X86_64.of_var var with
+        | Some x when x = Regs.X86_64.rbp -> true
+        | _ -> false)
+  in
 
   let block_find_rbp_pop block =
     let fold_elt = function
-      | `Def(def) when (def_is_rbp_pop def) -> Some (BStd.Term.tid def)
+      | `Def(def) when (def_is_rbp_pop def) -> SomePop (BStd.Term.tid def)
-      | _ -> None
+      | `Def(def) when (def_uses_rbp def) -> SomeRbpUse
+      | _ -> NoPop
     in
 
     let elts_seq = BStd.Blk.elts block in
     let last_pop = BStd.Seq.fold elts_seq
-        ~init:None
+        ~init:NoPop
         ~f:(fun accu elt ->
             (match fold_elt elt with
-             | None -> accu
+             | NoPop -> accu
-             | Some tid -> Some tid))
+             | SomeRbpUse -> SomeRbpUse
+             | SomePop tid -> SomePop tid))
     in
     last_pop
   in
@@ -288,7 +355,7 @@ let find_rbp_pop_set cfg entry =
       BStd.Tid.Set.empty, true, visited
     | false ->
       let visited = BStd.Blk.Set.add visited block in
-      let pop_set, has_pop, visited =
+      let pop_set, eligible, visited =
         BStd.Seq.fold (CFG.Node.succs node cfg)
           ~f:(fun (pre_pop_set, pre_has_pop, visited) child ->
               let cur_pop_set, cur_has_pop, visited =
@@ -299,14 +366,15 @@ let find_rbp_pop_set cfg entry =
             )
           ~init:(BStd.Tid.Set.empty, false, visited)
       in
-      let pop_set, has_pop = (match has_pop with
+      let pop_set, eligible = (match eligible with
           | false -> (* No rbp pop below, we seek rbp pops in this block *)
             (match block_find_rbp_pop block with
-                | None -> pop_set, false
+                | NoPop -> pop_set, false
-                | Some tid -> BStd.Tid.Set.add pop_set tid, true
+                | SomeRbpUse -> pop_set, true
+                | SomePop tid -> BStd.Tid.Set.add pop_set tid, true
             )
-          | true -> pop_set, has_pop) in
+          | true -> pop_set, eligible) in
-      pop_set, has_pop, visited
+      pop_set, eligible, visited
     )
   in
 
@@ -524,7 +592,13 @@ let process_jmp jmp (cur_reg: reg_pos)
   in
 
   match (BStd.Jmp.kind jmp) with
-  | BStd.Call call -> gen_change (-8)
+  | BStd.Call call -> (
+      (* If this call never returns (tail call), do not generate an offset of
+         -8. *)
+      match BStd.Call.return call with
+      | Some _ -> gen_change (-8)
+      | None -> None
+    )
   | BStd.Ret ret -> gen_change (8)
   | _ -> None
 
@@ -580,10 +654,15 @@ let process_blk
 
 exception Inconsistent of BStd.tid
 
-let get_entry_blk graph =
+let get_entry_blk graph first_addr =
+  let filter_out_of_range = function
+    | None -> None
+    | Some x when x < first_addr -> None
+    | Some x -> Some x
+  in
   let entry = BStd.Seq.min_elt (CFG.nodes graph) ~cmp:(fun x y ->
-      let ax = opt_addr_of @@ CFG.Node.label x
+      let ax = filter_out_of_range @@ opt_addr_of @@ CFG.Node.label x
-      and ay = opt_addr_of @@ CFG.Node.label y in
+      and ay = filter_out_of_range @@ opt_addr_of @@ CFG.Node.label y in
       match ax, ay with
       | None, None -> compare x y
       | Some _, None -> -1
@@ -653,19 +732,53 @@ let cleanup_fde (fde_changes: reg_changes_fde) : reg_changes_fde =
   match AddrMap.fold fold_one fde_changes (AddrMap.empty, None, false) with
   | out, _, _ -> out
 
+
+type merge_type =
+    Valid_merge
+  | Invalid_merge
+  | Valid_with_rbp_erasing of reg_pos
+
+let valid_merge_boilerplate regs_1 regs_2 valid_rbp_merge =
+  let r1_cfa, r1_rbp = regs_1 in
+  let r2_cfa, r2_rbp = regs_2 in
+  (match r1_cfa = r2_cfa with
+   | true -> valid_rbp_merge r1_rbp r2_rbp r1_cfa
+   | false -> Invalid_merge)
+
+
+let symmetric_valid_merge regs_1 regs_2 =
+  let valid_rbp_merge r1 r2 cfa = (match r1, r2 with
+      | x, y when x = y -> Valid_merge
+      | RbpUndef, RbpCfaOffset _ -> Valid_with_rbp_erasing (cfa, r1)
+      | RbpCfaOffset _, RbpUndef -> Valid_with_rbp_erasing (cfa, r2)
+      | _ -> Invalid_merge)
+  in
+  valid_merge_boilerplate regs_1 regs_2 valid_rbp_merge
+
+let valid_merge previous_regs cur_regs =
+  let valid_rbp_merge old cur cfa = (match old, cur with
+      | x, y when x = y -> Valid_merge
+      | RbpUndef, RbpCfaOffset _ -> Valid_merge
+      | RbpCfaOffset _, RbpUndef -> Valid_with_rbp_erasing (cfa, cur)
+      | _ -> Invalid_merge)
+  in
+  valid_merge_boilerplate previous_regs cur_regs valid_rbp_merge
+
 let process_sub sub next_instr_graph : subroutine_cfa_data =
   (** Extracts the `cfa_changes_fde` of a subroutine *)
 
   let cfg = BStd.Sub.to_cfg sub in
 
-  let first_addr = int64_addr_of sub in
+  let first_bap_addr = addr_of sub in
+  let first_addr = to_int64_addr first_bap_addr in
   let last_addr = find_last_addr sub in
 
   let initial_cfa_rsp_offset = Int64.of_int 8 in
 
-  let entry_blk = get_entry_blk cfg in
+  let entry_blk = get_entry_blk cfg (first_bap_addr) in
   let rbp_pop_set = find_rbp_pop_set cfg entry_blk in
 
+
   let rec dfs_process
       allow_rbp
       (sub_changes: (reg_changes_fde * reg_pos) TIdMap.t)
@@ -676,28 +789,64 @@ let process_sub sub next_instr_graph : subroutine_cfa_data =
     let cur_blk = CFG.Node.label node in
     let tid = BStd.Term.tid @@ cur_blk in
 
-    match (TIdMap.find_opt tid sub_changes) with
+    let compute_block_and_update entry_offset sub_changes =
-    | None ->
-      (* Not yet visited: compute the changes *)
       let cur_blk_changes, end_reg =
         process_blk next_instr_graph rbp_pop_set
           allow_rbp entry_offset cur_blk in
       let n_sub_changes =
         TIdMap.add tid (cur_blk_changes, entry_offset) sub_changes in
+      n_sub_changes, end_reg
+    in
+
+
+    match (TIdMap.find_opt tid sub_changes) with
+    | None ->
+      (* Not yet visited: compute the changes *)
+      let n_sub_changes, end_reg =
+        compute_block_and_update entry_offset sub_changes in
+
       BStd.Seq.fold (CFG.Node.succs node cfg)
-        ~f:(fun accu child -> dfs_process allow_rbp accu child end_reg)
+        ~f:(fun accu child ->
+            (match entrypoint_address (CFG.Node.label child) with
+             | Some x when x < first_bap_addr -> accu
+             | _ -> dfs_process allow_rbp accu child end_reg)
+            )
+
         ~init:n_sub_changes
     | Some (_, former_entry_offset) ->
       (* Already visited: check that entry values are matching *)
-      if entry_offset <> former_entry_offset then (
+
+      let do_fail () =
          if allow_rbp then
-          Format.eprintf "Found inconsistency (0x%Lx): %a -- %a@."
+           Format.eprintf "Found inconsistency (0x%Lx <%a>): %a -- %a@."
              (int64_addr_of cur_blk)
+             BStd.Tid.pp tid
              pp_reg_pos entry_offset pp_reg_pos former_entry_offset ;
          raise (Inconsistent tid)
+      in
+
+      (match valid_merge former_entry_offset entry_offset with
+       | Valid_merge -> sub_changes
+
+       | Invalid_merge -> do_fail ()
+       | Valid_with_rbp_erasing _ ->
+         (* Valid only if we manage to set back %rbp to undef in this block and
+            propagate the changes.
+            This tends to happen mostly in leaf blocks of a function (just
+            before a return), so we only handle the case for those blocks, in
+            which case there is no propagation needed.
+            The easy way to do this is simply to re-synthesize the block.
+         *)
+         let out_degree = CFG.Node.degree ~dir:`Out node cfg in
+         (match out_degree with
+          | 0 ->
+            let n_sub_changes, _ =
+              compute_block_and_update entry_offset sub_changes in
+            n_sub_changes
+          | _ ->
+            do_fail ()
+         )
       )
-      else
-        sub_changes
   in
 
   let with_rbp_if_needed initial_offset =
@@ -732,11 +881,16 @@ let process_sub sub next_instr_graph : subroutine_cfa_data =
   let changes_map = with_rbp_if_needed initial_offset in
 
   let merged_changes = TIdMap.fold
-      (fun _ (cfa_changes, _) accu -> AddrMap.union (fun _ v1 v2 ->
+      (fun _ (cfa_changes, _) accu -> AddrMap.union (fun addr v1 v2 ->
-           if v1 = v2 then
+           match (symmetric_valid_merge v1 v2) with
-             Some v1
+           | Valid_merge -> Some v1
-           else
+           | Invalid_merge ->
-             assert false)
+             Format.eprintf "Inconsistency: 0x%Lx: cannot merge %a - %a@."
+               addr pp_reg_pos v1 pp_reg_pos v2 ;
+             Some (CfaLostTrack, RbpUndef)
+           | Valid_with_rbp_erasing valid_merge ->
+             Some valid_merge
+         )
            cfa_changes accu)
       changes_map
       AddrMap.empty in
@@ -794,14 +948,18 @@ let build_sub_ranges prog: (memory_address) AddrMap.t =
     ~init:AddrMap.empty
     ~f:fold_subroutine
 
-let of_proj no_rbp_undef proj : subroutine_cfa_map =
+let of_proj no_rbp_undef timers proj : subroutine_cfa_map =
   (** Extracts the `cfa_changes` of a project *)
   __settings.no_rbp_undef <- no_rbp_undef ;
+  __settings.timers <- timers ;
+  timer_probe "dwarfsynth generation" ;
   let prog = BStd.Project.program proj in
   let sub_ranges = build_sub_ranges prog in
   let next_instr_graph =
     build_next_instr sub_ranges (BStd.Project.disasm proj) in
-  of_prog prog next_instr_graph
+  let result = of_prog prog next_instr_graph in
+  timer_probe "dwarfsynth cleaning" ;
+  result
 
 let clean_lost_track_subs pre_dwarf : subroutine_cfa_map =
   (** Removes the subroutines on which we lost track from [pre_dwarf] *)

HEURISTICS.md

@@ -0,0 +1,99 @@
+# Heuristics used for synthesis
+
+This file lists the major heuristics used for synthesis.
+
+## Initial row
+
+Initial row is always assumed as
+    CFA     rbp   ra
+    rsp+8   u     c-8
+
+## With or without %rbp?
+
+When synthesizing a FDE, there is sometimes a choice between using %rbp or
+not. For instance, it is possible that the original program uses %rbp for
+something entirely different than keeping a base pointer, without it being
+obvious: the synthesis must then avoid using %rbp.
+
+When synthesizing a FDE, two passes are applied on the function: a first pass
+that tracks %rbp to generate a correct table, but is denied using %rbp as an
+indexing mean for CFA. If this first pass fails by losing track of its CFA at
+some point, we fall back to a second phase that does the same, but switches its
+CFA indexing to %rbp if possible.
+
+This method works in practice because
+ * if the first pass succeeded, then a correct CFA indexing was found,
+ * if not, the original compiler could not generate a correct CFA indexing
+   either and was forced to use %rbp as a base pointer (except corner cases,
+   eg. clang sometimes generate code without possible correct unwinding data in
+   pre-abort error handling paths)
+
+## Lossy merge
+
+When two or more code branches merge at some point, we require that the
+unwinding data propagated by all of the branches can be merged into
+consistent data.
+
+Most of the time, *consistent* means strictly equivalent, but it can be
+weakened by allowing rows with %rbp undefined on one side and defined on the
+other to be merged — thus assuming the merged data is %rbp undefined, allowing
+a information loss.
+
+We actually process the control flow graph of a subroutine by walking it
+depth-first. When first encountering a new block, the propagated row is saved
+as the initial data for this block. When we encounter it again from another
+predecessor, the propagated row is merged if possible, or aborts with
+inconsistency. This merge operation is thus algorithmically free if the data
+first stored in the block is %rbp undefined — it is possible to just erase the
+data on the newly merged unwinding data. The other way around, changing the
+data already present, with which subsequent computations have already been
+made, would require recomputing a lot of data. We thus *only allow it* if the
+block is a leaf block in the control flow graph of the subroutine.
+
+This restriction in the application conditions works well in practice because
+gcc does not generate such lossy merges, and clang generates those only for the
+exit block of a function — just before `retq`.
+
+## CFA state tracking
+
+### When CFA is an offset of %rsp
+
+If the CFA is an offset of %rsp, it must be kept up to date when %rsp changes.
+In the BAP IR, every such change will generate some instruction `%rsp <- EXPR`.
+
+ * If the expression is just `%rsp <- %rsp + offset`, the CFA is updated with
+   this offset (most cases).
+ * If not, the analysis loses track and aborts. This case did not occur during
+   our testing while the CFA was indexed by %rsp.
+
+### When CFA is offset of %rbp
+
+If the CFA is an offset of %rbp, nothing special is required to track the CFA.
+
+### Switching between the modes: %rsp to %rbp indexing
+
+If the CFA is currently an offset of %rsp, an indexing mode change is detected
+when %rip is saved to %rbp. If the synthesis is currently allowed to use %rbp
+indexing (see *With or without %rbp?*), the indexing mode is then switched. If
+not, the current CFA indexing is kept.
+
+### Switching between the modes: %rbp to %rsp indexing
+
+The only event that triggers a revert to %rsp-based indexing is when %rbp gets
+overwritten with something while %rbp indexing.
+
+It is non-trivial to decide which %rsp offset should be used when switching
+back. So far, we have only encountered switches back to %rsp at the very end of
+functions — when %rbp was popped from the stack. Thus, we thus assume that upon
+restore, CFA=%rsp+8. This only works in practice since in the observed cases,
+compilers tend to stick to %rbp indexing when they decide to use it in a
+function.
+
+## %rbp state tracking
+
+Tracking the state of %rbp (or any other callee-saved register) can be done by
+tracking the program points at which
+
+ * %rbp is undefined and an instruction saves %rbp to the stack,
+ * %rbp is defined and an instruction overwrites %rbp with the data initially
+   saved on the stack

Makefile

@@ -1,23 +1,59 @@
 OCAMLBUILD=bapbuild -no-hygiene
 BAPBUNDLE=bapbundle
 ROOT_MODULE=dwarfsynth
+TARBALL=dwarfsynth.tar.gz
+
+LIBDWARFW_SO=libdwarfw/build/libdwarfw.so
+LIBDWARFW_SO_MESON=libdwarfw/build/build.ninja
 
 
 all: install ml_dwarf_write.bin
 
 .PHONY: ml_dwarf_write.bin
-ml_dwarf_write.bin:
+ml_dwarf_write.bin: $(LIBDWARFW_SO)
 	$(MAKE) -C DwarfSynth/c_bindings
 	ln -fs DwarfSynth/c_bindings/ml_dwarf_write.bin .
 
+.PHONY: $(LIBDWARFW_SO)
+$(LIBDWARFW_SO):
+	cd libdwarfw && test -d build || meson build
+	ninja -C libdwarfw/build
+
 .PHONY: $(ROOT_MODULE).plugin
 $(ROOT_MODULE).plugin:
 	$(OCAMLBUILD) $(ROOT_MODULE).plugin
 
+###############################################################################
 .PHONY: install
 install: $(ROOT_MODULE).plugin
 	$(BAPBUNDLE) install $<
 
+###############################################################################
 .PHONY: clean
 clean:
 	rm -rf _build
+
+###############################################################################
+tarball: $(TARBALL)
+
+.PHONY: $(TARBALL)
+$(TARBALL):
+	tar czf $(TARBALL) \
+		--exclude=.git \
+		--exclude=.gitignore \
+		--exclude=libdwarfw/build \
+		--exclude-backups \
+		--exclude=*.bck \
+		--exclude=*.bin \
+		--exclude=*.o \
+		--exclude=*.cmi \
+		--exclude=*.cmx \
+		--exclude=*.tar.gz \
+		--exclude=testsuite/sqlite3/sqlite \
+		--exclude=testsuite/gnupg/gnupg \
+		--exclude=testsuite/gnupg/gnupg \
+		--exclude=csmith/kept_tests \
+		--transform='s#^#dwarfsynth/#g' \
+		csmith DwarfSynth dwarfsynth.ml DwarfSynth.mlpack HEURISTICS.md \
+		libdwarfw LICENSE Makefile README.md synthesize_dwarf.sh _tags \
+		testsuite

README.md

@@ -8,8 +8,38 @@ examine its assembly code and, based solely on that, generate the corresponding
 
 ## Dependencies
 
-This tool relies on [BAP](https://github.com/BinaryAnalysisPlatform/bap), which
+This tool relies on
-is available through OPAM.
+
+* `opam` set up with an OCaml 4.05 switch (see below),
+* [BAP](https://github.com/BinaryAnalysisPlatform/bap) version 1.5 as of today,
+  which is available through OPAM;
+* `objcopy`, often packaged as `binutils`
+* `libelf`
+* `libdwarf`
+* `libdwarfw`, packaged as submodule
+
+### Installing dependencies
+
+You should be able to easily install `objcopy` (`binutils`), `libelf`,
+`libdwarf` and `opam` via your package manager.
+
+Once [`opam` is set up](https://opam.ocaml.org/doc/Install.html), you will have
+to use an `OCaml 4.05` opam switch. If you are not familiar with opam, we
+recommand using a fresh switch:
+
+```bash
+# If you never used opam before on this session:
+opam init
+eval $(opam config env)
+
+opam switch create dwarf-synthesis ocaml-base-compiler.4.05.0  # With opam 2
+# OR
+opam switch dwarf-synthesis --alias-of 4.05.0                  # With opam 1.x
+
+# Always:
+eval $(opam config env)
+opam install bap
+```
 
 ## Compiling
 

csmith/.gitignore

@@ -1 +1,3 @@
-0[0-9]/
+platform.info
+investigation
+kept_tests

csmith/check_generated_eh_frame.py

@@ -59,6 +59,24 @@ def detect_clang_flat_to_pyramid(rows):
       [k'; k[
     """
 
+    def is_flatness_row(row, prev_cfa, prev_loc, first_row=False):
+        for reg in row:
+            if reg not in ["LOC", "CFA", "ra"] and row[reg] != "u":
+                return prev_cfa, prev_loc, True
+        cfa = row["CFA"]
+        if cfa[:4] != "rsp+":
+            return prev_cfa, prev_loc, True
+        cfa_offset = int(cfa[4:])
+        if cfa_offset != prev_cfa + 8:
+            return prev_cfa, prev_loc, True
+        prev_cfa += 8
+        loc = row["LOC"]
+        if not first_row and loc > prev_loc + 2:
+            return prev_cfa, prev_loc, True
+        prev_loc = loc
+
+        return prev_cfa, prev_loc, False
+
     def try_starting_at(start_row):
         if len(rows) < start_row + 1:  # Ensure we have at least the start row
             return rows, False
@@ -69,22 +87,17 @@ def detect_clang_flat_to_pyramid(rows):
         first_cfa = int(rows[start_row]["CFA"][4:])
         prev_cfa = first_cfa
         prev_loc = rows[start_row]["LOC"]
+        first_row = True
+
         for row in rows[start_row + 1 :]:
-            for reg in row:
+            prev_cfa, prev_loc, flatness = is_flatness_row(
-                if reg not in ["LOC", "CFA", "ra"] and row[reg] != "u":
+                row, prev_cfa, prev_loc, first_row
+            )
+            first_row = False
+            if flatness:
                 break
-            cfa = row["CFA"]
-            if cfa[:4] != "rsp+":
-                break
-            cfa_offset = int(cfa[4:])
-            if cfa_offset != prev_cfa + 8:
-                break
-            prev_cfa += 8
-            loc = row["LOC"]
-            if loc > prev_loc + 2:
-                break
-            prev_loc = loc
             flatness_row_id += 1
+
         flatness_row_id += 1
         if flatness_row_id - start_row <= 1 or flatness_row_id >= len(rows):
             return rows, False  # nothing to change
@@ -172,17 +185,7 @@ def parse_fde(lines):
         for line in lines[2:]:
             rows.append(parse_fde_row(line, reg_cols))
 
-    # if pc_beg == 0x1160:
-    #     print("===== FDE: {}..{} ====".format(hex(pc_beg), hex(pc_end)))
-    #     print("BEFORE:")
-    #     for row in rows:
-    #         print(row)
     rows = detect_clang_flat_to_pyramid(rows)
-    # if pc_beg == 0x1160:
-    #     print("AFTER:")
-    #     for row in rows:
-    #         print(row)
-
     return {"beg": pc_beg, "end": pc_end, "rows": clean_rows(rows)}
 
 
@@ -282,6 +285,7 @@ def match_fde(orig, synth):
     rowchanges.sort(key=loc_of)
 
     mismatch_count = 0
+    match_count = 0
     for rowid, rowch in enumerate(rowchanges):
         typ, row = rowch[0], rowch[1]
         cur_val[typ] = vals_of(row)
@@ -297,8 +301,10 @@ def match_fde(orig, synth):
                     )
                 )
             mismatch_count += 1
+        else:
+            match_count += 1
 
-    return mismatch_count
+    return mismatch_count, match_count
 
 
 def parse_sym_table(handle):
@@ -347,11 +353,14 @@ def main():
     # dump_light_fdes(unmatched_synth)
 
     mismatches = 0
+    good_match = 0
     for (orig, synth) in matched:
-        mismatches += match_fde(orig, synth)
+        cur_mismatch, cur_match = match_fde(orig, synth)
+        mismatches += cur_mismatch
+        good_match += cur_match
     reports = []
     if mismatches > 0:
-        reports.append("{} mismatches".format(mismatches))
+        reports.append("{} mismatches - {} well matched".format(mismatches, good_match))
     if unmatched_orig:
         worth_reporting = False
         for unmatched in unmatched_orig:
@@ -374,8 +383,12 @@ def main():
         )
 
     if reports:
+        # If we had some errors to report, let's report positive data too
+        reports.append("{} matched".format(len(matched)))
         print("{}: {}".format(test_name, "; ".join(reports)))
+        return 1
+    return 0
 
 
 if __name__ == "__main__":
-    main()
+    sys.exit(main())

csmith/check_generated_eh_frame.sh

@@ -23,3 +23,4 @@ fi
     readelf -wF "$orig_path" ; \
     echo "===" ; \
     readelf -wF "$eh_path") | python $py_checker $*
+exit $?

dwarfsynth.ml

@@ -28,10 +28,19 @@ module Cmdline = struct
         ~default:false
     )
 
+  let timers = Cnf.(
+      param (bool) "timers"
+        ~doc:("Enable timers: print time probes at various points of the "
+              ^"code.")
+        ~as_flag:true
+        ~default: false
+    )
+
   let () = Cnf.(
       when_ready ((fun {get=(!!)} ->
           Bap.Std.Project.register_pass' (main
                                             ~no_rbp_undef:!!no_rbp_undef
+                                            ~timers:!!timers
                                             !!outfile )))
     )
 end

synthesize_dwarf.sh

@@ -15,9 +15,22 @@ If <binary_output_file> is provided, a binary file equivalent to
 <binary_input_file> that contains an .eh_frame ELF section will be written as
 <binary_output_file>.
 
-If not, the input file will be overwriten with such a file."
+If not, the input file will be overwriten with such a file.
+
+If the environment variable TIMERS is set to anything non-empty, the process
+will print timestamps at various locations to find out the time spent in
+the various steps.
+"
 ###############################################################################
 
+function timer_probe {
+    if [ -z "$TIMERS" ] ; then
+        return
+    fi
+    timer_name="$1"
+    >&2 echo "~~TIME~~ $timer_name [$(date +%s.%N)]"
+}
+
 function find_ml_dwarf_write {
     out=$(which "ml_dwarf_write.bin" 2>/dev/null)
     if [ -n "$out" ] ; then
@@ -35,7 +48,14 @@ function find_ml_dwarf_write {
 }
 
 function bap_synth {
+    timer_arg=""
+    if [ -n "$TIMERS" ]; then
+        timer_arg='--dwarfsynth-timers'
+    fi
+    # `--no-optimization`: it's actually faster without
     bap "$INPUT_FILE" \
+        $timer_arg \
+        --no-optimization \
         --no-byteweight -p dwarfsynth \
         --dwarfsynth-output "$TMP_DIR/marshal" $BAP_ARGS \
         > /dev/null
@@ -50,6 +70,7 @@ function dwarf_write_synth {
 
 function dwarf_plug {
     objcopy \
+        --remove-section '.eh_frame' --remove-section '.eh_frame_hdr' \
         --add-section .eh_frame="$TMP_DIR/eh_frame" \
         "$INPUT_FILE" "$OUTPUT_FILE"
     return $?
@@ -73,10 +94,18 @@ if ! [ -f "$INPUT_FILE" ] ; then
     >&2 echo -e "$INPUT_FILE: no such file.\n\n$HELP_TEXT"
 fi
 
+if [ -z "$OUTPUT_FILE" ] ; then
+    OUTPUT_FILE="$INPUT_FILE"
+fi
+
 TMP_DIR="$(mktemp -d)"
 
-bap_synth \
+timer_probe "bap startup" \
+    && bap_synth \
+    && timer_probe "write DWARF table" \
     && dwarf_write_synth \
-    && dwarf_plug
+    && timer_probe "insert DWARF table in binary" \
+    && dwarf_plug \
+    && timer_probe "finish"
 
 rm -rf "$TMP_DIR"

test/rec.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+int fac(int n) {
+    if(n <= 0)
+        return 0;
+    if(n == 1)
+        return 1;
+    return n * fac(n-1);
+}
+
+int main(void) {
+    printf("%d\n", fac(4));
+    return 0;
+}

testsuite/.gitignore

@@ -0,0 +1,2 @@
+*.tar.gz
+openssh

testsuite/csmith/.gitignore

@@ -0,0 +1,3 @@
+*.eh.bin
+*.bin
+!*.orig.bin

testsuite/csmith/Makefile

@@ -0,0 +1,19 @@
+ORIGBIN=$(shell find . -name '*.orig.bin')
+BASES=$(ORIGBIN:.orig.bin=)
+
+TEST_TARGETS=$(addsuffix -check, $(BASES))
+
+CHECK=../../csmith/check_generated_eh_frame.sh
+SYNTH=../../synthesize_dwarf.sh
+
+all: $(TEST_TARGETS)
+
+%-check: %.eh.bin
+	@$(CHECK) "$*" || true
+
+.PRECIOUS: %.eh.bin
+%.eh.bin: %.bin
+	BAP_ARGS='--dwarfsynth-no-rbp-undef' $(SYNTH) "$<" "$@"
+
+clean-synth:
+	rm -f $(BASES:=.eh.bin)

testsuite/csmith/clang_O0/06.c

@@ -0,0 +1,160 @@
+/*
+ * This is a RANDOMLY GENERATED PROGRAM.
+ *
+ * Generator: csmith 2.3.0
+ * Git version: 30dccd7
+ * Options:   (none)
+ * Seed:      7069041391684651990
+ */
+
+#include "csmith.h"
+
+
+static long __undefined;
+
+/* --- Struct/Union Declarations --- */
+/* --- GLOBAL VARIABLES --- */
+static int32_t g_2 = 0x91E29EA4L;
+static int32_t g_6[10][9] = {{(-2L),(-6L),1L,1L,(-6L),(-2L),(-6L),1L,1L},{0x6D238E48L,0x38330377L,0x969A22DBL,0x8EC32687L,0x969A22DBL,0x38330377L,0x6D238E48L,0x9226C312L,0xD4E70302L},{0x85B6478CL,(-6L),0x85B6478CL,(-2L),(-2L),0x85B6478CL,(-6L),0x85B6478CL,(-2L)},{0x8CAFA32FL,0x9226C312L,0x969A22DBL,0x12E1DFE0L,0xF82D83D7L,0x12E1DFE0L,0x969A22DBL,0x9226C312L,0x8CAFA32FL},{1L,(-2L),1L,(-2L),1L,1L,(-2L),1L,(-2L)},{0x969A22DBL,0x38330377L,0xF82D83D7L,2L,0x6D238E48L,0x12E1DFE0L,0x6D238E48L,2L,0xF82D83D7L},{(-2L),(-2L),0x85B6478CL,(-6L),0x85B6478CL,(-2L),(-2L),0x85B6478CL,(-6L)},{0xD4E70302L,0x38330377L,0xD4E70302L,0x12E1DFE0L,0x8CAFA32FL,0x8EC32687L,0x6D238E48L,0x8EC32687L,0x8CAFA32FL},{1L,0x85B6478CL,0x85B6478CL,1L,1L,1L,0x85B6478CL,0x85B6478CL,1L},{0x969A22DBL,0x12E1DFE0L,0xF82D83D7L,0x12E1DFE0L,0x969A22DBL,0x9226C312L,0x8CAFA32FL,2L,0x8CAFA32FL}};
+static uint8_t g_23 = 0x52L;
+
+
+/* --- FORWARD DECLARATIONS --- */
+uint16_t  func_1(void);
+
+
+/* --- FUNCTIONS --- */
+/* ------------------------------------------ */
+/* 
+ * reads : g_2 g_23 g_6
+ * writes: g_2 g_23
+ */
+uint16_t  func_1(void)
+{ /* block id: 0 */
+    int16_t l_11 = 0x5DE2L;
+    int32_t l_12 = 3L;
+    int32_t l_13 = 5L;
+    int32_t l_15 = 1L;
+    uint32_t l_16[7][10][3] = {{{18446744073709551610UL,0x1D5E8E05L,0x569FAA33L},{0xD8D46D8DL,18446744073709551615UL,0x5B7DFF93L},{0x1D5E8E05L,0x1D5E8E05L,0x5AE7BE98L},{0x92E414E4L,0x384C83B0L,1UL},{6UL,9UL,18446744073709551615UL},{0xE686B7DEL,0xDA2DD443L,0x384C83B0L},{18446744073709551615UL,6UL,18446744073709551615UL},{0UL,0x91F28F68L,1UL},{0x60280E44L,0x47BFE1A2L,0x5AE7BE98L},{0xDA2DD443L,0x92E414E4L,0x5B7DFF93L}},{{18446744073709551615UL,0x569FAA33L,0x569FAA33L},{0xDA2DD443L,0x8EB8A80AL,0xE686B7DEL},{0x60280E44L,0xAB159BBCL,0x1D5E8E05L},{0UL,0xE686B7DEL,0xDA2DD443L},{18446744073709551615UL,0x5AE7BE98L,1UL},{0xE686B7DEL,0xE686B7DEL,18446744073709551615UL},{6UL,0xAB159BBCL,0x72882C65L},{0x92E414E4L,0x8EB8A80AL,0xD8D46D8DL},{0x1D5E8E05L,0x569FAA33L,0xAB159BBCL},{0xD8D46D8DL,0x92E414E4L,0xD8D46D8DL}},{{18446744073709551610UL,0x47BFE1A2L,0x72882C65L},{0x15FA727FL,0x91F28F68L,18446744073709551615UL},{0x569FAA33L,6UL,1UL},{0x8F52837BL,0xDA2DD443L,0xDA2DD443L},{0x569FAA33L,9UL,0x1D5E8E05L},{0x15FA727FL,0x384C83B0L,0xE686B7DEL},{18446744073709551610UL,0x1D5E8E05L,0x569FAA33L},{0xD8D46D8DL,18446744073709551615UL,0x5B7DFF93L},{0x1D5E8E05L,0x1D5E8E05L,0x5AE7BE98L},{0x92E414E4L,0x384C83B0L,1UL}},{{6UL,9UL,18446744073709551615UL},{0xE686B7DEL,0xDA2DD443L,0x384C83B0L},{18446744073709551615UL,6UL,18446744073709551615UL},{0UL,0x91F28F68L,1UL},{0x60280E44L,0x47BFE1A2L,0x5AE7BE98L},{0xDA2DD443L,0x92E414E4L,0x5B7DFF93L},{18446744073709551615UL,0x569FAA33L,0x569FAA33L},{0xDA2DD443L,0x8EB8A80AL,0xE686B7DEL},{0x60280E44L,0xAB159BBCL,0x1D5E8E05L},{0UL,0xE686B7DEL,0xDA2DD443L}},{{18446744073709551615UL,0x5AE7BE98L,1UL},{0xE686B7DEL,0xE686B7DEL,18446744073709551615UL},{6UL,0xAB159BBCL,0x72882C65L},{0x92E414E4L,0x8EB8A80AL,0xD8D46D8DL},{0x1D5E8E05L,0x569FAA33L,0xAB159BBCL},{0xD8D46D8DL,0x92E414E4L,0xD8D46D8DL},{18446744073709551610UL,0x47BFE1A2L,0x72882C65L},{0x15FA727FL,0x91F28F68L,18446744073709551615UL},{0x569FAA33L,6UL,1UL},{0xE686B7DEL,0x8F52837BL,0x8F52837BL}},{{18446744073709551615UL,0x72882C65L,0x5AE7BE98L},{0xD8D46D8DL,0xDA2DD443L,18446744073709551615UL},{0x47BFE1A2L,0x5AE7BE98L,18446744073709551615UL},{0x384C83B0L,0x92E414E4L,0x15FA727FL},{0x5AE7BE98L,0x5AE7BE98L,6UL},{0UL,0xDA2DD443L,0x5B7DFF93L},{18446744073709551610UL,0x72882C65L,0xAB159BBCL},{18446744073709551615UL,0x8F52837BL,0xDA2DD443L},{0xAB159BBCL,18446744073709551610UL,0xAB159BBCL},{0x91F28F68L,0x8EB8A80AL,0x5B7DFF93L}},{{18446744073709551615UL,9UL,6UL},{0x8F52837BL,0UL,0x15FA727FL},{0x1D5E8E05L,18446744073709551615UL,18446744073709551615UL},{0x8F52837BL,1UL,18446744073709551615UL},{18446744073709551615UL,0x569FAA33L,0x5AE7BE98L},{0x91F28F68L,18446744073709551615UL,0x8F52837BL},{0xAB159BBCL,6UL,0x60280E44L},{18446744073709551615UL,18446744073709551615UL,0x92E414E4L},{18446744073709551610UL,0x569FAA33L,1UL},{0UL,1UL,0x384C83B0L}}};
+    int32_t *l_19 = &g_6[6][4];
+    int32_t *l_20 = &g_6[6][4];
+    int32_t *l_21[6];
+    int64_t l_22 = 1L;
+    int i, j, k;
+    for (i = 0; i < 6; i++)
+        l_21[i] = &l_13;
+    for (g_2 = 0; (g_2 == (-22)); g_2 = safe_sub_func_uint8_t_u_u(g_2, 1))
+    { /* block id: 3 */
+        int32_t *l_5 = &g_6[6][4];
+        int32_t *l_7 = &g_6[4][2];
+        int32_t *l_8 = &g_6[3][5];
+        int32_t *l_9 = (void*)0;
+        int32_t *l_10[3];
+        int64_t l_14 = 0L;
+        int i;
+        for (i = 0; i < 3; i++)
+            l_10[i] = (void*)0;
+        ++l_16[4][8][2];
+    }
+    ++g_23;
+    return (*l_20);
+}
+
+
+
+
+/* ---------------------------------------- */
+int main (int argc, char* argv[])
+{
+    int i, j;
+    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);
+    for (i = 0; i < 10; i++)
+    {
+        for (j = 0; j < 9; j++)
+        {
+            transparent_crc(g_6[i][j], "g_6[i][j]", print_hash_value);
+            if (print_hash_value) printf("index = [%d][%d]\n", i, j);
+
+        }
+    }
+    transparent_crc(g_23, "g_23", print_hash_value);
+    platform_main_end(crc32_context ^ 0xFFFFFFFFUL, print_hash_value);
+    return 0;
+}
+
+/************************ statistics *************************
+XXX max struct depth: 0
+breakdown:
+   depth: 0, occurrence: 8
+XXX total union variables: 0
+
+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: 2
+breakdown:
+   depth: 1, occurrence: 5
+   depth: 2, occurrence: 1
+
+XXX total number of pointers: 8
+
+XXX times a variable address is taken: 6
+XXX times a pointer is dereferenced on RHS: 1
+breakdown:
+   depth: 1, occurrence: 1
+XXX times a pointer is dereferenced on LHS: 0
+breakdown:
+XXX times a pointer is compared with null: 0
+XXX times a pointer is compared with address of another variable: 0
+XXX times a pointer is compared with another pointer: 0
+XXX times a pointer is qualified to be dereferenced: 591
+
+XXX max dereference level: 1
+breakdown:
+   level: 0, occurrence: 0
+   level: 1, occurrence: 2
+XXX number of pointers point to pointers: 0
+XXX number of pointers point to scalars: 8
+XXX number of pointers point to structs: 0
+XXX percent of pointers has null in alias set: 25
+XXX average alias set size: 1
+
+XXX times a non-volatile is read: 3
+XXX times a non-volatile is write: 3
+XXX times a volatile is read: 0
+XXX    times read thru a pointer: 0
+XXX times a volatile is write: 0
+XXX    times written thru a pointer: 0
+XXX times a volatile is available for access: 0
+XXX percentage of non-volatile access: 100
+
+XXX forward jumps: 0
+XXX backward jumps: 0
+
+XXX stmts: 4
+XXX max block depth: 1
+breakdown:
+   depth: 0, occurrence: 3
+   depth: 1, occurrence: 1
+
+XXX percentage a fresh-made variable is used: 5.84
+XXX percentage an existing variable is used: 94.2
+FYI: the random generator makes assumptions about the integer size. See platform.info for more details.
+********************* end of statistics **********************/
+

testsuite/csmith/clang_O0/14.c

@@ -0,0 +1,97 @@
+/*
+ * This is a RANDOMLY GENERATED PROGRAM.
+ *
+ * Generator: csmith 2.3.0
+ * Git version: 30dccd7
+ * Options:   (none)
+ * Seed:      11328556100234644801
+ */
+
+#include "csmith.h"
+
+
+static long __undefined;
+
+/* --- Struct/Union Declarations --- */
+/* --- GLOBAL VARIABLES --- */
+
+
+/* --- FORWARD DECLARATIONS --- */
+int8_t  func_1(void);
+
+
+/* --- FUNCTIONS --- */
+/* ------------------------------------------ */
+/* 
+ * reads :
+ * writes:
+ */
+int8_t  func_1(void)
+{ /* block id: 0 */
+    uint32_t l_2 = 0x6CCB0362L;
+    return l_2;
+}
+
+
+
+
+/* ---------------------------------------- */
+int main (int argc, char* argv[])
+{
+    int print_hash_value = 0;
+    if (argc == 2 && strcmp(argv[1], "1") == 0) print_hash_value = 1;
+    platform_main_begin();
+    crc32_gentab();
+    func_1();
+    platform_main_end(crc32_context ^ 0xFFFFFFFFUL, print_hash_value);
+    return 0;
+}
+
+/************************ statistics *************************
+XXX max struct depth: 0
+breakdown:
+   depth: 0, occurrence: 1
+XXX total union variables: 0
+
+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: 1
+breakdown:
+   depth: 1, occurrence: 1
+
+XXX total number of pointers: 0
+
+XXX times a non-volatile is read: 1
+XXX times a non-volatile is write: 0
+XXX times a volatile is read: 0
+XXX    times read thru a pointer: 0
+XXX times a volatile is write: 0
+XXX    times written thru a pointer: 0
+XXX times a volatile is available for access: 0
+XXX percentage of non-volatile access: 100
+
+XXX forward jumps: 0
+XXX backward jumps: 0
+
+XXX stmts: 1
+XXX max block depth: 0
+breakdown:
+   depth: 0, occurrence: 1
+
+XXX percentage a fresh-made variable is used: 100
+XXX percentage an existing variable is used: 0
+FYI: the random generator makes assumptions about the integer size. See platform.info for more details.
+********************* end of statistics **********************/
+

testsuite/csmith/clang_O0/18.c

@@ -0,0 +1,137 @@
+/*
+ * This is a RANDOMLY GENERATED PROGRAM.
+ *
+ * Generator: csmith 2.3.0
+ * Git version: 30dccd7
+ * Options:   (none)
+ * Seed:      9373947074814737804
+ */
+
+#include "csmith.h"
+
+
+static long __undefined;
+
+/* --- Struct/Union Declarations --- */
+/* --- GLOBAL VARIABLES --- */
+static int32_t g_3 = 0x22B16580L;
+static volatile int16_t g_9 = 1L;/* VOLATILE GLOBAL g_9 */
+static volatile int32_t g_11 = 0x816F93BDL;/* VOLATILE GLOBAL g_11 */
+static volatile int8_t g_12 = (-7L);/* VOLATILE GLOBAL g_12 */
+static uint64_t g_13 = 0xB6084EDC0223DEC9LL;
+
+
+/* --- FORWARD DECLARATIONS --- */
+uint32_t  func_1(void);
+
+
+/* --- FUNCTIONS --- */
+/* ------------------------------------------ */
+/* 
+ * reads : g_13 g_3
+ * writes: g_13
+ */
+uint32_t  func_1(void)
+{ /* block id: 0 */
+    int32_t *l_2 = &g_3;
+    int32_t l_4 = 0x5D811F07L;
+    int32_t *l_5 = (void*)0;
+    int32_t *l_6 = &l_4;
+    int32_t *l_7 = (void*)0;
+    int32_t *l_8[9];
+    int32_t l_10 = (-1L);
+    int i;
+    for (i = 0; i < 9; i++)
+        l_8[i] = &l_4;
+    g_13++;
+    return (*l_2);
+}
+
+
+
+
+/* ---------------------------------------- */
+int main (int argc, char* argv[])
+{
+    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_3, "g_3", print_hash_value);
+    transparent_crc(g_9, "g_9", print_hash_value);
+    transparent_crc(g_11, "g_11", print_hash_value);
+    transparent_crc(g_12, "g_12", print_hash_value);
+    transparent_crc(g_13, "g_13", print_hash_value);
+    platform_main_end(crc32_context ^ 0xFFFFFFFFUL, print_hash_value);
+    return 0;
+}
+
+/************************ statistics *************************
+XXX max struct depth: 0
+breakdown:
+   depth: 0, occurrence: 6
+XXX total union variables: 0
+
+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: 1
+breakdown:
+   depth: 1, occurrence: 3
+
+XXX total number of pointers: 5
+
+XXX times a variable address is taken: 3
+XXX times a pointer is dereferenced on RHS: 1
+breakdown:
+   depth: 1, occurrence: 1
+XXX times a pointer is dereferenced on LHS: 0
+breakdown:
+XXX times a pointer is compared with null: 0
+XXX times a pointer is compared with address of another variable: 0
+XXX times a pointer is compared with another pointer: 0
+XXX times a pointer is qualified to be dereferenced: 69
+
+XXX max dereference level: 1
+breakdown:
+   level: 0, occurrence: 0
+   level: 1, occurrence: 2
+XXX number of pointers point to pointers: 0
+XXX number of pointers point to scalars: 5
+XXX number of pointers point to structs: 0
+XXX percent of pointers has null in alias set: 40
+XXX average alias set size: 1
+
+XXX times a non-volatile is read: 2
+XXX times a non-volatile is write: 1
+XXX times a volatile is read: 0
+XXX    times read thru a pointer: 0
+XXX times a volatile is write: 0
+XXX    times written thru a pointer: 0
+XXX times a volatile is available for access: 3
+XXX percentage of non-volatile access: 100
+
+XXX forward jumps: 0
+XXX backward jumps: 0
+
+XXX stmts: 2
+XXX max block depth: 0
+breakdown:
+   depth: 0, occurrence: 2
+
+XXX percentage a fresh-made variable is used: 35.3
+XXX percentage an existing variable is used: 64.7
+********************* end of statistics **********************/
+

testsuite/csmith/clang_O0/21.c

@@ -0,0 +1,100 @@
+/*
+ * This is a RANDOMLY GENERATED PROGRAM.
+ *
+ * Generator: csmith 2.3.0
+ * Git version: 30dccd7
+ * Options:   (none)
+ * Seed:      5826903752990308834
+ */
+
+#include "csmith.h"
+
+
+static long __undefined;
+
+/* --- Struct/Union Declarations --- */
+/* --- GLOBAL VARIABLES --- */
+
+
+/* --- FORWARD DECLARATIONS --- */
+uint16_t  func_1(void);
+
+
+/* --- FUNCTIONS --- */
+/* ------------------------------------------ */
+/* 
+ * reads :
+ * writes:
+ */
+uint16_t  func_1(void)
+{ /* block id: 0 */
+    uint8_t l_2[4];
+    int i;
+    for (i = 0; i < 4; i++)
+        l_2[i] = 1UL;
+    return l_2[2];
+}
+
+
+
+
+/* ---------------------------------------- */
+int main (int argc, char* argv[])
+{
+    int print_hash_value = 0;
+    if (argc == 2 && strcmp(argv[1], "1") == 0) print_hash_value = 1;
+    platform_main_begin();
+    crc32_gentab();
+    func_1();
+    platform_main_end(crc32_context ^ 0xFFFFFFFFUL, print_hash_value);
+    return 0;
+}
+
+/************************ statistics *************************
+XXX max struct depth: 0
+breakdown:
+   depth: 0, occurrence: 1
+XXX total union variables: 0
+
+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: 1
+breakdown:
+   depth: 1, occurrence: 1
+
+XXX total number of pointers: 0
+
+XXX times a non-volatile is read: 1
+XXX times a non-volatile is write: 0
+XXX times a volatile is read: 0
+XXX    times read thru a pointer: 0
+XXX times a volatile is write: 0
+XXX    times written thru a pointer: 0
+XXX times a volatile is available for access: 0
+XXX percentage of non-volatile access: 100
+
+XXX forward jumps: 0
+XXX backward jumps: 0
+
+XXX stmts: 1
+XXX max block depth: 0
+breakdown:
+   depth: 0, occurrence: 1
+
+XXX percentage a fresh-made variable is used: 100
+XXX percentage an existing variable is used: 0
+FYI: the random generator makes assumptions about the integer size. See platform.info for more details.
+********************* end of statistics **********************/
+

testsuite/csmith/clang_O0/27.c

@@ -0,0 +1,744 @@
+/*
+ * This is a RANDOMLY GENERATED PROGRAM.
+ *
+ * Generator: csmith 2.3.0
+ * Git version: 30dccd7
+ * Options:   (none)
+ * Seed:      4939118505898640007
+ */
+
+#include "csmith.h"
+
+
+static long __undefined;
+
+/* --- Struct/Union Declarations --- */
+struct S0 {
+   const int16_t  f0;
+};
+
+/* --- GLOBAL VARIABLES --- */
+static int32_t g_2 = 1L;
+static int32_t g_31 = 0x4CBED562L;
+static uint16_t g_60 = 0xA37FL;
+static uint64_t g_80 = 18446744073709551610UL;
+static uint32_t g_94[1][1][1] = {{{18446744073709551612UL}}};
+static int32_t *g_106 = (void*)0;
+static int32_t **g_105 = &g_106;
+static int32_t *** volatile g_104[9] = {&g_105,&g_105,&g_105,&g_105,&g_105,&g_105,&g_105,&g_105,&g_105};
+static struct S0 g_112 = {0L};
+static struct S0 g_114 = {0x7435L};
+static const struct S0 *g_113 = &g_114;
+static uint32_t g_128 = 1UL;
+static uint16_t g_157 = 1UL;
+static int16_t g_205 = (-5L);
+static int64_t g_206[10][9][2] = {{{8L,0xC1F9FFFE23A00BB9LL},{4L,4L},{0xDC9C6B8B8FC5BE1FLL,0x26F0046A04E36BC8LL},{0x26F0046A04E36BC8LL,0L},{0x5CD842213CFF432ALL,0x5F2ABC7DE2BD186ELL},{0xDF84B9FB94D7B63DLL,0xC1F9FFFE23A00BB9LL},{0x0398EE976175C34ALL,0x47830171682B1930LL},{(-1L),0xAB61836B9FF5A867LL},{1L,(-1L)}},{{(-1L),0xE937EEBF2CD2CC1ELL},{(-2L),0x36EFE24D9FB8D8D9LL},{0x0398EE976175C34ALL,0x9414DFAFC3317156LL},{0L,0xD72D98116C57B5C6LL},{0xDC9C6B8B8FC5BE1FLL,0L},{(-1L),0xEDDA87D9E4C9B6CBLL},{0x47830171682B1930LL,0x5F2ABC7DE2BD186ELL},{4L,0x9414DFAFC3317156LL},{0xAB61836B9FF5A867LL,0xDC9C6B8B8FC5BE1FLL}},{{0xDF84B9FB94D7B63DLL,0xF9BAFFA15E022920LL},{0xEEB242C2FB3528B5LL,(-1L)},{0xC6D7AF98BDDBF572LL,0x6488FA247C74D67DLL},{0x9FCB6D48FF13D07ELL,(-1L)},{(-1L),(-2L)},{(-4L),0x5CD842213CFF432ALL},{0xD4F435555EB81EC1LL,(-5L)},{0xF97D4469016A669BLL,(-5L)},{0xD4F435555EB81EC1LL,0x5CD842213CFF432ALL}},{{(-4L),(-2L)},{(-1L),(-1L)},{0x9FCB6D48FF13D07ELL,0x6488FA247C74D67DLL},{0xC6D7AF98BDDBF572LL,(-1L)},{0xEEB242C2FB3528B5LL,0xF9BAFFA15E022920LL},{0xDF84B9FB94D7B63DLL,0L},{(-1L),1L},{(-10L),0xDC9C6B8B8FC5BE1FLL},{(-1L),(-5L)}},{{(-3L),0xF97D4469016A669BLL},{0L,0x47830171682B1930LL},{(-4L),1L},{(-5L),0x26F0046A04E36BC8LL},{4L,0x6488FA247C74D67DLL},{0xEEB242C2FB3528B5LL,1L},{4L,(-1L)},{0xDF84B9FB94D7B63DLL,(-1L)},{(-5L),(-1L)}},{{(-1L),0xDC9C6B8B8FC5BE1FLL},{0xD4F435555EB81EC1LL,0xF97D4469016A669BLL},{0x8D824AE4D288C40DLL,0x8D824AE4D288C40DLL},{0L,0x5CD842213CFF432ALL},{(-10L),(-1L)},{0xF9BAFFA15E022920LL,0x26F0046A04E36BC8LL},{0x9FCB6D48FF13D07ELL,0xF9BAFFA15E022920LL},{4L,0xA6F27C5AEF28909FLL},{4L,0xF9BAFFA15E022920LL}},{{0x9FCB6D48FF13D07ELL,0x26F0046A04E36BC8LL},{0xF9BAFFA15E022920LL,(-1L)},{(-10L),0x5CD842213CFF432ALL},{0L,0x8D824AE4D288C40DLL},{0x8D824AE4D288C40DLL,0xF97D4469016A669BLL},{0xD4F435555EB81EC1LL,0xDC9C6B8B8FC5BE1FLL},{(-1L),(-1L)},{(-5L),(-1L)},{0xDF84B9FB94D7B63DLL,(-1L)}},{{4L,1L},{0xEEB242C2FB3528B5LL,0x6488FA247C74D67DLL},{4L,0x26F0046A04E36BC8LL},{(-5L),1L},{(-4L),0x47830171682B1930LL},{0L,0xF97D4469016A669BLL},{(-3L),(-5L)},{(-1L),0xDC9C6B8B8FC5BE1FLL},{(-10L),1L}},{{(-1L),0L},{0xDF84B9FB94D7B63DLL,0xF9BAFFA15E022920LL},{0xEEB242C2FB3528B5LL,(-1L)},{0xC6D7AF98BDDBF572LL,0x6488FA247C74D67DLL},{0x9FCB6D48FF13D07ELL,(-1L)},{(-1L),(-2L)},{(-4L),0x5CD842213CFF432ALL},{0xD4F435555EB81EC1LL,(-5L)},{0xF97D4469016A669BLL,(-5L)}},{{0xD4F435555EB81EC1LL,0x5CD842213CFF432ALL},{(-4L),(-2L)},{(-1L),(-1L)},{0x9FCB6D48FF13D07ELL,0x6488FA247C74D67DLL},{0xC6D7AF98BDDBF572LL,(-1L)},{0xEEB242C2FB3528B5LL,0xF9BAFFA15E022920LL},{0xDF84B9FB94D7B63DLL,0L},{(-1L),1L},{(-10L),0xDC9C6B8B8FC5BE1FLL}}};
+static int8_t g_226 = 7L;
+static int64_t g_227 = 0L;
+static uint8_t g_289 = 0x38L;
+static int8_t g_291 = (-1L);
+static uint16_t g_410 = 0UL;
+static uint8_t *g_439 = (void*)0;
+static uint64_t *g_475 = &g_80;
+static int32_t g_482[9][2][7] = {{{0L,0L,0x6B7770A5L,0L,0L,0x6B7770A5L,0L},{(-9L),0x075A7863L,0x25BA78F7L,0xFEBB07E3L,0x25BA78F7L,0x075A7863L,(-9L)}},{{0x60323B76L,0L,0x60323B76L,0x60323B76L,0L,0x60323B76L,0x60323B76L},{(-9L),0xFEBB07E3L,(-2L),0xFEBB07E3L,(-9L),0x38509B10L,(-9L)}},{{0L,0x60323B76L,0x60323B76L,0L,0x60323B76L,0x60323B76L,0L},{0x25BA78F7L,0xFEBB07E3L,0x25BA78F7L,0x075A7863L,(-9L),0x075A7863L,0x25BA78F7L}},{{0L,0L,0x6B7770A5L,0L,0L,0L,0x60323B76L},{0x25BA78F7L,0x38509B10L,(-2L),0x075A7863L,(-2L),0x38509B10L,0x25BA78F7L}},{{0x6B7770A5L,0x60323B76L,0x6B7770A5L,0x6B7770A5L,0x60323B76L,0x6B7770A5L,0x6B7770A5L},{0x25BA78F7L,0x075A7863L,(-9L),0x075A7863L,0x25BA78F7L,0xFEBB07E3L,0x25BA78F7L}},{{0x60323B76L,0x6B7770A5L,0x6B7770A5L,0x60323B76L,0x6B7770A5L,0x6B7770A5L,0x60323B76L},{(-2L),0x075A7863L,(-2L),0x38509B10L,0x25BA78F7L,0x38509B10L,(-2L)}},{{0x60323B76L,0x60323B76L,0L,0x60323B76L,0x60323B76L,0L,0x60323B76L},{0x25BA78F7L,0x38509B10L,(-2L),0x075A7863L,(-2L),0x38509B10L,0x25BA78F7L}},{{0x6B7770A5L,0x60323B76L,0x6B7770A5L,0x6B7770A5L,0x60323B76L,0x6B7770A5L,0x6B7770A5L},{0x25BA78F7L,0x075A7863L,(-9L),0x075A7863L,0x25BA78F7L,0xFEBB07E3L,0x25BA78F7L}},{{0x60323B76L,0x6B7770A5L,0x6B7770A5L,0x60323B76L,0x6B7770A5L,0x6B7770A5L,0x60323B76L},{(-2L),0x075A7863L,(-2L),0x38509B10L,0x25BA78F7L,0x38509B10L,(-2L)}}};
+static int32_t * volatile g_484 = &g_482[5][0][0];/* VOLATILE GLOBAL g_484 */
+static int16_t g_533 = 0x5020L;
+static int32_t * volatile g_535[8][2][4] = {{{&g_31,&g_31,&g_31,&g_31},{&g_31,&g_31,&g_31,&g_31}},{{&g_31,&g_31,&g_31,&g_31},{&g_31,&g_31,&g_31,&g_31}},{{&g_31,&g_31,&g_31,&g_31},{&g_31,&g_31,&g_31,&g_31}},{{&g_31,&g_31,&g_31,&g_31},{&g_31,&g_31,&g_31,&g_31}},{{&g_31,&g_31,&g_31,&g_31},{&g_31,&g_31,&g_31,&g_31}},{{&g_31,&g_31,&g_31,&g_31},{&g_31,&g_31,&g_31,&g_31}},{{&g_31,&g_31,&g_31,&g_31},{&g_31,&g_31,&g_31,&g_31}},{{&g_31,&g_31,&g_31,&g_31},{&g_31,&g_31,&g_31,&g_31}}};
+static uint32_t g_540 = 1UL;
+static int32_t ***g_589 = &g_105;
+static int32_t **** volatile g_588[4] = {&g_589,&g_589,&g_589,&g_589};
+static int32_t **** volatile g_590 = &g_589;/* VOLATILE GLOBAL g_590 */
+static struct S0 *g_592[5][8][1] = {{{(void*)0},{(void*)0},{(void*)0},{&g_112},{&g_112},{&g_114},{&g_112},{&g_114}},{{&g_112},{&g_112},{(void*)0},{(void*)0},{(void*)0},{(void*)0},{&g_112},{&g_112}},{{&g_114},{&g_112},{&g_114},{&g_112},{&g_112},{(void*)0},{(void*)0},{(void*)0}},{{(void*)0},{&g_112},{&g_112},{&g_114},{&g_112},{&g_114},{&g_112},{&g_112}},{{(void*)0},{(void*)0},{(void*)0},{(void*)0},{&g_112},{&g_112},{&g_114},{&g_112}}};
+static struct S0 ** volatile g_591 = &g_592[4][0][0];/* VOLATILE GLOBAL g_591 */
+static volatile int32_t g_621 = 0L;/* VOLATILE GLOBAL g_621 */
+static volatile int32_t *g_620[10][10][2] = {{{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621},{(void*)0,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,(void*)0}},{{&g_621,(void*)0},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,(void*)0},{&g_621,(void*)0},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621}},{{(void*)0,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,(void*)0},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621}},{{&g_621,(void*)0},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,(void*)0},{&g_621,&g_621},{&g_621,(void*)0},{&g_621,&g_621},{&g_621,(void*)0},{&g_621,(void*)0}},{{&g_621,(void*)0},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621},{(void*)0,(void*)0},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621},{(void*)0,&g_621}},{{&g_621,&g_621},{&g_621,&g_621},{(void*)0,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,(void*)0},{(void*)0,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621}},{{&g_621,(void*)0},{&g_621,(void*)0},{&g_621,(void*)0},{&g_621,&g_621},{&g_621,(void*)0},{&g_621,&g_621},{&g_621,(void*)0},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621}},{{&g_621,(void*)0},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,(void*)0},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621}},{{&g_621,&g_621},{(void*)0,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,(void*)0},{&g_621,(void*)0},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621}},{{&g_621,(void*)0},{&g_621,(void*)0},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621},{(void*)0,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621},{&g_621,&g_621}}};
+static volatile int32_t **g_619 = &g_620[8][3][0];
+static volatile int32_t ***g_618 = &g_619;
+static uint8_t g_626 = 0x61L;
+static int64_t ****g_657 = (void*)0;
+static int64_t ***** volatile g_656 = &g_657;/* VOLATILE GLOBAL g_656 */
+static uint64_t g_678 = 0x39133899D178DA16LL;
+static volatile int32_t g_755 = (-7L);/* VOLATILE GLOBAL g_755 */
+static const int32_t g_759 = 1L;
+static int32_t * const ** const ** volatile g_769[3] = {(void*)0,(void*)0,(void*)0};
+static int32_t * const *g_773 = &g_106;
+static int32_t * const ** const g_772 = &g_773;
+static int32_t * const ** const *g_771[10][8][3] = {{{&g_772,&g_772,(void*)0},{&g_772,&g_772,&g_772},{&g_772,&g_772,(void*)0},{&g_772,&g_772,&g_772},{&g_772,(void*)0,&g_772},{&g_772,(void*)0,&g_772},{&g_772,&g_772,&g_772},{&g_772,&g_772,&g_772}},{{(void*)0,&g_772,&g_772},{&g_772,&g_772,(void*)0},{(void*)0,&g_772,&g_772},{(void*)0,(void*)0,(void*)0},{&g_772,(void*)0,(void*)0},{&g_772,&g_772,&g_772},{&g_772,&g_772,&g_772},{(void*)0,(void*)0,&g_772}},{{&g_772,&g_772,&g_772},{&g_772,(void*)0,&g_772},{&g_772,&g_772,&g_772},{&g_772,&g_772,&g_772},{&g_772,(void*)0,&g_772},{&g_772,(void*)0,&g_772},{&g_772,&g_772,&g_772},{&g_772,&g_772,(void*)0}},{{&g_772,&g_772,&g_772},{&g_772,&g_772,(void*)0},{&g_772,&g_772,&g_772},{&g_772,(void*)0,&g_772},{&g_772,(void*)0,&g_772},{(void*)0,&g_772,&g_772},{&g_772,&g_772,&g_772},{&g_772,&g_772,&g_772}},{{&g_772,&g_772,&g_772},{&g_772,&g_772,&g_772},{&g_772,&g_772,(void*)0},{&g_772,&g_772,&g_772},{(void*)0,&g_772,&g_772},{&g_772,&g_772,(void*)0},{&g_772,&g_772,&g_772},{&g_772,&g_772,&g_772}},{{&g_772,&g_772,&g_772},{&g_772,&g_772,&g_772},{&g_772,(void*)0,(void*)0},{&g_772,&g_772,&g_772},{&g_772,&g_772,(void*)0},{&g_772,&g_772,(void*)0},{&g_772,(void*)0,&g_772},{&g_772,(void*)0,&g_772}},{{&g_772,(void*)0,&g_772},{&g_772,&g_772,&g_772},{(void*)0,(void*)0,&g_772},{&g_772,&g_772,(void*)0},{&g_772,&g_772,(void*)0},{&g_772,&g_772,&g_772},{(void*)0,&g_772,(void*)0},{(void*)0,&g_772,&g_772}},{{&g_772,&g_772,&g_772},{(void*)0,(void*)0,&g_772},{&g_772,(void*)0,&g_772},{&g_772,&g_772,(void*)0},{&g_772,&g_772,&g_772},{&g_772,&g_772,&g_772},{&g_772,(void*)0,&g_772},{(void*)0,&g_772,&g_772}},{{&g_772,&g_772,&g_772},{&g_772,&g_772,&g_772},{&g_772,&g_772,&g_772},{&g_772,(void*)0,&g_772},{&g_772,&g_772,&g_772},{&g_772,&g_772,&g_772},{&g_772,&g_772,&g_772},{&g_772,&g_772,&g_772}},{{&g_772,&g_772,(void*)0},{(void*)0,(void*)0,&g_772},{(void*)0,&g_772,&g_772},{&g_772,&g_772,&g_772},{&g_772,&g_772,&g_772},{&g_772,&g_772,&g_772},{(void*)0,&g_772,&g_772},{&g_772,&g_772,&g_772}}};
+static int32_t * const ** const ** volatile g_770 = &g_771[2][5][1];/* VOLATILE GLOBAL g_770 */
+static const int16_t *** volatile g_776 = (void*)0;/* VOLATILE GLOBAL g_776 */
+static const int16_t *g_779[3] = {&g_114.f0,&g_114.f0,&g_114.f0};
+static const int16_t **g_778 = &g_779[2];
+static const int16_t *** volatile g_777[7][10] = {{&g_778,&g_778,(void*)0,&g_778,&g_778,&g_778,&g_778,(void*)0,(void*)0,&g_778},{(void*)0,&g_778,&g_778,&g_778,&g_778,(void*)0,&g_778,(void*)0,&g_778,&g_778},{&g_778,&g_778,&g_778,&g_778,&g_778,&g_778,&g_778,&g_778,(void*)0,&g_778},{&g_778,&g_778,(void*)0,&g_778,&g_778,(void*)0,&g_778,&g_778,(void*)0,&g_778},{(void*)0,&g_778,&g_778,(void*)0,&g_778,&g_778,&g_778,(void*)0,&g_778,&g_778},{&g_778,&g_778,&g_778,(void*)0,&g_778,&g_778,&g_778,(void*)0,&g_778,&g_778},{&g_778,&g_778,(void*)0,(void*)0,&g_778,&g_778,&g_778,&g_778,(void*)0,&g_778}};
+static int32_t g_820 = 1L;
+static volatile uint32_t g_912 = 4294967295UL;/* VOLATILE GLOBAL g_912 */
+static struct S0 g_932[10][1][5] = {{{{-1L},{-1L},{-1L},{0L},{2L}}},{{{0L},{-1L},{2L},{0L},{-1L}}},{{{2L},{0L},{-1L},{-1L},{0L}}},{{{0L},{0xFEE0L},{2L},{-1L},{0x996AL}}},{{{-1L},{0xFEE0L},{-1L},{-6L},{0xB55CL}}},{{{-6L},{0L},{0L},{-6L},{-6L}}},{{{-1L},{-1L},{0x996AL},{1L},{-6L}}},{{{0L},{-1L},{0xB55CL},{2L},{0xB55CL}}},{{{2L},{2L},{-6L},{1L},{0x996AL}}},{{{0L},{0L},{-6L},{-6L},{0L}}}};
+
+
+/* --- FORWARD DECLARATIONS --- */
+const int32_t  func_1(void);
+const uint8_t  func_5(uint32_t  p_6, uint32_t  p_7, const uint16_t  p_8, int16_t  p_9);
+uint64_t  func_12(const struct S0  p_13, uint32_t  p_14);
+int32_t  func_16(uint32_t  p_17, uint32_t  p_18);
+uint32_t  func_19(struct S0  p_20, uint8_t  p_21);
+uint32_t  func_22(int32_t  p_23, const uint32_t  p_24, uint64_t  p_25);
+int16_t  func_37(int8_t  p_38, uint32_t  p_39, uint8_t  p_40);
+uint16_t  func_44(int16_t  p_45, int64_t  p_46, struct S0  p_47, int32_t  p_48, uint64_t  p_49);
+int64_t  func_50(uint8_t  p_51);
+uint8_t  func_53(uint16_t  p_54, int32_t  p_55);
+
+
+/* --- FUNCTIONS --- */
+/* ------------------------------------------ */
+/* 
+ * reads : g_2 g_60 g_678 g_626
+ * writes: g_2 g_678
+ */
+const int32_t  func_1(void)
+{ /* block id: 0 */
+    int64_t l_11[6] = {(-1L),(-1L),(-1L),(-1L),(-1L),(-1L)};
+    struct S0 l_731 = {2L};
+    uint64_t *l_736[6] = {&g_80,&g_80,&g_80,&g_80,&g_80,(void*)0};
+    int32_t *l_803 = (void*)0;
+    int32_t l_825 = 0x8346A47DL;
+    uint64_t *l_866[4][5][7] = {{{&g_678,&g_678,&g_80,&g_80,&g_678,&g_678,&g_80},{&g_80,(void*)0,&g_678,(void*)0,&g_678,(void*)0,&g_80},{&g_80,&g_80,(void*)0,&g_678,&g_80,(void*)0,&g_80},{&g_678,&g_80,&g_678,&g_80,&g_678,&g_80,(void*)0},{&g_678,&g_678,(void*)0,(void*)0,&g_678,&g_678,&g_678}},{{&g_678,&g_80,&g_678,&g_80,&g_678,&g_80,&g_678},{&g_80,(void*)0,&g_80,&g_678,&g_678,(void*)0,(void*)0},{(void*)0,&g_80,&g_80,&g_80,(void*)0,(void*)0,&g_678},{&g_678,&g_678,&g_80,&g_80,&g_678,&g_678,&g_678},{&g_678,&g_80,&g_80,(void*)0,&g_678,&g_80,&g_678}},{{&g_678,&g_80,&g_80,&g_678,&g_678,&g_80,&g_80},{(void*)0,(void*)0,&g_678,(void*)0,&g_678,(void*)0,(void*)0},{&g_80,&g_678,(void*)0,&g_80,&g_80,&g_80,&g_80},{&g_678,&g_80,&g_678,&g_80,&g_678,&g_80,&g_678},{&g_678,&g_678,(void*)0,&g_678,&g_678,&g_80,&g_678}},{{&g_678,&g_80,&g_678,&g_80,(void*)0,&g_80,&g_678},{&g_80,&g_80,&g_80,(void*)0,&g_678,&g_80,(void*)0},{&g_80,&g_80,&g_80,&g_80,&g_80,(void*)0,&g_678},{&g_678,&g_678,&g_80,&g_678,&g_678,&g_80,&g_678},{&g_678,&g_80,&g_80,(void*)0,(void*)0,&g_80,(void*)0}}};
+    uint32_t l_898 = 3UL;
+    int32_t l_899 = 0L;
+    int8_t l_924 = (-9L);
+    uint32_t l_925 = 4294967290UL;
+    int32_t *l_946 = (void*)0;
+    int32_t *l_947 = &l_825;
+    int32_t *l_948 = &g_2;
+    int32_t *l_949 = &l_899;
+    int32_t *l_950 = (void*)0;
+    int32_t *l_951 = &g_482[5][1][4];
+    int32_t *l_952 = (void*)0;
+    int32_t *l_953 = &l_899;
+    int32_t *l_954 = &l_899;
+    int32_t *l_955 = &l_825;
+    int32_t *l_956 = &g_482[5][0][0];
+    int32_t *l_957 = &l_899;
+    int32_t *l_958 = &l_899;
+    int32_t l_959 = 0x478B5972L;
+    int32_t *l_960 = &l_899;
+    int32_t l_961 = (-1L);
+    int32_t *l_962 = (void*)0;
+    int32_t *l_963 = (void*)0;
+    int32_t *l_964 = &l_961;
+    int32_t l_965 = 0L;
+    int32_t *l_966 = &l_965;
+    int32_t *l_967 = &l_899;
+    int32_t l_968 = 0xA026CC2BL;
+    int32_t *l_969 = &g_31;
+    int32_t *l_970 = &l_968;
+    int32_t l_971 = 0xE99CE824L;
+    int32_t *l_972[4][5] = {{&l_959,&l_959,&l_959,&l_961,&l_968},{&g_482[5][0][0],&g_482[5][0][0],&l_968,&g_482[5][0][0],&g_482[5][0][0]},{&l_959,&g_482[5][0][0],&l_959,&g_482[5][0][0],&l_959},{&l_959,&l_959,&l_968,&g_482[5][0][0],&g_31}};
+    uint32_t l_973 = 0x876D107DL;
+    uint8_t l_978 = 0xD7L;
+    int i, j, k;
+    for (g_2 = 0; (g_2 >= (-18)); --g_2)
+    { /* block id: 3 */
+        int32_t l_10[5] = {2L,2L,2L,2L,2L};
+        const struct S0 l_15 = {0xB552L};
+        uint64_t **l_765 = (void*)0;
+        uint64_t ***l_764 = &l_765;
+        uint64_t ***l_766 = &l_765;
+        const int16_t *l_775 = &g_533;
+        const int16_t **l_774 = &l_775;
+        int32_t l_781 = 0xBE52AE16L;
+        int32_t l_782 = 0xA4430295L;
+        uint8_t l_783 = 9UL;
+        uint8_t l_819 = 0UL;
+        int32_t l_844 = 0x04CBAF0FL;
+        int8_t l_864 = 0L;
+        int32_t l_891 = (-1L);
+        int32_t * const *l_900 = &g_106;
+        uint16_t l_945[1];
+        int i;
+        for (i = 0; i < 1; i++)
+            l_945[i] = 65528UL;
+    }
+    --l_973;
+    l_978 = (safe_mul_func_int8_t_s_s(0xB7L, g_60));
+    for (l_898 = 0; (l_898 <= 1); l_898 += 1)
+    { /* block id: 466 */
+        uint64_t l_979 = 0xB46F44D803291F1ELL;
+        --l_979;
+        for (g_678 = 0; (g_678 <= 1); g_678 += 1)
+        { /* block id: 470 */
+            return g_626;
+        }
+    }
+    return g_626;
+}
+
+
+/* ------------------------------------------ */
+/* 
+ * reads : g_618 g_619 g_626 g_482
+ * writes: g_620 g_626 g_482
+ */
+const uint8_t  func_5(uint32_t  p_6, uint32_t  p_7, const uint16_t  p_8, int16_t  p_9)
+{ /* block id: 346 */
+    int32_t *l_725 = (void*)0;
+    int32_t *l_726 = &g_482[0][0][1];
+lbl_724:
+    (**g_618) = (void*)0;
+    for (g_626 = 17; (g_626 >= 27); g_626 = safe_add_func_int64_t_s_s(g_626, 7))
+    { /* block id: 350 */
+        int8_t l_723[8] = {0L,0L,0L,0L,0L,0L,0L,0L};
+        int i;
+        l_723[3] = p_7;
+        if (g_626)
+            goto lbl_724;
+        return p_7;
+    }
+    (*l_726) = 0xF1704B91L;
+    return (*l_726);
+}
+
+
+/* ------------------------------------------ */
+/* 
+ * reads : g_2 g_31 g_226 g_410 g_482 g_205 g_113 g_114 g_291 g_484 g_289 g_105 g_94 g_106 g_128 g_157 g_80 g_475 g_533 g_540 g_206 g_590 g_591 g_618 g_626 g_621 g_656 g_112.f0 g_619 g_620
+ * writes: g_31 g_60 g_475 g_80 g_482 g_106 g_128 g_157 g_540 g_533 g_226 g_410 g_589 g_592 g_626 g_657 g_227 g_620
+ */
+uint64_t  func_12(const struct S0  p_13, uint32_t  p_14)
+{ /* block id: 4 */
+    int8_t l_26 = 0x82L;
+    struct S0 l_494[9] = {{-3L},{-3L},{-3L},{-3L},{-3L},{-3L},{-3L},{-3L},{-3L}};
+    uint64_t l_495 = 0x929444579EC6F0FBLL;
+    uint32_t *l_537 = &g_128;
+    int32_t l_700 = (-1L);
+    int32_t *l_701 = &g_482[6][0][5];
+    int32_t *l_702 = (void*)0;
+    int32_t *l_703 = &l_700;
+    int32_t *l_704 = &l_700;
+    int32_t *l_705 = &g_482[6][1][4];
+    int32_t *l_706 = &g_482[1][0][6];
+    int32_t *l_707 = &g_482[5][0][0];
+    int32_t l_708[9][7][4] = {{{0x32A2E2ADL,0xE07A4AFDL,0x5743FA18L,0L},{9L,0x6C663A7DL,0xCA0535B4L,0xCA0535B4L},{(-1L),(-1L),0xB5305E5CL,0x1BAC1A7AL},{1L,0xA82DACEDL,0x372B3687L,0xA349DCE7L},{2L,1L,0xA687A79CL,0x372B3687L},{0x4EB7BD16L,1L,(-7L),0xA349DCE7L},{1L,0xA82DACEDL,0x3F0EB62CL,0x1BAC1A7AL}},{{0x7B7C6FF3L,(-1L),0x0E6DB3A9L,0xCA0535B4L},{0x2C4001A9L,0xF8D3D151L,0x3E0D5A9BL,8L},{(-1L),0x37D740C6L,7L,0xA82DACEDL},{0x0BEA32D2L,0x3F0EB62CL,0xBB719CDAL,2L},{0xCA0535B4L,0L,1L,0x0BEA32D2L},{(-6L),1L,0L,0x3E0D5A9BL},{0x2757F56FL,0xDFBE5776L,0x46239E21L,5L}},{{0x1BAC1A7AL,0x10D30892L,0xDAD0C92AL,0x8A797BA2L},{0x46239E21L,0x73EC1238L,0L,0xB2194DE8L},{(-2L),(-1L),0x9ECB3BC8L,2L},{0xC2E56F44L,1L,9L,6L},{0xBAED941FL,(-7L),9L,0x32A2E2ADL},{0xCB651077L,(-1L),0x10D30892L,0xF62A791AL},{(-3L),9L,0xE07A4AFDL,0xA687A79CL}},{{0xDD4F796DL,0xC4C9CD16L,0x4EB7BD16L,0xBB719CDAL},{0x10D30892L,0x16788205L,(-1L),3L},{0x37391391L,(-1L),2L,(-1L)},{0xBB719CDAL,0xBAED941FL,0xDD4F796DL,(-1L)},{1L,0x05AB6771L,0xC2E56F44L,(-1L)},{0x45FEB658L,0x4EB7BD16L,(-6L),0xEF48B12BL},{0x3F0EB62CL,0x5743FA18L,0xA349DCE7L,0x5743FA18L}},{{8L,(-1L),0xC5524747L,0x45FEB658L},{0x37D740C6L,5L,(-1L),0L},{2L,0xB5305E5CL,0xDFBE5776L,9L},{2L,0x1BAC1A7AL,(-1L),(-6L)},{0x37D740C6L,9L,0xC5524747L,0xA94BC96EL},{8L,0L,0xA349DCE7L,0xC2E56F44L},{0x3F0EB62CL,6L,(-6L),1L}},{{0x45FEB658L,0x40B05923L,0xC2E56F44L,0xE0427DC4L},{1L,5L,0xDD4F796DL,0x37391391L},{0xBB719CDAL,0x0BEA32D2L,2L,0x7D543402L},{0x37391391L,0xBE6A35D1L,(-1L),1L},{0x10D30892L,(-10L),0x4EB7BD16L,0xE07A4AFDL},{0xDD4F796DL,8L,0xE07A4AFDL,(-1L)},{(-3L),8L,0x10D30892L,0x73EC1238L}},{{0xCB651077L,9L,9L,0x67C34EF4L},{0xBAED941FL,0xA94BC96EL,9L,1L},{0xC2E56F44L,0x2757F56FL,0x9ECB3BC8L,0xB5305E5CL},{(-2L),3L,0L,9L},{0x46239E21L,0x37391391L,0xDAD0C92AL,0xA094968DL},{0x1BAC1A7AL,0x7B7C6FF3L,0x46239E21L,(-10L)},{0x2757F56FL,0x45FEB658L,0L,1L}},{{(-6L),0x8A797BA2L,(-10L),0xF62A791AL},{0xA94BC96EL,0xE6C1A697L,0xE0427DC4L,0L},{0x372B3687L,1L,0x46239E21L,0x8A797BA2L},{0xDAD0C92AL,(-1L),3L,0xE07A4AFDL},{0x76B33CB4L,(-1L),(-1L),0x76B33CB4L},{(-1L),0xB5305E5CL,0x1BAC1A7AL,1L},{0L,(-1L),0x3F0EB62CL,(-10L)}},{{0x330C1550L,(-1L),0xA349DCE7L,(-10L)},{1L,(-1L),0x6CC3A969L,1L},{(-1L),0xB5305E5CL,0x0E6DB3A9L,0x76B33CB4L},{0xBB719CDAL,(-1L),0xA94BC96EL,0xE07A4AFDL},{0x2757F56FL,(-1L),0xF62A791AL,0x8A797BA2L},{(-10L),1L,(-10L),0L},{9L,0xE6C1A697L,0x7CFF47C3L,0xF62A791AL}}};
+    int32_t *l_709 = (void*)0;
+    int32_t *l_710 = (void*)0;
+    int32_t *l_711 = &g_482[5][0][0];
+    int32_t *l_712 = (void*)0;
+    int32_t *l_713 = &g_482[5][0][0];
+    int32_t *l_714 = &g_482[5][0][0];
+    int32_t *l_715 = &l_700;
+    int32_t *l_716 = &g_482[5][0][0];
+    int32_t *l_717[3];
+    uint32_t l_718 = 0xDABAE242L;
+    int i, j, k;
+    for (i = 0; i < 3; i++)
+        l_717[i] = (void*)0;
+    l_700 = func_16(g_2, ((*l_537) = func_19((((func_22(l_26, (g_31 = (safe_rshift_func_uint8_t_u_u((safe_sub_func_uint32_t_u_u(p_14, (-1L))), p_14))), g_2) , 0x9AL) & (safe_lshift_func_uint8_t_u_u((safe_mod_func_int64_t_s_s(p_14, 0x3EF0EDB10875E408LL)), l_26))) , l_494[1]), l_495)));
+    l_701 = &l_700;
+    (*g_105) = &l_700;
+    l_718--;
+    return (*g_475);
+}
+
+
+/* ------------------------------------------ */
+/* 
+ * reads : g_540 g_157 g_410 g_105 g_206 g_590 g_591 g_226 g_618 g_114.f0 g_289 g_626 g_533 g_94 g_482 g_621 g_656 g_112.f0 g_205 g_80 g_475 g_484 g_619 g_620
+ * writes: g_540 g_157 g_533 g_226 g_128 g_410 g_106 g_589 g_592 g_626 g_657 g_482 g_227 g_620
+ */
+int32_t  func_16(uint32_t  p_17, uint32_t  p_18)
+{ /* block id: 255 */
+    int32_t l_538 = 2L;
+    int32_t *l_539[10][6] = {{&l_538,(void*)0,&g_482[8][1][2],&g_2,&g_2,(void*)0},{&g_31,&g_482[5][0][0],&g_482[5][0][0],&g_2,&g_2,&g_482[5][0][0]},{&l_538,&l_538,&g_482[5][0][0],&g_482[5][0][0],&g_482[8][1][2],&g_482[2][1][6]},{&g_482[2][1][6],(void*)0,&l_538,&g_482[5][0][0],(void*)0,&g_482[5][0][0]},{&g_31,&g_482[2][1][6],&l_538,&g_31,&l_538,&g_482[2][1][6]},{&g_2,&g_31,&g_482[5][0][0],&g_482[6][0][3],&g_482[5][0][0],&g_482[5][0][0]},{&g_482[6][0][3],&g_482[5][0][0],&g_482[5][0][0],&l_538,&g_482[7][0][3],(void*)0},{&g_482[5][0][0],&g_482[5][0][0],&g_482[8][1][2],&g_482[8][1][2],&g_482[5][0][0],&g_482[5][0][0]},{&g_482[5][0][0],&g_31,&g_482[2][1][6],(void*)0,&l_538,&g_482[5][0][0]},{&g_482[8][1][2],&g_482[2][1][6],&g_482[7][0][3],&g_31,(void*)0,&g_2}};
+    uint32_t l_622 = 0UL;
+    int8_t l_676 = (-1L);
+    int8_t l_681 = 1L;
+    int32_t ***l_691 = &g_105;
+    int8_t l_692 = 0x01L;
+    int32_t l_693[4][5] = {{4L,0xD60D148BL,0xD60D148BL,4L,4L},{0x8B273713L,0x47B0D9E6L,0x8B273713L,0x47B0D9E6L,0x8B273713L},{4L,4L,0xD60D148BL,0xD60D148BL,4L},{0L,0x47B0D9E6L,0L,0x47B0D9E6L,0L}};
+    int32_t l_694[9][4] = {{0xC6CBB58CL,0x59044AB2L,0x365BA97BL,0x59044AB2L},{0x59044AB2L,0L,0x365BA97BL,0x365BA97BL},{0xC6CBB58CL,0xC6CBB58CL,0x59044AB2L,0x365BA97BL},{0xFF8479B5L,0L,0xFF8479B5L,0x59044AB2L},{0xFF8479B5L,0x59044AB2L,0x59044AB2L,0xFF8479B5L},{0xC6CBB58CL,0x59044AB2L,0x365BA97BL,0x59044AB2L},{0x59044AB2L,0L,0x365BA97BL,0x365BA97BL},{0xC6CBB58CL,0xC6CBB58CL,0x59044AB2L,0x365BA97BL},{0xFF8479B5L,0L,0xFF8479B5L,0x59044AB2L}};
+    int32_t l_695 = 5L;
+    int64_t l_696 = 0xAA466618D5D0C41BLL;
+    uint32_t l_697 = 0xB09E1623L;
+    int i, j;
+    ++g_540;
+    for (g_157 = 14; (g_157 == 28); g_157++)
+    { /* block id: 259 */
+        uint32_t l_545 = 0UL;
+        int32_t l_567 = 0x505A8B48L;
+        uint32_t l_597 = 1UL;
+        int32_t ***l_616[10] = {&g_105,&g_105,&g_105,&g_105,&g_105,&g_105,&g_105,&g_105,&g_105,&g_105};
+        int32_t l_627[4][8][8] = {{{0x144BCE58L,0xF45F0988L,0x1928B3D1L,5L,0x37C2DFFBL,0x984FA087L,0x8C84018CL,0x37C2DFFBL},{0x2383E9C2L,5L,5L,3L,0xC16B911CL,0x1C555F7DL,0x6D573599L,1L},{(-7L),0x6DE4C1B2L,(-8L),(-10L),(-9L),0xFABA48DDL,0xA9DEF1EAL,1L},{0xF45F0988L,(-2L),0xA85D4C98L,5L,0xA85D4C98L,(-2L),0xF45F0988L,0xBA4DD380L},{0x984FA087L,(-1L),0x2383E9C2L,0x6DE4C1B2L,3L,0xFD8F5C03L,0xD5AD810AL,0x5EA5EEC7L},{(-8L),1L,1L,0x51D7FB2EL,3L,0L,0x51D7FB2EL,5L},{0x984FA087L,1L,0xFABA48DDL,0x5EA5EEC7L,0xA85D4C98L,0L,5L,(-8L)},{0xF45F0988L,0xC16B911CL,0x8C84018CL,0x1928B3D1L,(-9L),1L,(-1L),0x6D573599L}},{{(-7L),0x5EA5EEC7L,0L,(-8L),0xC16B911CL,(-10L),0xFABA48DDL,5L},{3L,0x0C9EFA26L,0x5C7D16E3L,(-9L),0xA9DEF1EAL,0xA85D4C98L,0x4B138195L,(-8L)},{0x4B138195L,0x37C2DFFBL,0xACF1C41CL,0x6DE4C1B2L,0x6DE4C1B2L,0xACF1C41CL,0x37C2DFFBL,0x4B138195L},{0xA9DEF1EAL,0xF45F0988L,0L,1L,0x984FA087L,0x0C9EFA26L,(-9L),1L},{5L,0x51D7FB2EL,1L,1L,1L,0x0C9EFA26L,5L,(-10L)},{0x37C2DFFBL,0xF45F0988L,(-1L),3L,0xD5AD810AL,0xACF1C41CL,(-9L),7L},{(-10L),0x37C2DFFBL,1L,(-9L),5L,0xA85D4C98L,0x0C9EFA26L,0xD5AD810AL},{1L,0x0C9EFA26L,0xBA4DD380L,0x4B138195L,0x0C9EFA26L,(-10L),0xF45F0988L,(-7L)}},{{0x37C2DFFBL,0x5EA5EEC7L,0x9EFCD6B4L,0xF45F0988L,5L,1L,7L,0x6DE4C1B2L},{0xDF00451FL,0xC16B911CL,(-8L),0L,0x984FA087L,0L,(-8L),0xC16B911CL},{7L,1L,(-9L),0x4B138195L,(-2L),0L,5L,0x0C9EFA26L},{0x4B138195L,1L,0xC2A26F55L,(-1L),7L,0xFD8F5C03L,5L,7L},{0L,(-1L),(-9L),0L,0xC16B911CL,(-2L),(-8L),1L},{0xC16B911CL,(-2L),(-8L),1L,0x51D7FB2EL,0xFABA48DDL,7L,0x5C7D16E3L},{0xF45F0988L,0x6DE4C1B2L,0x9EFCD6B4L,5L,0x1928B3D1L,0x1C555F7DL,0xF45F0988L,0x4B138195L},{1L,(-1L),0xBA4DD380L,(-2L),3L,0xDF00451FL,0x0C9EFA26L,0x5EA5EEC7L}},{{0x5EA5EEC7L,0x5C7D16E3L,1L,(-9L),0L,0L,(-9L),1L},{0xDF00451FL,0xDF00451FL,7L,(-9L),(-7L),1L,0xBA4DD380L,0L},{0xACF1C41CL,(-8L),0xFD8F5C03L,0xC2A26F55L,(-8L),1L,0x8C84018CL,0L},{(-8L),5L,(-1L),(-9L),5L,0x144BCE58L,0xA9DEF1EAL,0x2383E9C2L},{0xFABA48DDL,0x51D7FB2EL,1L,(-8L),(-2L),0xC16B911CL,0L,(-9L)},{0xBB1E3114L,0xA9DEF1EAL,(-6L),0x9EFCD6B4L,0xA85D4C98L,(-6L),0xB9ECE949L,0L},{(-2L),0xACF1C41CL,(-1L),0xBA4DD380L,0xFD8F5C03L,0xA3C53EF1L,1L,(-6L)},{0x6256DB07L,(-8L),5L,1L,0xBA4DD380L,(-9L),0xBA4DD380L,1L}}};
+        uint16_t l_630 = 9UL;
+        int64_t *l_655[4][2] = {{(void*)0,(void*)0},{(void*)0,(void*)0},{(void*)0,(void*)0},{(void*)0,(void*)0}};
+        int64_t **l_654 = &l_655[3][1];
+        int64_t ***l_653 = &l_654;
+        int64_t ****l_652 = &l_653;
+        uint64_t ** const l_680[2][8] = {{&g_475,&g_475,&g_475,&g_475,&g_475,&g_475,&g_475,&g_475},{&g_475,(void*)0,(void*)0,&g_475,&g_475,&g_475,&g_475,&g_475}};
+        int i, j, k;
+        --l_545;
+        if (l_545)
+            continue;
+        if (p_17)
+        { /* block id: 262 */
+            int32_t l_629 = (-8L);
+            int64_t **l_665 = &l_655[1][0];
+            int32_t l_679 = 0xF9263B17L;
+            if (p_17)
+            { /* block id: 263 */
+                int64_t l_548 = 0xF9695ADBCC2153A1LL;
+                l_548 = 1L;
+                return p_18;
+            }
+            else
+            { /* block id: 266 */
+                int32_t l_565 = 1L;
+                int32_t **l_583 = &l_539[4][2];
+                int32_t l_593 = (-1L);
+                int8_t *l_650 = &g_226;
+                uint64_t *l_677[5][4];
+                int i, j;
+                for (i = 0; i < 5; i++)
+                {
+                    for (j = 0; j < 4; j++)
+                        l_677[i][j] = &g_678;
+                }
+                for (g_533 = 0; (g_533 != (-24)); g_533 = safe_sub_func_uint16_t_u_u(g_533, 6))
+                { /* block id: 269 */
+                    int64_t l_555[9][5] = {{1L,1L,0L,0L,1L},{(-1L),0xFECC5331B20DD10ELL,(-1L),0xFECC5331B20DD10ELL,(-1L)},{1L,0L,0L,1L,1L},{2L,0xFECC5331B20DD10ELL,2L,0xFECC5331B20DD10ELL,2L},{1L,1L,0L,0L,1L},{(-1L),0xFECC5331B20DD10ELL,(-1L),0xFECC5331B20DD10ELL,(-1L)},{1L,0L,0L,1L,1L},{2L,0xFECC5331B20DD10ELL,2L,0xFECC5331B20DD10ELL,2L},{1L,1L,0L,0L,1L}};
+                    int8_t *l_566[9][7][1] = {{{&g_291},{&g_291},{(void*)0},{&g_291},{(void*)0},{&g_291},{&g_226}},{{&g_291},{&g_291},{(void*)0},{(void*)0},{&g_291},{&g_291},{&g_226}},{{&g_291},{(void*)0},{&g_291},{(void*)0},{&g_291},{&g_291},{&g_226}},{{(void*)0},{&g_226},{&g_291},{&g_291},{(void*)0},{&g_291},{(void*)0}},{{&g_291},{&g_226},{&g_291},{&g_291},{(void*)0},{(void*)0},{&g_291}},{{&g_291},{&g_226},{&g_291},{(void*)0},{&g_291},{(void*)0},{&g_291}},{{&g_291},{&g_226},{(void*)0},{&g_226},{&g_291},{&g_291},{(void*)0}},{{&g_291},{(void*)0},{&g_291},{&g_226},{&g_291},{&g_291},{(void*)0}},{{(void*)0},{&g_291},{&g_291},{&g_226},{&g_291},{(void*)0},{&g_291}}};
+                    uint32_t *l_572 = &g_128;
+                    int64_t *l_575 = &g_206[7][3][0];
+                    int64_t **l_574 = &l_575;
+                    int64_t ***l_573 = &l_574;
+                    int i, j, k;
+                    (*l_573) = (((((((safe_sub_func_uint32_t_u_u((safe_sub_func_uint16_t_u_u((p_18 ^ 1UL), l_555[8][0])), (safe_add_func_int8_t_s_s(l_545, (+p_17))))) != (safe_rshift_func_int8_t_s_u((l_567 ^= (safe_mul_func_int8_t_s_s((safe_unary_minus_func_uint32_t_u(p_17)), (g_226 = (!l_565))))), 5))) || (l_555[8][0] > (((*l_572) = (((safe_sub_func_int64_t_s_s((safe_mul_func_uint8_t_u_u(p_17, p_18)), l_565)) , (void*)0) == (void*)0)) ^ g_157))) , &l_567) == (void*)0) != 0xD5ED112C17E97BFALL) , (void*)0);
+                    if (p_17)
+                        continue;
+                }
+                for (p_17 = 0; (p_17 <= 1); p_17 += 1)
+                { /* block id: 278 */
+                    int32_t **l_582 = &l_539[9][4];
+                    uint16_t *l_633 = (void*)0;
+                    uint16_t *l_634 = &g_410;
+                    for (g_410 = 0; (g_410 <= 1); g_410 += 1)
+                    { /* block id: 281 */
+                        int32_t l_578 = 0x63B8E7DEL;
+                        int32_t l_586 = 5L;
+                        int32_t ***l_587 = (void*)0;
+                        int i, j, k;
+                        (*g_105) = l_539[(p_17 + 8)][(g_410 + 4)];
+                        l_586 &= (((l_578 = (safe_sub_func_int8_t_s_s(g_206[(g_410 + 7)][(g_410 + 3)][g_410], g_206[(g_410 + 3)][(g_410 + 5)][g_410]))) > p_18) || (safe_sub_func_int8_t_s_s((!(l_582 == (g_206[1][3][0] , l_583))), (safe_rshift_func_int8_t_s_u((-7L), 1)))));
+                        (*g_590) = l_587;
+                        (*g_591) = &g_112;
+                    }
+                    for (g_226 = 0; (g_226 <= 1); g_226 += 1)
+                    { /* block id: 290 */
+                        uint32_t l_594 = 0x81F161E9L;
+                        int32_t ****l_617 = &l_616[4];
+                        uint32_t *l_623 = &l_594;
+                        const int16_t l_624[3] = {0x6756L,0x6756L,0x6756L};
+                        uint8_t *l_625 = &g_626;
+                        int32_t l_628 = 1L;
+                        int i, j, k;
+                        l_594++;
+                        l_597 = g_206[(p_17 + 8)][(p_17 + 6)][g_226];
+                        l_627[0][1][5] |= (safe_mul_func_int8_t_s_s(1L, ((safe_unary_minus_func_uint16_t_u(((((safe_mod_func_int64_t_s_s((p_18 , ((safe_rshift_func_int16_t_s_u(((safe_mul_func_uint8_t_u_u(((*l_625) |= ((l_567 | ((*l_623) |= (((safe_mul_func_uint8_t_u_u(((0x4EL & ((+0xD028L) | p_17)) ^ ((safe_rshift_func_uint16_t_u_u((safe_sub_func_int8_t_s_s((0xE4L > 1L), ((((*l_617) = l_616[0]) != g_618) && 0xFD8AB39842A07C02LL))), p_17)) , g_114.f0)), p_18)) != g_289) > l_622))) == l_624[0])), p_18)) >= 0UL), p_18)) & p_18)), p_17)) == 0xC8C3A15DA5234EE0LL) | g_533) , 65526UL))) == g_114.f0)));
+                        --l_630;
+                    }
+                    if (p_18)
+                        continue;
+                    l_593 = (((*l_634) = (18446744073709551611UL != (g_94[0][0][0] , p_18))) != (safe_sub_func_uint64_t_u_u((&g_128 == (void*)0), 0UL)));
+                    for (l_593 = 1; (l_593 >= 0); l_593 -= 1)
+                    { /* block id: 304 */
+                        uint8_t *l_645[7] = {&g_289,&g_289,&g_289,&g_289,&g_289,&g_289,&g_289};
+                        int32_t l_651 = 0L;
+                        int i;
+                        l_651 = (safe_lshift_func_uint16_t_u_s(((*l_634)++), (safe_mul_func_uint8_t_u_u(g_482[5][0][0], (((safe_mod_func_uint32_t_u_u((((void*)0 == l_645[0]) >= (p_18 >= ((((-1L) & ((p_18 , ((safe_sub_func_uint8_t_u_u(p_18, ((l_629 = p_18) || (safe_mul_func_uint8_t_u_u(g_621, p_18))))) , l_650)) != (void*)0)) >= g_206[0][6][1]) < 0x8EL))), p_17)) == 0x3BF7L) , p_18)))));
+                        (*g_656) = l_652;
+                    }
+                }
+                (*g_484) ^= (p_18 > (safe_add_func_int8_t_s_s((((((l_593 &= (g_112.f0 ^ (safe_mod_func_int16_t_s_s(((((g_205 == (((((safe_mod_func_int8_t_s_s(((*l_650) = ((!(((void*)0 == l_665) == (l_629 < (safe_rshift_func_int16_t_s_s(((!((+0x38AAL) & (safe_div_func_uint32_t_u_u((safe_div_func_int32_t_s_s(((safe_mul_func_int8_t_s_s(p_18, g_114.f0)) == 6UL), p_17)), p_17)))) , l_676), g_80))))) , 0xF8L)), 0x51L)) | 0UL) >= p_18) <= 0x64L) >= g_114.f0)) , (-6L)) , &g_592[0][0][0]) != (void*)0), l_629)))) != (*g_475)) || p_18) , p_18) | 0UL), p_17)));
+            }
+            l_679 = (l_629 = p_18);
+            l_629 = ((*g_484) = ((void*)0 == l_680[1][4]));
+        }
+        else
+        { /* block id: 319 */
+            uint32_t l_685[1];
+            int i;
+            for (i = 0; i < 1; i++)
+                l_685[i] = 0x624A98D0L;
+            if ((p_18 <= l_681))
+            { /* block id: 320 */
+                uint8_t l_682 = 255UL;
+                l_682 = (&g_128 != (p_18 , &l_597));
+                for (g_540 = 1; (g_540 == 42); ++g_540)
+                { /* block id: 324 */
+                    if (p_17)
+                        break;
+                }
+                l_685[0]++;
+            }
+            else
+            { /* block id: 328 */
+                for (g_227 = 0; (g_227 < 28); g_227 = safe_add_func_int64_t_s_s(g_227, 6))
+                { /* block id: 331 */
+                    int8_t l_690[10][3] = {{9L,0x91L,0x91L},{2L,0x91L,0x56L},{(-3L),9L,0x6AL},{2L,2L,0x6AL},{9L,(-3L),0x56L},{0x91L,2L,0x91L},{0x91L,9L,2L},{9L,0x91L,0x91L},{2L,0x91L,0x56L},{(-3L),9L,0x6AL}};
+                    int i, j;
+                    l_690[1][1] = p_17;
+                }
+                (*g_484) = ((void*)0 != l_691);
+            }
+        }
+    }
+    (**g_618) = (**g_618);
+    --l_697;
+    return p_17;
+}
+
+
+/* ------------------------------------------ */
+/* 
+ * reads : g_128 g_157 g_80 g_291 g_31 g_475 g_2 g_533
+ * writes: g_128 g_157 g_482 g_80
+ */
+uint32_t  func_19(struct S0  p_20, uint8_t  p_21)
+{ /* block id: 240 */
+    const int32_t *l_498 = &g_482[0][0][3];
+    const int32_t **l_497[8] = {(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0};
+    const int32_t ***l_496 = &l_497[5];
+    const int32_t ****l_499 = (void*)0;
+    const int32_t ****l_500[3];
+    const int32_t ***l_501 = &l_497[1];
+    int i;
+    for (i = 0; i < 3; i++)
+        l_500[i] = &l_496;
+    l_501 = l_496;
+    for (g_128 = 0; (g_128 <= 8); g_128 += 1)
+    { /* block id: 244 */
+        uint32_t l_528 = 0xFDC2A730L;
+        for (g_157 = 0; (g_157 <= 2); g_157 += 1)
+        { /* block id: 247 */
+            uint64_t l_510 = 0x7300EACFC8219228LL;
+            int32_t *l_534 = &g_482[5][0][0];
+            int32_t l_536 = 0x92E89912L;
+            int i;
+            l_536 = ((safe_add_func_uint8_t_u_u((p_20.f0 > 1L), ((g_80 && (safe_unary_minus_func_int16_t_s((((*g_475) = ((~(safe_lshift_func_int16_t_s_s((((safe_mod_func_int16_t_s_s((l_510 && 18446744073709551611UL), (safe_unary_minus_func_int8_t_s((safe_sub_func_int16_t_s_s(((((*l_534) = ((-7L) < ((safe_mul_func_uint16_t_u_u(((safe_mod_func_uint16_t_u_u((p_20.f0 & ((((safe_rshift_func_int8_t_s_u(((((safe_lshift_func_int8_t_s_u((((safe_add_func_int16_t_s_s(((safe_mod_func_int32_t_s_s(l_528, (safe_rshift_func_uint8_t_u_s(((safe_div_func_int16_t_s_s(g_291, g_31)) <= 0UL), l_528)))) ^ 253UL), (-10L))) >= l_528) == p_20.f0), 0)) ^ (*g_475)) > g_2) && 3L), 7)) , (void*)0) == (void*)0) >= 1UL)), g_80)) & 1UL), 3UL)) || g_533))) & p_20.f0) == 0L), p_21)))))) < p_21) , 0x1255L), 5))) | g_157)) == p_21)))) ^ l_528))) && 0xDFB442A1BDC81E3DLL);
+        }
+    }
+    return g_2;
+}
+
+
+/* ------------------------------------------ */
+/* 
+ * reads : g_31 g_2 g_226 g_410 g_482 g_205 g_113 g_114 g_291 g_484 g_289 g_105 g_94 g_106
+ * writes: g_31 g_60 g_475 g_80 g_482 g_106
+ */
+uint32_t  func_22(int32_t  p_23, const uint32_t  p_24, uint64_t  p_25)
+{ /* block id: 6 */
+    int32_t l_34[2];
+    uint16_t l_41 = 0x7163L;
+    uint64_t l_52[4][9][7] = {{{0xBC92CEBB36E903ADLL,0x0B3897E00C1829B6LL,18446744073709551606UL,0x0B3897E00C1829B6LL,0xBC92CEBB36E903ADLL,0x684E8D7FF0BA59A1LL,0xE45221BA827CF573LL},{18446744073709551615UL,0xCDC70526E61A645CLL,3UL,0x70F5D9662A5332CFLL,1UL,0x7A227BBAC67CE96ELL,18446744073709551610UL},{0x8B5E68274657C2A8LL,5UL,0xB4DBDF9020C5ABFELL,0x00EEBEB99C015C40LL,18446744073709551615UL,0xA6DCE4D36899A90ALL,0xFBC2A5DE23EDE1F3LL},{18446744073709551615UL,0x70F5D9662A5332CFLL,1UL,0xDA74E9983536F110LL,0x52276C1F5E2D0B18LL,0xCDC70526E61A645CLL,0x87840EF1F3E16851LL},{0xBC92CEBB36E903ADLL,0UL,1UL,0UL,5UL,18446744073709551615UL,1UL},{0x0F218D362EA1E67ELL,0x30B13CFF85525C53LL,0x9DD310FED0A01C17LL,18446744073709551608UL,0x70F5D9662A5332CFLL,1UL,0x04247EC8A5E720F5LL},{1UL,18446744073709551610UL,18446744073709551615UL,0x2EC213DB237E2CA8LL,0xF45EA776A221E122LL,0xB4DBDF9020C5ABFELL,0UL},{1UL,4UL,18446744073709551615UL,0xA5798870B3783EA6LL,0UL,0xA5798870B3783EA6LL,18446744073709551615UL},{0UL,0UL,18446744073709551615UL,0xA73D9AAD11CF5132LL,0xC0D6813F8C547FCELL,0x3AE5685E9D070FEELL,5UL}},{{3UL,18446744073709551612UL,0x8DB22284F583EF4CLL,0x0F218D362EA1E67ELL,0x9DD310FED0A01C17LL,1UL,1UL},{18446744073709551615UL,0xBC92CEBB36E903ADLL,1UL,0UL,0xC0D6813F8C547FCELL,1UL,0x00EEBEB99C015C40LL},{0x052196DB3533B016LL,0xECB5CB1BEBA424ACLL,0xA5798870B3783EA6LL,1UL,0UL,0x70F5D9662A5332CFLL,18446744073709551613UL},{1UL,0xA73D9AAD11CF5132LL,0UL,18446744073709551615UL,0xF45EA776A221E122LL,1UL,5UL},{18446744073709551615UL,0xDA74E9983536F110LL,0xAA2DF500C330E0E3LL,0x739425A33ED86378LL,0x70F5D9662A5332CFLL,1UL,18446744073709551615UL},{0xF45EA776A221E122LL,0xABC5D6BB23DF4915LL,1UL,18446744073709551615UL,5UL,18446744073709551615UL,6UL},{0x4863FCCFB42DE3FCLL,0x52276C1F5E2D0B18LL,1UL,1UL,0x52276C1F5E2D0B18LL,0x4863FCCFB42DE3FCLL,18446744073709551607UL},{0UL,3UL,0xA73D9AAD11CF5132LL,6UL,18446744073709551615UL,0x66B31915E3087C3CLL,0x2DA4CB52C22A6657LL},{1UL,1UL,4UL,1UL,1UL,18446744073709551615UL,8UL}},{{0xAEA4CC78B939845FLL,3UL,0x3AE5685E9D070FEELL,0xA6DCE4D36899A90ALL,0xBC92CEBB36E903ADLL,0UL,1UL},{0xDA74E9983536F110LL,0x52276C1F5E2D0B18LL,0xCDC70526E61A645CLL,0x87840EF1F3E16851LL,0x77BAB6EA1325A46ELL,18446744073709551607UL,18446744073709551611UL},{18446744073709551606UL,0xABC5D6BB23DF4915LL,0UL,0UL,0xAEA4CC78B939845FLL,0xE45221BA827CF573LL,0xB4DBDF9020C5ABFELL},{18446744073709551610UL,1UL,0x8DB22284F583EF4CLL,1UL,0UL,0x052196DB3533B016LL,0x04247EC8A5E720F5LL},{0x2DA4CB52C22A6657LL,0xABC5D6BB23DF4915LL,1UL,1UL,18446744073709551610UL,18446744073709551610UL,1UL},{18446744073709551615UL,0x052196DB3533B016LL,18446744073709551615UL,0xE93B6ABB57DDD2E7LL,1UL,1UL,18446744073709551615UL},{0xAEA4CC78B939845FLL,0xB4DBDF9020C5ABFELL,0UL,0x0B3897E00C1829B6LL,0x3AE5685E9D070FEELL,1UL,18446744073709551615UL},{0x54F5258DDFA37A4CLL,18446744073709551613UL,0xBADF38E70E9EE194LL,1UL,0x04247EC8A5E720F5LL,1UL,1UL},{0xC0D6813F8C547FCELL,1UL,3UL,0xE541960CC19AB5AALL,0UL,18446744073709551610UL,18446744073709551608UL}},{{0xE93B6ABB57DDD2E7LL,0x739425A33ED86378LL,0UL,0x0F218D362EA1E67ELL,18446744073709551612UL,0x052196DB3533B016LL,0x54F5258DDFA37A4CLL},{18446744073709551606UL,0x00EEBEB99C015C40LL,0xA6DCE4D36899A90ALL,18446744073709551610UL,6UL,18446744073709551615UL,0x2DA4CB52C22A6657LL},{0xDA74E9983536F110LL,0UL,1UL,0x739425A33ED86378LL,18446744073709551615UL,0xECB5CB1BEBA424ACLL,0x70F5D9662A5332CFLL},{0x3AE5685E9D070FEELL,18446744073709551615UL,0xC0D6813F8C547FCELL,0xBC92CEBB36E903ADLL,0xC0D6813F8C547FCELL,18446744073709551615UL,0x3AE5685E9D070FEELL},{0UL,0x9DD310FED0A01C17LL,18446744073709551610UL,0xDA74E9983536F110LL,1UL,18446744073709551615UL,0x0F218D362EA1E67ELL},{0UL,0xFBC2A5DE23EDE1F3LL,0x3AE5685E9D070FEELL,0x66B31915E3087C3CLL,1UL,0xC0D6813F8C547FCELL,1UL},{0xECB5CB1BEBA424ACLL,0x54F5258DDFA37A4CLL,18446744073709551610UL,0UL,0xA5798870B3783EA6LL,18446744073709551615UL,0x7A227BBAC67CE96ELL},{5UL,1UL,0xC0D6813F8C547FCELL,0UL,18446744073709551615UL,0x2DA4CB52C22A6657LL,18446744073709551610UL},{1UL,0UL,1UL,18446744073709551612UL,0x14AC9FD4076B8492LL,0x7A227BBAC67CE96ELL,1UL}}};
+    uint32_t l_61 = 18446744073709551612UL;
+    int i, j, k;
+    for (i = 0; i < 2; i++)
+        l_34[i] = 0L;
+    for (p_23 = 10; (p_23 <= (-12)); p_23 = safe_sub_func_uint64_t_u_u(p_23, 9))
+    { /* block id: 9 */
+        int64_t l_72 = 0xC53E4AB27A36CEB1LL;
+        for (g_31 = 1; (g_31 >= 0); g_31 -= 1)
+        { /* block id: 12 */
+            uint16_t *l_59[3][3][2];
+            int32_t l_73 = (-3L);
+            int i, j, k;
+            for (i = 0; i < 3; i++)
+            {
+                for (j = 0; j < 3; j++)
+                {
+                    for (k = 0; k < 2; k++)
+                        l_59[i][j][k] = &g_60;
+                }
+            }
+            l_34[g_31] = (safe_mul_func_int16_t_s_s(func_37(l_34[0], (l_41 | 0x56A218F0ED693765LL), (l_34[0] , (((safe_mul_func_uint8_t_u_u(((func_44((func_50((l_52[2][5][5] , func_53((l_61 = (safe_lshift_func_uint8_t_u_u(((!g_2) >= (-10L)), 6))), (safe_mod_func_uint8_t_u_u(((safe_sub_func_int64_t_s_s(((g_2 <= (safe_div_func_int64_t_s_s(((safe_add_func_int16_t_s_s((safe_sub_func_int32_t_s_s(0x1895B12CL, l_72)), l_73)) >= 0x48L), l_73))) != 1L), 0xAE866A738CF3A2ABLL)) & p_23), 1L))))) , 0L), g_205, (*g_113), g_410, l_72) , l_73) >= p_23), p_24)) & p_24) , g_289))), g_291));
+            (*g_106) &= ((((g_94[0][0][0] | l_73) <= (safe_mul_func_uint8_t_u_u((safe_lshift_func_uint16_t_u_u(p_23, l_34[g_31])), p_25))) | 1L) ^ l_72);
+        }
+        if (l_72)
+            break;
+        return l_41;
+    }
+    l_34[0] = l_52[3][5][4];
+    return g_482[2][0][1];
+}
+
+
+/* ------------------------------------------ */
+/* 
+ * reads : g_105
+ * writes: g_106
+ */
+int16_t  func_37(int8_t  p_38, uint32_t  p_39, uint8_t  p_40)
+{ /* block id: 229 */
+    int32_t *l_485 = &g_482[5][0][0];
+    (*g_105) = l_485;
+    return p_39;
+}
+
+
+/* ------------------------------------------ */
+/* 
+ * reads : g_291 g_484
+ * writes: g_482
+ */
+uint16_t  func_44(int16_t  p_45, int64_t  p_46, struct S0  p_47, int32_t  p_48, uint64_t  p_49)
+{ /* block id: 226 */
+    (*g_484) = (~g_291);
+    return p_49;
+}
+
+
+/* ------------------------------------------ */
+/* 
+ * reads : g_226 g_410 g_482
+ * writes: g_475 g_80 g_482
+ */
+int64_t  func_50(uint8_t  p_51)
+{ /* block id: 220 */
+    int64_t l_464 = (-1L);
+    uint64_t *l_473 = &g_80;
+    uint64_t **l_474[9][3] = {{&l_473,&l_473,&l_473},{&l_473,&l_473,&l_473},{&l_473,&l_473,&l_473},{&l_473,&l_473,(void*)0},{(void*)0,&l_473,&l_473},{(void*)0,&l_473,&l_473},{(void*)0,&l_473,(void*)0},{&l_473,(void*)0,&l_473},{&l_473,&l_473,&l_473}};
+    int32_t l_479 = 0xCC01C951L;
+    uint16_t l_480[3][7] = {{65526UL,0UL,65526UL,65526UL,0UL,65526UL,65526UL},{0UL,0UL,0x482FL,0UL,0UL,0x482FL,0UL},{0UL,65526UL,65526UL,0UL,65526UL,65526UL,0UL}};
+    int32_t *l_481 = &g_482[5][0][0];
+    int i, j;
+    (*l_481) ^= ((l_464 != (((safe_mod_func_uint32_t_u_u((safe_sub_func_int64_t_s_s(((safe_mod_func_uint8_t_u_u(l_464, 0x14L)) || ((safe_lshift_func_uint8_t_u_s(((g_475 = l_473) == ((p_51 <= (!(((((g_80 = (p_51 & 0x02867D164A1839FBLL)) ^ (safe_lshift_func_int16_t_s_u((((p_51 <= (l_479 = (g_226 && 0xA335BC6AL))) || g_410) != l_464), p_51))) < 0xD2C4370CL) && 0xC2L) , 0x8F30L))) , &g_80)), l_480[1][5])) , l_464)), l_480[1][5])), p_51)) ^ 0x0AE6L) && l_464)) && 0UL);
+    return p_51;
+}
+
+
+/* ------------------------------------------ */
+/* 
+ * reads : g_60
+ * writes: g_60
+ */
+uint8_t  func_53(uint16_t  p_54, int32_t  p_55)
+{ /* block id: 14 */
+    uint16_t l_78[10][5] = {{65528UL,65528UL,65528UL,65528UL,65528UL},{65534UL,65534UL,65534UL,65534UL,65534UL},{65528UL,65528UL,65528UL,65528UL,65528UL},{65534UL,65534UL,65534UL,65534UL,65534UL},{65528UL,65528UL,65528UL,65528UL,65528UL},{65534UL,65534UL,65534UL,65534UL,65534UL},{65528UL,65528UL,65528UL,65528UL,65528UL},{65534UL,65534UL,65534UL,65534UL,65534UL},{65528UL,65528UL,65528UL,65528UL,65528UL},{65534UL,65534UL,65534UL,65534UL,65534UL}};
+    int32_t *l_103 = &g_2;
+    int32_t **l_102 = &l_103;
+    const struct S0 *l_111[4] = {&g_112,&g_112,&g_112,&g_112};
+    int32_t l_145 = 0xBD8C4516L;
+    int32_t l_149[7] = {0x8C39ED3BL,0x8C39ED3BL,0x8C39ED3BL,0x8C39ED3BL,0x8C39ED3BL,0x8C39ED3BL,0x8C39ED3BL};
+    int32_t l_172 = 0xFF09878DL;
+    const uint64_t l_210 = 0xDBB4F0F8AB85963DLL;
+    uint32_t l_213 = 2UL;
+    int32_t *l_316[9][2][3] = {{{(void*)0,(void*)0,(void*)0},{&g_31,&l_172,(void*)0}},{{&l_172,&g_31,(void*)0},{(void*)0,(void*)0,(void*)0}},{{&g_31,&l_172,(void*)0},{&l_172,&g_31,(void*)0}},{{(void*)0,(void*)0,(void*)0},{&g_31,&l_172,(void*)0}},{{&l_172,&g_31,(void*)0},{(void*)0,(void*)0,(void*)0}},{{&g_31,&l_172,(void*)0},{&l_172,&g_31,(void*)0}},{{(void*)0,(void*)0,(void*)0},{&g_31,&l_172,(void*)0}},{{&l_172,&g_31,(void*)0},{(void*)0,(void*)0,(void*)0}},{{&g_31,&l_172,(void*)0},{&l_172,&g_31,(void*)0}}};
+    const int32_t l_341[2] = {0x38881130L,0x38881130L};
+    uint32_t *l_360 = &g_128;
+    uint32_t **l_359[10] = {&l_360,&l_360,&l_360,&l_360,&l_360,&l_360,&l_360,&l_360,&l_360,&l_360};
+    uint16_t l_423 = 65528UL;
+    int i, j, k;
+    for (g_60 = 0; (g_60 != 8); g_60 = safe_add_func_uint32_t_u_u(g_60, 8))
+    { /* block id: 17 */
+        uint64_t *l_79 = &g_80;
+        int32_t l_85 = 0x5B57BD3FL;
+        int32_t l_115 = 2L;
+        int32_t **l_126[3][2];
+        int32_t l_142[5][10][3] = {{{(-5L),0L,0L},{(-1L),(-1L),0L},{6L,1L,0x86351EF7L},{(-1L),6L,0xC97F7709L},{8L,0L,(-1L)},{9L,6L,0L},{0xE1293A16L,1L,(-5L)},{(-1L),(-1L),6L},{(-1L),0L,9L},{0xE1293A16L,0xF7597347L,0x66B7E9E4L}},{{9L,0L,0xE1293A16L},{8L,0xE1293A16L,0x66B7E9E4L},{(-1L),0xA327EC85L,9L},{6L,0x0905539DL,6L},{(-1L),0x0905539DL,(-5L)},{(-5L),0xA327EC85L,0L},{0x0905539DL,0xE1293A16L,(-1L)},{1L,0L,0xC97F7709L},{0x0905539DL,0xF7597347L,0x86351EF7L},{(-5L),0L,0L}},{{(-1L),(-1L),0L},{6L,1L,0x86351EF7L},{(-1L),6L,0xC97F7709L},{8L,0L,(-1L)},{9L,6L,0L},{0xE1293A16L,1L,(-5L)},{(-1L),(-1L),6L},{(-1L),0L,9L},{0xE1293A16L,0xF7597347L,0x66B7E9E4L},{9L,0L,0xE1293A16L}},{{8L,0xE1293A16L,0x66B7E9E4L},{(-1L),0xA327EC85L,9L},{6L,0x0905539DL,6L},{(-1L),0L,6L},{6L,0L,(-1L)},{0L,1L,8L},{0L,(-1L),9L},{0L,0x86351EF7L,0xE1293A16L},{6L,(-1L),(-1L)},{0xF7597347L,8L,(-1L)}},{{(-1L),0L,0xE1293A16L},{0xC97F7709L,(-1L),9L},{0xD399BD31L,0x66B7E9E4L,8L},{(-5L),(-1L),(-1L)},{1L,0L,6L},{8L,8L,(-1L)},{8L,(-1L),(-5L)},{1L,0x86351EF7L,0x0905539DL},{(-5L),(-1L),1L},{0xD399BD31L,1L,0x0905539DL}}};
+        int64_t l_155 = 1L;
+        int16_t *l_219 = &g_205;
+        struct S0 l_223 = {0xCFC9L};
+        int16_t l_224 = (-1L);
+        int8_t *l_225 = &g_226;
+        uint32_t *l_340 = &g_128;
+        uint32_t **l_339 = &l_340;
+        uint16_t l_342 = 1UL;
+        const int64_t l_416 = (-5L);
+        int i, j, k;
+        for (i = 0; i < 3; i++)
+        {
+            for (j = 0; j < 2; j++)
+                l_126[i][j] = &l_103;
+        }
+    }
+    return p_54;
+}
+
+
+
+
+/* ---------------------------------------- */
+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_31, "g_31", print_hash_value);
+    transparent_crc(g_60, "g_60", print_hash_value);
+    transparent_crc(g_80, "g_80", print_hash_value);
+    for (i = 0; i < 1; i++)
+    {
+        for (j = 0; j < 1; j++)
+        {
+            for (k = 0; k < 1; k++)
+            {
+                transparent_crc(g_94[i][j][k], "g_94[i][j][k]", print_hash_value);
+                if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k);
+
+            }
+        }
+    }
+    transparent_crc(g_112.f0, "g_112.f0", print_hash_value);
+    transparent_crc(g_114.f0, "g_114.f0", print_hash_value);
+    transparent_crc(g_128, "g_128", print_hash_value);
+    transparent_crc(g_157, "g_157", print_hash_value);
+    transparent_crc(g_205, "g_205", print_hash_value);
+    for (i = 0; i < 10; i++)
+    {
+        for (j = 0; j < 9; j++)
+        {
+            for (k = 0; k < 2; k++)
+            {
+                transparent_crc(g_206[i][j][k], "g_206[i][j][k]", print_hash_value);
+                if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k);
+
+            }
+        }
+    }
+    transparent_crc(g_226, "g_226", print_hash_value);
+    transparent_crc(g_227, "g_227", print_hash_value);
+    transparent_crc(g_289, "g_289", print_hash_value);
+    transparent_crc(g_291, "g_291", print_hash_value);
+    transparent_crc(g_410, "g_410", print_hash_value);
+    for (i = 0; i < 9; i++)
+    {
+        for (j = 0; j < 2; j++)
+        {
+            for (k = 0; k < 7; k++)
+            {
+                transparent_crc(g_482[i][j][k], "g_482[i][j][k]", print_hash_value);
+                if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k);
+
+            }
+        }
+    }
+    transparent_crc(g_533, "g_533", print_hash_value);
+    transparent_crc(g_540, "g_540", print_hash_value);
+    transparent_crc(g_621, "g_621", print_hash_value);
+    transparent_crc(g_626, "g_626", print_hash_value);
+    transparent_crc(g_678, "g_678", print_hash_value);
+    transparent_crc(g_755, "g_755", print_hash_value);
+    transparent_crc(g_759, "g_759", print_hash_value);
+    transparent_crc(g_820, "g_820", print_hash_value);
+    transparent_crc(g_912, "g_912", print_hash_value);
+    for (i = 0; i < 10; i++)
+    {
+        for (j = 0; j < 1; j++)
+        {
+            for (k = 0; k < 5; k++)
+            {
+                transparent_crc(g_932[i][j][k].f0, "g_932[i][j][k].f0", print_hash_value);
+                if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k);
+
+            }
+        }
+    }
+    platform_main_end(crc32_context ^ 0xFFFFFFFFUL, print_hash_value);
+    return 0;
+}
+
+/************************ statistics *************************
+XXX max struct depth: 1
+breakdown:
+   depth: 0, occurrence: 236
+   depth: 1, occurrence: 9
+XXX total union variables: 0
+
+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: 40
+breakdown:
+   depth: 1, occurrence: 90
+   depth: 2, occurrence: 21
+   depth: 3, occurrence: 2
+   depth: 7, occurrence: 2
+   depth: 9, occurrence: 1
+   depth: 17, occurrence: 1
+   depth: 20, occurrence: 1
+   depth: 22, occurrence: 1
+   depth: 27, occurrence: 1
+   depth: 29, occurrence: 1
+   depth: 31, occurrence: 1
+   depth: 34, occurrence: 1
+   depth: 40, occurrence: 1
+
+XXX total number of pointers: 210
+
+XXX times a variable address is taken: 646
+XXX times a pointer is dereferenced on RHS: 40
+breakdown:
+   depth: 1, occurrence: 27
+   depth: 2, occurrence: 13
+XXX times a pointer is dereferenced on LHS: 91
+breakdown:
+   depth: 1, occurrence: 80
+   depth: 2, occurrence: 11
+XXX times a pointer is compared with null: 21
+XXX times a pointer is compared with address of another variable: 4
+XXX times a pointer is compared with another pointer: 0
+XXX times a pointer is qualified to be dereferenced: 3267
+
+XXX max dereference level: 5
+breakdown:
+   level: 0, occurrence: 0
+   level: 1, occurrence: 233
+   level: 2, occurrence: 152
+   level: 3, occurrence: 34
+   level: 4, occurrence: 20
+   level: 5, occurrence: 18
+XXX number of pointers point to pointers: 84
+XXX number of pointers point to scalars: 122
+XXX number of pointers point to structs: 4
+XXX percent of pointers has null in alias set: 32.4
+XXX average alias set size: 1.45
+
+XXX times a non-volatile is read: 693
+XXX times a non-volatile is write: 337
+XXX times a volatile is read: 6
+XXX    times read thru a pointer: 0
+XXX times a volatile is write: 9
+XXX    times written thru a pointer: 0
+XXX times a volatile is available for access: 884
+XXX percentage of non-volatile access: 98.6
+
+XXX forward jumps: 0
+XXX backward jumps: 1
+
+XXX stmts: 82
+XXX max block depth: 5
+breakdown:
+   depth: 0, occurrence: 33
+   depth: 1, occurrence: 12
+   depth: 2, occurrence: 8
+   depth: 3, occurrence: 10
+   depth: 4, occurrence: 9
+   depth: 5, occurrence: 10
+
+XXX percentage a fresh-made variable is used: 16.6
+XXX percentage an existing variable is used: 83.4
+********************* end of statistics **********************/
+

testsuite/csmith/clang_O0/29.c

@@ -0,0 +1,588 @@
+/*
+ * This is a RANDOMLY GENERATED PROGRAM.
+ *
+ * Generator: csmith 2.3.0
+ * Git version: 30dccd7
+ * Options:   (none)
+ * Seed:      12120557635237400247
+ */
+
+#include "csmith.h"
+
+
+static long __undefined;
+
+/* --- Struct/Union Declarations --- */
+/* --- GLOBAL VARIABLES --- */
+static int32_t g_3 = 0x98A8F939L;
+static int8_t g_11 = 0x22L;
+static volatile uint32_t g_13 = 0x885B3D92L;/* VOLATILE GLOBAL g_13 */
+static int16_t g_22 = 7L;
+static int32_t **g_72 = (void*)0;
+static int32_t g_75 = (-1L);
+static volatile int8_t g_79 = (-5L);/* VOLATILE GLOBAL g_79 */
+static int32_t *g_95 = &g_3;
+static int32_t ** volatile g_94 = &g_95;/* VOLATILE GLOBAL g_94 */
+static int16_t g_101 = 0x1B8EL;
+static int64_t g_111 = (-9L);
+static volatile int8_t g_112 = 0x14L;/* VOLATILE GLOBAL g_112 */
+static volatile int16_t g_113 = (-5L);/* VOLATILE GLOBAL g_113 */
+static int8_t g_114[7] = {(-1L),(-1L),(-1L),(-1L),(-1L),(-1L),(-1L)};
+static volatile uint32_t g_115[10][1][10] = {{{0x9DA24988L,0xE4BE9B3FL,1UL,1UL,0xE4BE9B3FL,0x9DA24988L,0xF1776544L,0xD8E0A4D0L,0xE864F27CL,0x931822BFL}},{{4294967295UL,4294967286UL,0xF1776544L,4294967286UL,5UL,0xE4BE9B3FL,0x858A7F69L,0x66CDF1D2L,6UL,4294967290UL}},{{4294967295UL,0x159807BFL,4294967290UL,0x9DA24988L,0x52EF7354L,0x9DA24988L,4294967290UL,0x159807BFL,4294967295UL,0xE864F27CL}},{{0x9DA24988L,4294967290UL,0x159807BFL,4294967295UL,0xE864F27CL,0x858A7F69L,4294967295UL,1UL,1UL,0xE864F27CL}},{{0xB1038030L,0x9DA24988L,4294967295UL,0xC9A06BD8L,5UL,4294967290UL,4294967290UL,5UL,0xC9A06BD8L,4294967295UL}},{{1UL,1UL,0x931822BFL,1UL,0x9DA24988L,0x159807BFL,0xA31BD4A4L,0x66CDF1D2L,4294967286UL,0xD8E0A4D0L}},{{4294967295UL,0x66CDF1D2L,0xE4BE9B3FL,0xB1038030L,4294967290UL,4294967286UL,0xA31BD4A4L,1UL,0xA31BD4A4L,4294967286UL}},{{0xD8E0A4D0L,1UL,0xB1038030L,1UL,0xD8E0A4D0L,0xE4BE9B3FL,4294967290UL,0x858A7F69L,0x9DA24988L,0x931822BFL}},{{4294967286UL,0x9DA24988L,0xC9A06BD8L,4294967295UL,0xB1038030L,4294967295UL,0xE4BE9B3FL,4294967295UL,0x931822BFL,0x931822BFL}},{{4294967290UL,4294967295UL,4294967286UL,0xD8E0A4D0L,0xD8E0A4D0L,4294967286UL,4294967295UL,4294967290UL,1UL,4294967286UL}}};
+static uint8_t g_152 = 255UL;
+static uint8_t g_156 = 246UL;
+static uint16_t g_160 = 8UL;
+static volatile uint64_t g_165 = 0xAF10161F38F8E0B2LL;/* VOLATILE GLOBAL g_165 */
+static volatile uint64_t * volatile g_164 = &g_165;/* VOLATILE GLOBAL g_164 */
+static uint16_t g_170 = 65527UL;
+static uint16_t g_174[1] = {65535UL};
+static int32_t *g_183 = &g_75;
+static const int32_t * const g_188 = &g_3;
+static volatile uint16_t g_190 = 0x106FL;/* VOLATILE GLOBAL g_190 */
+static int32_t g_196 = (-2L);
+static uint16_t g_197 = 65534UL;
+static int32_t ** volatile g_215[9] = {&g_95,&g_183,&g_95,&g_95,&g_183,&g_95,&g_95,&g_183,&g_95};
+static int32_t ** volatile g_216 = &g_183;/* VOLATILE GLOBAL g_216 */
+static int64_t *** volatile g_276 = (void*)0;/* VOLATILE GLOBAL g_276 */
+static int8_t g_312 = (-1L);
+static uint64_t g_313 = 0x3BBA409FF7E1002FLL;
+static volatile int64_t g_337 = (-1L);/* VOLATILE GLOBAL g_337 */
+static uint8_t *g_343 = &g_152;
+static volatile int64_t *g_346 = &g_337;
+static volatile int64_t **g_345 = &g_346;
+static uint32_t g_349 = 0x9011A977L;
+static int32_t ** volatile g_355[7] = {&g_95,&g_95,&g_95,&g_95,&g_95,&g_95,&g_95};
+static uint32_t g_390[8] = {2UL,2UL,2UL,2UL,2UL,2UL,2UL,2UL};
+static const int32_t ***g_429 = (void*)0;
+static volatile int16_t *g_459 = &g_113;
+static volatile int16_t * volatile *g_458 = &g_459;
+static uint32_t g_469 = 0x4B9680D0L;
+static int32_t ** volatile g_490 = &g_183;/* VOLATILE GLOBAL g_490 */
+static uint16_t g_518[4] = {0x1996L,0x1996L,0x1996L,0x1996L};
+static const int32_t g_527 = 0x5A0EC59AL;
+static uint64_t g_532 = 0x367F34663D782C50LL;
+static int32_t ** const  volatile g_574 = &g_183;/* VOLATILE GLOBAL g_574 */
+static uint8_t g_693[10] = {0xD5L,0xD5L,0xD5L,0xD5L,0xD5L,0xD5L,0xD5L,0xD5L,0xD5L,0xD5L};
+static int16_t *g_711[2][1] = {{&g_101},{&g_101}};
+static int16_t **g_710 = &g_711[1][0];
+static int16_t ***g_709 = &g_710;
+static int16_t **** volatile g_708[7] = {&g_709,&g_709,&g_709,&g_709,&g_709,&g_709,&g_709};
+static int16_t **** volatile g_712 = (void*)0;/* VOLATILE GLOBAL g_712 */
+static int16_t **** volatile g_713 = &g_709;/* VOLATILE GLOBAL g_713 */
+static int64_t g_730 = 0x993F76CE5798F22ELL;
+static int32_t ** volatile g_743 = &g_183;/* VOLATILE GLOBAL g_743 */
+static uint64_t *g_749 = (void*)0;
+static uint64_t **g_748 = &g_749;
+static uint64_t *** volatile g_747 = &g_748;/* VOLATILE GLOBAL g_747 */
+static int32_t ** volatile g_780 = &g_183;/* VOLATILE GLOBAL g_780 */
+static const int16_t g_840 = 0L;
+static int32_t ** volatile g_841 = (void*)0;/* VOLATILE GLOBAL g_841 */
+static int32_t ** volatile g_843[5] = {(void*)0,(void*)0,(void*)0,(void*)0,(void*)0};
+static int32_t ** volatile g_844 = &g_183;/* VOLATILE GLOBAL g_844 */
+static int8_t g_847 = 0x05L;
+static int32_t ** volatile g_861 = &g_183;/* VOLATILE GLOBAL g_861 */
+static int32_t g_865 = 0L;
+static uint32_t g_874 = 0xA8A315DEL;
+static int32_t ** volatile g_875 = &g_95;/* VOLATILE GLOBAL g_875 */
+static int32_t ** volatile g_876 = &g_183;/* VOLATILE GLOBAL g_876 */
+static volatile uint32_t *g_998 = &g_115[5][0][6];
+static volatile uint32_t ** const g_997[7][10][3] = {{{(void*)0,&g_998,&g_998},{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998},{&g_998,&g_998,(void*)0},{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998},{(void*)0,&g_998,&g_998},{&g_998,(void*)0,&g_998},{&g_998,&g_998,&g_998}},{{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998},{(void*)0,&g_998,&g_998},{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998},{&g_998,(void*)0,&g_998},{&g_998,&g_998,(void*)0},{&g_998,&g_998,&g_998}},{{&g_998,&g_998,&g_998},{(void*)0,&g_998,&g_998},{(void*)0,(void*)0,&g_998},{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998},{&g_998,(void*)0,&g_998},{&g_998,(void*)0,&g_998},{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998}},{{&g_998,(void*)0,&g_998},{&g_998,&g_998,&g_998},{(void*)0,&g_998,&g_998},{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998},{&g_998,&g_998,(void*)0},{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998}},{{&g_998,(void*)0,&g_998},{&g_998,(void*)0,&g_998},{(void*)0,&g_998,&g_998},{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998},{(void*)0,&g_998,&g_998},{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998},{(void*)0,&g_998,(void*)0}},{{&g_998,&g_998,&g_998},{&g_998,(void*)0,&g_998},{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998},{&g_998,(void*)0,&g_998},{&g_998,(void*)0,&g_998},{&g_998,&g_998,&g_998},{&g_998,&g_998,(void*)0},{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998}},{{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998},{&g_998,&g_998,&g_998},{(void*)0,&g_998,&g_998},{&g_998,&g_998,(void*)0},{&g_998,(void*)0,&g_998},{&g_998,&g_998,&g_998},{(void*)0,&g_998,&g_998},{&g_998,(void*)0,&g_998},{&g_998,&g_998,&g_998}}};
+static int16_t *g_1070 = &g_22;
+static uint32_t *g_1080 = (void*)0;
+static uint32_t * volatile *g_1079 = &g_1080;
+static uint32_t **g_1081 = (void*)0;
+static int64_t **g_1161 = (void*)0;
+static int64_t ***g_1160 = &g_1161;
+static int64_t ****g_1159 = &g_1160;
+static int64_t ****g_1163 = &g_1160;
+static const uint8_t g_1196 = 0x50L;
+static const uint8_t g_1198 = 252UL;
+
+
+/* --- FORWARD DECLARATIONS --- */
+int8_t  func_1(void);
+int32_t  func_23(uint32_t  p_24, const int16_t  p_25, int32_t * p_26);
+uint8_t  func_27(int32_t  p_28);
+int8_t  func_29(uint8_t  p_30);
+int16_t  func_40(int8_t  p_41);
+int16_t  func_42(uint32_t  p_43);
+uint32_t  func_46(const int16_t * p_47);
+int32_t *** func_54(int32_t * const  p_55, int32_t  p_56, int32_t ** p_57, const int8_t  p_58, const int32_t ** p_59);
+int32_t * const  func_60(int32_t  p_61, const int16_t * p_62);
+int32_t  func_66(int32_t ** p_67, uint16_t  p_68, int32_t * p_69, int32_t *** p_70, int16_t  p_71);
+
+
+/* --- FUNCTIONS --- */
+/* ------------------------------------------ */
+/* 
+ * reads : g_13 g_3 g_11 g_22 g_115 g_160 g_94 g_95 g_216 g_709 g_710 g_711 g_101 g_693 g_343 g_152 g_865 g_780 g_196 g_1159 g_1160 g_1163 g_313 g_75 g_197
+ * writes: g_13 g_22 g_3 g_183 g_101 g_196 g_1160 g_865 g_532 g_75
+ */
+int8_t  func_1(void)
+{ /* block id: 0 */
+    int32_t *l_2 = &g_3;
+    int32_t *l_4 = &g_3;
+    int32_t *l_5 = &g_3;
+    int32_t *l_6 = (void*)0;
+    int32_t *l_7 = &g_3;
+    int32_t *l_8 = &g_3;
+    int32_t *l_9 = &g_3;
+    int32_t *l_10[3][8][8] = {{{&g_3,(void*)0,&g_3,&g_3,&g_3,&g_3,&g_3,(void*)0},{&g_3,&g_3,&g_3,(void*)0,&g_3,(void*)0,(void*)0,&g_3},{(void*)0,&g_3,(void*)0,(void*)0,&g_3,&g_3,(void*)0,(void*)0},{(void*)0,(void*)0,&g_3,(void*)0,&g_3,&g_3,&g_3,&g_3},{&g_3,&g_3,&g_3,&g_3,(void*)0,(void*)0,(void*)0,&g_3},{&g_3,&g_3,&g_3,(void*)0,&g_3,(void*)0,&g_3,(void*)0},{(void*)0,&g_3,(void*)0,(void*)0,&g_3,&g_3,&g_3,&g_3},{(void*)0,&g_3,&g_3,&g_3,&g_3,&g_3,&g_3,&g_3}},{{&g_3,(void*)0,&g_3,(void*)0,&g_3,&g_3,&g_3,&g_3},{&g_3,(void*)0,&g_3,(void*)0,&g_3,&g_3,&g_3,(void*)0},{&g_3,&g_3,&g_3,&g_3,(void*)0,&g_3,(void*)0,(void*)0},{&g_3,(void*)0,&g_3,&g_3,(void*)0,&g_3,&g_3,(void*)0},{(void*)0,&g_3,&g_3,(void*)0,(void*)0,&g_3,&g_3,&g_3},{&g_3,&g_3,&g_3,(void*)0,&g_3,&g_3,&g_3,(void*)0},{(void*)0,&g_3,&g_3,&g_3,&g_3,(void*)0,&g_3,(void*)0},{(void*)0,(void*)0,&g_3,&g_3,&g_3,&g_3,(void*)0,(void*)0}},{{(void*)0,(void*)0,&g_3,(void*)0,&g_3,(void*)0,&g_3,&g_3},{&g_3,&g_3,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,&g_3},{(void*)0,(void*)0,&g_3,&g_3,(void*)0,&g_3,&g_3,(void*)0},{&g_3,(void*)0,&g_3,&g_3,(void*)0,(void*)0,&g_3,&g_3},{&g_3,&g_3,&g_3,&g_3,&g_3,&g_3,(void*)0,&g_3},{&g_3,&g_3,(void*)0,&g_3,&g_3,&g_3,&g_3,&g_3},{&g_3,&g_3,&g_3,&g_3,&g_3,&g_3,(void*)0,&g_3},{&g_3,(void*)0,&g_3,&g_3,(void*)0,&g_3,&g_3,(void*)0}}};
+    int8_t l_12 = 0L;
+    int16_t *l_20 = (void*)0;
+    int16_t *l_21[9] = {&g_22,&g_22,&g_22,&g_22,&g_22,&g_22,&g_22,&g_22,&g_22};
+    int32_t **l_39 = &l_4;
+    int64_t *l_214 = &g_111;
+    int8_t l_1129 = 0xC7L;
+    int32_t *l_1153 = &g_196;
+    uint64_t *l_1233 = (void*)0;
+    uint64_t *l_1234 = (void*)0;
+    uint64_t *l_1235 = &g_532;
+    const int32_t l_1236 = (-8L);
+    int i, j, k;
+    g_13++;
+    (*l_4) = (safe_add_func_int64_t_s_s(g_13, ((safe_lshift_func_int16_t_s_s((g_22 = 0L), 6)) == g_3)));
+    g_75 ^= func_23(((g_11 >= ((*l_1235) = (func_27(((*l_1153) = ((func_29((((safe_sub_func_uint32_t_u_u(((safe_div_func_int16_t_s_s(((safe_rshift_func_uint8_t_u_s((safe_mul_func_uint8_t_u_u((&g_3 != ((*l_39) = &g_3)), g_22)), 5)) , func_40((((**g_710) = ((*l_2) , func_42((safe_sub_func_uint32_t_u_u(func_46(l_20), (((g_160 <= ((safe_sub_func_int8_t_s_s(0x36L, 255UL)) != 0x47E4D3A49C13FF5FLL)) , l_214) == (void*)0)))))) , l_1129))), 2UL)) ^ (*l_9)), 0xD930E48EL)) | (-5L)) && 0x10D4L)) < (*g_343)) , g_865))) || (*g_343)))) | g_313), l_1236, l_1153);
+    return g_197;
+}
+
+
+/* ------------------------------------------ */
+/* 
+ * reads : g_95 g_3 g_196
+ * writes: g_3
+ */
+int32_t  func_23(uint32_t  p_24, const int16_t  p_25, int32_t * p_26)
+{ /* block id: 563 */
+    int32_t *l_1237[6];
+    int32_t l_1238 = 0xE5A34D66L;
+    int8_t l_1239 = 0L;
+    uint32_t l_1240[8][4][8] = {{{0UL,7UL,1UL,0x9D59D1AFL,0xD7F6947EL,3UL,0x99888F1BL,18446744073709551615UL},{0x6549C834L,1UL,0xB093344AL,1UL,0x9D59D1AFL,0x6549C834L,0x4F245711L,7UL},{0x8060F254L,0x0AED7F77L,0x1484EBF8L,18446744073709551615UL,0x01457BC1L,2UL,1UL,7UL},{7UL,0x5B081871L,0x6ECEFA63L,0xD2D8C813L,0xBAE77B86L,0UL,0xBAE77B86L,0xD2D8C813L}},{{0UL,0xBAE77B86L,0UL,0xB093344AL,0x8B1F6F98L,0x7DAB25F4L,0xA226FE92L,18446744073709551608UL},{0xD7F6947EL,0x7C3BC1F0L,0xA918308AL,0x9D59D1AFL,18446744073709551613UL,1UL,0x8B1F6F98L,18446744073709551606UL},{1UL,7UL,0x32ABA689L,0UL,5UL,0x8B1F6F98L,7UL,0x48E1CFC5L},{18446744073709551609UL,0UL,0x00D7B457L,9UL,18446744073709551613UL,0x6ECEFA63L,18446744073709551615UL,0xD7BDD3C1L}},{{0UL,0x60DB6959L,18446744073709551615UL,1UL,0x60DB6959L,0xF5BA06CBL,0x20A42D37L,3UL},{1UL,0xC14ADDBDL,0UL,0UL,2UL,0x784AC3D5L,0x4F245711L,1UL},{18446744073709551615UL,0xD7BDD3C1L,0x1D6F591CL,0xF5BA06CBL,1UL,8UL,0x00D7B457L,0x6531AB48L},{7UL,0x197BA9FBL,18446744073709551615UL,1UL,0xDC575280L,0x039DD24BL,0x1484EBF8L,18446744073709551615UL}},{{18446744073709551615UL,0x48E1CFC5L,0xF08BD21DL,1UL,0x6549C834L,0x8653EBB4L,5UL,0x48E1CFC5L},{0x00D7B457L,1UL,18446744073709551615UL,18446744073709551608UL,0x20A42D37L,8UL,9UL,0x27427C24L},{0x08D0F828L,0x26A0E0D4L,0xC270DB7EL,2UL,0x00D7B457L,0x6ECEFA63L,1UL,18446744073709551609UL},{0x93D61AA3L,2UL,0UL,0x7DAB25F4L,0xB093344AL,0x99888F1BL,5UL,0x6531AB48L}},{{8UL,0x93D61AA3L,0xDC575280L,3UL,2UL,18446744073709551615UL,18446744073709551615UL,2UL},{0xCFB92F85L,18446744073709551615UL,18446744073709551615UL,0xCFB92F85L,6UL,9UL,0x48E1CFC5L,0xF5BA06CBL},{0xD7BDD3C1L,18446744073709551613UL,3UL,1UL,0x20A42D37L,0xF08BD21DL,0x4F245711L,0x01457BC1L},{0xC270DB7EL,18446744073709551613UL,1UL,0xC28E6EC9L,1UL,9UL,1UL,18446744073709551615UL}},{{1UL,18446744073709551615UL,18446744073709551615UL,5UL,0x039DD24BL,18446744073709551615UL,0xD7BDD3C1L,18446744073709551606UL},{7UL,0x93D61AA3L,1UL,0xA226FE92L,0x48E1CFC5L,0x99888F1BL,7UL,0xD7BDD3C1L},{0x6ECEFA63L,2UL,8UL,18446744073709551606UL,0UL,0x6ECEFA63L,0xDC575280L,0UL},{2UL,0x26A0E0D4L,18446744073709551608UL,0x6531AB48L,0x60DB6959L,8UL,0x4F245711L,6UL}},{{0xCFB92F85L,1UL,0x586B1444L,0UL,0x48E1CFC5L,0x8653EBB4L,18446744073709551613UL,0xCFB92F85L},{0UL,0x48E1CFC5L,0x1D6F591CL,8UL,0x7C3BC1F0L,0x039DD24BL,8UL,0x01457BC1L},{1UL,0x197BA9FBL,0xDC575280L,0xA226FE92L,1UL,8UL,0x7C3BC1F0L,0x00D7B457L},{18446744073709551615UL,0xD7BDD3C1L,0x32ABA689L,0x3D21F9EDL,0x20A42D37L,0x784AC3D5L,0xD7BDD3C1L,0x48E1CFC5L}},{{18446744073709551615UL,0xC14ADDBDL,18446744073709551606UL,6UL,18446744073709551613UL,0xF5BA06CBL,9UL,0x01457BC1L},{0xCFB92F85L,0x60DB6959L,18446744073709551606UL,0x7DAB25F4L,0xC28E6EC9L,0x6ECEFA63L,0x197BA9FBL,3UL},{8UL,18446744073709551609UL,18446744073709551613UL,18446744073709551609UL,8UL,5UL,1UL,0xEFACA8E0L},{0x8060F254L,0xC28E6EC9L,0x8653EBB4L,1UL,0xCE38D759L,0x32ABA689L,18446744073709551615UL,18446744073709551609UL}}};
+    int32_t **l_1243 = &l_1237[4];
+    int i, j, k;
+    for (i = 0; i < 6; i++)
+        l_1237[i] = (void*)0;
+    --l_1240[6][0][4];
+    (*l_1243) = p_26;
+    (*g_95) ^= (p_24 >= (8L <= p_25));
+    return (*p_26);
+}
+
+
+/* ------------------------------------------ */
+/* 
+ * reads : g_780 g_196 g_1159 g_1160 g_1163 g_95
+ * writes: g_183 g_196 g_1160 g_865 g_3
+ */
+uint8_t  func_27(int32_t  p_28)
+{ /* block id: 524 */
+    int32_t *l_1154 = &g_865;
+    const uint8_t *l_1197[5];
+    int64_t ***l_1232 = &g_1161;
+    int i;
+    for (i = 0; i < 5; i++)
+        l_1197[i] = &g_1198;
+    (*g_780) = l_1154;
+    for (g_196 = 7; (g_196 <= (-3)); --g_196)
+    { /* block id: 528 */
+        int64_t *****l_1162[9][9] = {{&g_1159,(void*)0,&g_1159,&g_1159,&g_1159,&g_1159,&g_1159,&g_1159,(void*)0},{(void*)0,&g_1159,&g_1159,&g_1159,&g_1159,(void*)0,(void*)0,&g_1159,&g_1159},{(void*)0,&g_1159,&g_1159,&g_1159,&g_1159,&g_1159,(void*)0,(void*)0,&g_1159},{(void*)0,(void*)0,&g_1159,&g_1159,&g_1159,&g_1159,(void*)0,&g_1159,&g_1159},{&g_1159,&g_1159,&g_1159,&g_1159,&g_1159,(void*)0,&g_1159,(void*)0,&g_1159},{&g_1159,&g_1159,(void*)0,&g_1159,&g_1159,&g_1159,&g_1159,&g_1159,&g_1159},{(void*)0,&g_1159,&g_1159,&g_1159,&g_1159,&g_1159,&g_1159,&g_1159,&g_1159},{(void*)0,&g_1159,&g_1159,(void*)0,&g_1159,&g_1159,&g_1159,(void*)0,&g_1159},{(void*)0,&g_1159,&g_1159,&g_1159,&g_1159,&g_1159,&g_1159,&g_1159,&g_1159}};
+        uint16_t *l_1174 = &g_518[2];
+        int32_t l_1175 = (-3L);
+        int8_t *l_1176[7][4] = {{&g_114[1],(void*)0,(void*)0,&g_114[1]},{(void*)0,&g_114[1],(void*)0,(void*)0},{&g_114[1],&g_114[1],&g_114[1],&g_114[1]},{&g_114[1],(void*)0,(void*)0,&g_114[1]},{(void*)0,&g_114[1],(void*)0,(void*)0},{&g_114[1],&g_114[1],&g_114[1],&g_114[1]},{&g_114[1],(void*)0,(void*)0,&g_114[1]}};
+        uint64_t *l_1177 = &g_532;
+        uint16_t *l_1178 = &g_160;
+        int16_t ** const *l_1180 = (void*)0;
+        int16_t ** const **l_1179 = &l_1180;
+        int32_t l_1181 = 0x3BCFBBE9L;
+        int32_t **l_1182[8][10] = {{&g_95,&g_95,&g_95,&g_95,&g_95,&g_95,&l_1154,&g_95,&g_95,&g_95},{&l_1154,(void*)0,&l_1154,&g_95,&l_1154,&l_1154,&g_95,&l_1154,(void*)0,&l_1154},{&l_1154,&g_95,(void*)0,&g_95,(void*)0,&g_95,&l_1154,&l_1154,&g_95,(void*)0},{&g_95,&l_1154,&l_1154,&g_95,(void*)0,&g_95,(void*)0,&g_95,&l_1154,&l_1154},{(void*)0,&l_1154,&g_95,&l_1154,&l_1154,&g_95,&l_1154,(void*)0,&l_1154,&g_95},{&g_95,&g_95,&l_1154,&g_95,&g_95,&g_95,&g_95,&g_95,&g_95,&l_1154},{(void*)0,(void*)0,&l_1154,&g_95,&g_95,&g_95,(void*)0,(void*)0,(void*)0,(void*)0},{&l_1154,&g_95,&l_1154,&l_1154,&g_95,&l_1154,(void*)0,&l_1154,&g_95,&l_1154}};
+        const uint8_t **l_1193 = (void*)0;
+        const uint8_t *l_1195[2][9] = {{&g_1196,&g_1196,&g_1196,&g_1196,&g_1196,&g_1196,&g_1196,&g_1196,&g_1196},{&g_1196,&g_1196,&g_1196,&g_1196,&g_1196,&g_1196,&g_1196,&g_1196,&g_1196}};
+        const uint8_t **l_1194[8][3][4] = {{{&l_1195[0][1],&l_1195[0][4],&l_1195[0][4],&l_1195[0][4]},{&l_1195[0][4],&l_1195[0][4],&l_1195[0][4],&l_1195[0][4]},{(void*)0,&l_1195[0][4],&l_1195[0][4],&l_1195[0][4]}},{{&l_1195[1][3],&l_1195[0][4],&l_1195[0][4],&l_1195[0][6]},{(void*)0,&l_1195[0][0],&l_1195[0][1],&l_1195[0][6]},{&l_1195[0][4],&l_1195[0][4],&l_1195[0][4],&l_1195[0][4]}},{{&l_1195[0][4],&l_1195[0][4],&l_1195[0][4],&l_1195[0][4]},{&l_1195[0][1],&l_1195[0][4],&l_1195[0][1],&l_1195[0][4]},{&l_1195[0][6],&l_1195[0][4],&l_1195[0][4],&l_1195[0][4]}},{{&l_1195[0][4],&l_1195[0][4],&l_1195[0][4],&l_1195[0][0]},{&l_1195[0][6],(void*)0,&l_1195[0][1],&l_1195[0][1]},{&l_1195[0][1],&l_1195[0][1],&l_1195[0][4],&l_1195[0][4]}},{{&l_1195[0][4],&l_1195[0][4],&l_1195[0][4],&l_1195[0][4]},{&l_1195[0][4],&l_1195[1][3],&l_1195[0][1],&l_1195[0][4]},{(void*)0,&l_1195[1][3],&l_1195[0][4],&l_1195[0][4]}},{{&l_1195[1][3],&l_1195[0][4],&l_1195[0][4],&l_1195[0][4]},{(void*)0,&l_1195[0][1],&l_1195[0][4],&l_1195[0][1]},{&l_1195[0][4],(void*)0,&l_1195[0][4],&l_1195[0][0]}},{{&l_1195[0][1],&l_1195[0][4],&l_1195[1][3],&l_1195[0][4]},{&l_1195[0][1],&l_1195[0][4],&l_1195[0][4],&l_1195[0][4]},{&l_1195[0][4],&l_1195[0][4],&l_1195[0][4],&l_1195[0][4]}},{{(void*)0,&l_1195[0][4],&l_1195[0][4],&l_1195[0][4]},{&l_1195[1][3],&l_1195[0][4],&l_1195[0][4],&l_1195[0][6]},{(void*)0,&l_1195[0][0],&l_1195[0][1],&l_1195[0][6]}}};
+        int32_t l_1227 = 0xCCCD00F9L;
+        int i, j, k;
+    }
+    (*g_95) = ((*l_1154) = (((*g_1163) = (*g_1159)) == l_1232));
+    (*g_95) = p_28;
+    return p_28;
+}
+
+
+/* ------------------------------------------ */
+/* 
+ * reads : g_693
+ * writes:
+ */
+int8_t  func_29(uint8_t  p_30)
+{ /* block id: 520 */
+    const int32_t ****l_1151 = &g_429;
+    const int32_t *****l_1152 = &l_1151;
+    (*l_1152) = l_1151;
+    return g_693[9];
+}
+
+
+/* ------------------------------------------ */
+/* 
+ * reads : g_22
+ * writes: g_22
+ */
+int16_t  func_40(int8_t  p_41)
+{ /* block id: 513 */
+    int32_t l_1140 = 0L;
+    int32_t l_1141 = 0L;
+    int32_t l_1142 = 0x54E03374L;
+    int32_t l_1143 = 0x3D1CCDF1L;
+    int32_t l_1144 = 0xF03D1FA4L;
+    int32_t l_1145 = 0xFD6574F5L;
+    int32_t l_1146 = (-2L);
+    int32_t l_1147 = 0xFEB8C496L;
+    uint8_t l_1148 = 0xE6L;
+    for (g_22 = 0; (g_22 == 28); ++g_22)
+    { /* block id: 516 */
+        int32_t *l_1132 = &g_865;
+        int32_t *l_1133 = &g_865;
+        int32_t *l_1134 = &g_865;
+        int32_t *l_1135 = &g_865;
+        int32_t *l_1136 = &g_75;
+        int32_t *l_1137 = &g_865;
+        int32_t *l_1138 = &g_3;
+        int32_t *l_1139[9];
+        int i;
+        for (i = 0; i < 9; i++)
+            l_1139[i] = &g_3;
+        ++l_1148;
+    }
+    return p_41;
+}
+
+
+/* ------------------------------------------ */
+/* 
+ * reads : g_94 g_95 g_216 g_709 g_710 g_711 g_101
+ * writes: g_183
+ */
+int16_t  func_42(uint32_t  p_43)
+{ /* block id: 94 */
+    uint8_t l_221 = 0xD2L;
+    int64_t l_222 = 0L;
+    uint16_t *l_228 = &g_160;
+    int32_t l_243 = 0L;
+    int32_t l_244 = 0x431E9B56L;
+    int32_t l_245[6][5] = {{0x5BDFB80BL,0x61FE9FD4L,0x02D84668L,0x66154BDAL,0x66154BDAL},{0xA315F3A9L,0xA0527C21L,0xA315F3A9L,0x73CF2983L,0x788FA9ADL},{0L,0x19A10924L,0x66154BDAL,0x19A10924L,0L},{0xA315F3A9L,(-4L),0xA0527C21L,1L,0xA0527C21L},{0x5BDFB80BL,0x5BDFB80BL,0x66154BDAL,0L,0x21E71C83L},{(-4L),0xA315F3A9L,0xA315F3A9L,(-4L),0xA0527C21L}};
+    uint8_t l_248 = 0x57L;
+    int8_t *l_263 = &g_114[1];
+    int32_t l_272 = 0x29E4F98AL;
+    int64_t *l_275 = (void*)0;
+    int64_t **l_274 = &l_275;
+    int64_t *l_344 = &g_111;
+    const int16_t *l_434 = &g_22;
+    uint32_t *l_435 = &g_390[2];
+    int32_t *l_457 = &g_3;
+    int8_t l_464 = 0x3EL;
+    int32_t l_466 = 4L;
+    uint32_t l_473 = 18446744073709551615UL;
+    uint32_t l_495 = 4294967290UL;
+    int16_t *l_545 = &g_101;
+    int16_t **l_544[7][10][3] = {{{(void*)0,&l_545,&l_545},{&l_545,&l_545,(void*)0},{&l_545,(void*)0,&l_545},{&l_545,&l_545,(void*)0},{&l_545,(void*)0,&l_545},{(void*)0,(void*)0,(void*)0},{&l_545,&l_545,(void*)0},{&l_545,&l_545,&l_545},{&l_545,&l_545,&l_545},{&l_545,&l_545,&l_545}},{{(void*)0,&l_545,&l_545},{&l_545,(void*)0,&l_545},{&l_545,&l_545,&l_545},{&l_545,(void*)0,&l_545},{&l_545,&l_545,&l_545},{(void*)0,(void*)0,&l_545},{&l_545,&l_545,&l_545},{(void*)0,&l_545,&l_545},{(void*)0,(void*)0,&l_545},{&l_545,&l_545,&l_545}},{{(void*)0,&l_545,&l_545},{&l_545,&l_545,&l_545},{&l_545,&l_545,&l_545},{&l_545,(void*)0,&l_545},{&l_545,&l_545,&l_545},{(void*)0,&l_545,&l_545},{(void*)0,&l_545,&l_545},{(void*)0,&l_545,&l_545},{&l_545,(void*)0,&l_545},{&l_545,&l_545,&l_545}},{{(void*)0,&l_545,&l_545},{&l_545,&l_545,&l_545},{&l_545,&l_545,&l_545},{(void*)0,(void*)0,&l_545},{(void*)0,&l_545,&l_545},{(void*)0,&l_545,&l_545},{&l_545,(void*)0,&l_545},{&l_545,&l_545,&l_545},{&l_545,(void*)0,&l_545},{&l_545,&l_545,&l_545}},{{(void*)0,(void*)0,&l_545},{&l_545,&l_545,&l_545},{(void*)0,&l_545,&l_545},{(void*)0,(void*)0,&l_545},{&l_545,&l_545,&l_545},{(void*)0,&l_545,&l_545},{&l_545,&l_545,&l_545},{&l_545,&l_545,&l_545},{&l_545,(void*)0,&l_545},{&l_545,&l_545,&l_545}},{{(void*)0,&l_545,&l_545},{(void*)0,&l_545,&l_545},{(void*)0,&l_545,&l_545},{&l_545,(void*)0,&l_545},{&l_545,&l_545,&l_545},{(void*)0,&l_545,&l_545},{&l_545,&l_545,&l_545},{&l_545,&l_545,&l_545},{(void*)0,(void*)0,&l_545},{(void*)0,&l_545,&l_545}},{{(void*)0,&l_545,&l_545},{&l_545,(void*)0,&l_545},{&l_545,&l_545,&l_545},{&l_545,(void*)0,&l_545},{&l_545,&l_545,&l_545},{(void*)0,(void*)0,&l_545},{&l_545,&l_545,&l_545},{(void*)0,&l_545,&l_545},{(void*)0,(void*)0,&l_545},{&l_545,&l_545,&l_545}}};
+    int16_t ***l_543[2];
+    int32_t l_676 = 1L;
+    int16_t ***l_707 = &l_544[0][9][1];
+    int16_t l_853 = 0x52C5L;
+    uint32_t l_927 = 0x7BE8C1B0L;
+    const int8_t l_967 = 0xE3L;
+    int16_t l_968 = 0x1343L;
+    int32_t l_980[6] = {0x008AF5F9L,0xC1F376BEL,0xC1F376BEL,0x008AF5F9L,0xC1F376BEL,0xC1F376BEL};
+    uint64_t **l_995[9];
+    int32_t ***l_1103[7];
+    int32_t ****l_1102[3];
+    const int32_t l_1126 = 0x360AA6BCL;
+    int i, j, k;
+    for (i = 0; i < 2; i++)
+        l_543[i] = &l_544[0][9][1];
+    for (i = 0; i < 9; i++)
+        l_995[i] = &g_749;
+    for (i = 0; i < 7; i++)
+        l_1103[i] = &g_72;
+    for (i = 0; i < 3; i++)
+        l_1102[i] = &l_1103[3];
+    (*g_216) = (*g_94);
+    return (***g_709);
+}
+
+
+/* ------------------------------------------ */
+/* 
+ * reads : g_115
+ * writes:
+ */
+uint32_t  func_46(const int16_t * p_47)
+{ /* block id: 5 */
+    int32_t *l_48[4] = {&g_3,&g_3,&g_3,&g_3};
+    int32_t **l_49 = &l_48[0];
+    int32_t *l_51 = &g_3;
+    int32_t **l_50 = &l_51;
+    const int16_t * const l_65 = (void*)0;
+    int32_t ***l_124 = &l_49;
+    uint8_t l_171 = 0UL;
+    int i;
+    (*l_50) = ((*l_49) = l_48[0]);
+    return g_115[5][0][6];
+}
+
+
+/* ------------------------------------------ */
+/* 
+ * reads :
+ * writes:
+ */
+int32_t *** func_54(int32_t * const  p_55, int32_t  p_56, int32_t ** p_57, const int8_t  p_58, const int32_t ** p_59)
+{ /* block id: 35 */
+    int32_t *l_121 = &g_3;
+    (*p_57) = l_121;
+    return &g_72;
+}
+
+
+/* ------------------------------------------ */
+/* 
+ * reads : g_115
+ * writes: g_101 g_22 g_75 g_115
+ */
+int32_t * const  func_60(int32_t  p_61, const int16_t * p_62)
+{ /* block id: 30 */
+    uint32_t l_102[7][2][10] = {{{4UL,0x1AB084DBL,4294967292UL,0xB12BF80AL,1UL,0x828161DDL,1UL,0xB12BF80AL,4294967292UL,0x1AB084DBL},{0x828161DDL,1UL,0xB12BF80AL,4294967292UL,0x1AB084DBL,0x828161DDL,4294967295UL,0x1153E23BL,0UL,0xD421DEF1L}},{{0x828161DDL,4294967295UL,0x1153E23BL,0UL,0xD421DEF1L,0x828161DDL,0x4528E6A8L,0x1B20306CL,0x1B20306CL,0x4528E6A8L},{0x828161DDL,0x4528E6A8L,0x1B20306CL,0x1B20306CL,0x4528E6A8L,0x828161DDL,0xD421DEF1L,0UL,0x1153E23BL,4294967295UL}},{{0x828161DDL,0xD421DEF1L,0UL,0x1153E23BL,4294967295UL,0x828161DDL,0x1AB084DBL,4294967292UL,0xB12BF80AL,1UL},{0x828161DDL,0x1AB084DBL,4294967292UL,0xB12BF80AL,1UL,0x828161DDL,1UL,0xB12BF80AL,4294967292UL,0x1AB084DBL}},{{0x828161DDL,1UL,0xB12BF80AL,4294967292UL,0x1AB084DBL,0x828161DDL,4294967295UL,0x1153E23BL,0UL,0xD421DEF1L},{0x828161DDL,4294967295UL,0x1153E23BL,0UL,0xD421DEF1L,0x828161DDL,0x4528E6A8L,0x1B20306CL,0x1B20306CL,0x4528E6A8L}},{{0x828161DDL,0x4528E6A8L,0x1B20306CL,0x1B20306CL,0x4528E6A8L,0x828161DDL,0xD421DEF1L,0UL,0x1153E23BL,4294967295UL},{0x828161DDL,0xD421DEF1L,0UL,0x1153E23BL,4294967295UL,0x828161DDL,0x1AB084DBL,4294967292UL,0xB12BF80AL,1UL}},{{0x828161DDL,0x1AB084DBL,4294967292UL,0xB12BF80AL,1UL,0x828161DDL,1UL,0xB12BF80AL,4294967292UL,0x1AB084DBL},{0x828161DDL,1UL,0xB12BF80AL,4294967292UL,0x1AB084DBL,0x828161DDL,4294967295UL,0x1153E23BL,0UL,0xD421DEF1L}},{{0x828161DDL,4294967295UL,0x1153E23BL,0UL,0xD421DEF1L,0x828161DDL,0x4528E6A8L,0x1B20306CL,0x1B20306CL,0x4528E6A8L},{0x828161DDL,0x4528E6A8L,0x1B20306CL,0x1B20306CL,0x4528E6A8L,0x828161DDL,0xD421DEF1L,0UL,0x1153E23BL,4294967295UL}}};
+    int32_t l_103 = 3L;
+    int32_t *l_104 = &g_75;
+    int32_t *l_105 = &g_75;
+    int32_t *l_106 = &l_103;
+    int32_t *l_107 = &g_75;
+    int32_t *l_108 = &g_75;
+    int32_t *l_109 = &g_75;
+    int32_t *l_110[2][4][8] = {{{&g_75,&g_3,&g_75,&g_75,(void*)0,(void*)0,&g_75,&g_75},{&g_3,&g_3,(void*)0,&g_75,(void*)0,&g_75,(void*)0,&g_3},{&g_3,&g_75,&g_75,(void*)0,(void*)0,&g_75,&g_75,&g_3},{&g_75,&g_3,&g_3,&g_75,&g_3,&g_3,&g_75,&g_75}},{{&g_3,&g_75,&g_75,&g_75,&g_75,&g_3,(void*)0,&g_3},{&g_75,&g_3,(void*)0,&g_3,&g_75,&g_75,&g_75,&g_75},{&g_3,&g_75,&g_75,&g_3,(void*)0,&g_75,(void*)0,&g_75},{&g_75,(void*)0,&g_75,(void*)0,&g_3,&g_3,(void*)0,&g_75}}};
+    int i, j, k;
+    for (g_101 = 0; g_101 < 7; g_101 += 1)
+    {
+        for (g_22 = 0; g_22 < 2; g_22 += 1)
+        {
+            for (g_75 = 0; g_75 < 10; g_75 += 1)
+            {
+                l_102[g_101][g_22][g_75] = 0xE7BB48DFL;
+            }
+        }
+    }
+    l_103 = p_61;
+    ++g_115[5][0][6];
+    return &g_3;
+}
+
+
+/* ------------------------------------------ */
+/* 
+ * reads : g_22 g_79 g_3 g_75 g_94
+ * writes: g_22 g_75 g_79 g_95
+ */
+int32_t  func_66(int32_t ** p_67, uint16_t  p_68, int32_t * p_69, int32_t *** p_70, int16_t  p_71)
+{ /* block id: 11 */
+    int8_t l_73[1];
+    int32_t l_96 = (-1L);
+    int i;
+    for (i = 0; i < 1; i++)
+        l_73[i] = 0xD8L;
+    for (g_22 = 0; (g_22 <= 0); g_22 += 1)
+    { /* block id: 14 */
+        int32_t *l_74 = &g_75;
+        uint64_t l_76 = 0xE6E92ECD44262C44LL;
+        int32_t l_92 = (-8L);
+        int32_t *l_93 = &l_92;
+        int i;
+        ++l_76;
+        for (g_75 = 0; (g_75 >= 0); g_75 -= 1)
+        { /* block id: 18 */
+            int16_t *l_86 = &g_22;
+            int16_t **l_85 = &l_86;
+            int32_t l_91 = 0x32083B01L;
+            int i;
+            g_79 ^= 0x2C4EE0C6L;
+            l_92 = ((safe_div_func_int64_t_s_s((0xC7D0B67CL > ((safe_sub_func_int64_t_s_s((~(&g_22 == ((*l_85) = &g_22))), (l_73[g_22] >= ((((safe_lshift_func_int16_t_s_s((g_79 < ((((p_71 , (-1L)) || (safe_add_func_uint16_t_u_u(0xBF4BL, (l_91 &= 6UL)))) , (-1L)) | (-1L))), 9)) , l_73[g_22]) , p_68) & g_3)))) == 0UL)), (-1L))) < (*l_74));
+        }
+        (*l_93) ^= ((*l_74) |= l_73[g_22]);
+        (*g_94) = &l_92;
+    }
+    return l_96;
+}
+
+
+
+
+/* ---------------------------------------- */
+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_3, "g_3", print_hash_value);
+    transparent_crc(g_11, "g_11", print_hash_value);
+    transparent_crc(g_13, "g_13", print_hash_value);
+    transparent_crc(g_22, "g_22", print_hash_value);
+    transparent_crc(g_75, "g_75", print_hash_value);
+    transparent_crc(g_79, "g_79", print_hash_value);
+    transparent_crc(g_101, "g_101", print_hash_value);
+    transparent_crc(g_111, "g_111", print_hash_value);
+    transparent_crc(g_112, "g_112", print_hash_value);
+    transparent_crc(g_113, "g_113", print_hash_value);
+    for (i = 0; i < 7; i++)
+    {
+        transparent_crc(g_114[i], "g_114[i]", print_hash_value);
+        if (print_hash_value) printf("index = [%d]\n", i);
+
+    }
+    for (i = 0; i < 10; i++)
+    {
+        for (j = 0; j < 1; j++)
+        {
+            for (k = 0; k < 10; k++)
+            {
+                transparent_crc(g_115[i][j][k], "g_115[i][j][k]", print_hash_value);
+                if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k);
+
+            }
+        }
+    }
+    transparent_crc(g_152, "g_152", print_hash_value);
+    transparent_crc(g_156, "g_156", print_hash_value);
+    transparent_crc(g_160, "g_160", print_hash_value);
+    transparent_crc(g_165, "g_165", print_hash_value);
+    transparent_crc(g_170, "g_170", print_hash_value);
+    for (i = 0; i < 1; i++)
+    {
+        transparent_crc(g_174[i], "g_174[i]", print_hash_value);
+        if (print_hash_value) printf("index = [%d]\n", i);
+
+    }
+    transparent_crc(g_190, "g_190", print_hash_value);
+    transparent_crc(g_196, "g_196", print_hash_value);
+    transparent_crc(g_197, "g_197", print_hash_value);
+    transparent_crc(g_312, "g_312", print_hash_value);
+    transparent_crc(g_313, "g_313", print_hash_value);
+    transparent_crc(g_337, "g_337", print_hash_value);
+    transparent_crc(g_349, "g_349", print_hash_value);
+    for (i = 0; i < 8; i++)
+    {
+        transparent_crc(g_390[i], "g_390[i]", print_hash_value);
+        if (print_hash_value) printf("index = [%d]\n", i);
+
+    }
+    transparent_crc(g_469, "g_469", print_hash_value);
+    for (i = 0; i < 4; i++)
+    {
+        transparent_crc(g_518[i], "g_518[i]", print_hash_value);
+        if (print_hash_value) printf("index = [%d]\n", i);
+
+    }
+    transparent_crc(g_527, "g_527", print_hash_value);
+    transparent_crc(g_532, "g_532", print_hash_value);
+    for (i = 0; i < 10; i++)
+    {
+        transparent_crc(g_693[i], "g_693[i]", print_hash_value);
+        if (print_hash_value) printf("index = [%d]\n", i);
+
+    }
+    transparent_crc(g_730, "g_730", print_hash_value);
+    transparent_crc(g_840, "g_840", print_hash_value);
+    transparent_crc(g_847, "g_847", print_hash_value);
+    transparent_crc(g_865, "g_865", print_hash_value);
+    transparent_crc(g_874, "g_874", print_hash_value);
+    transparent_crc(g_1196, "g_1196", print_hash_value);
+    transparent_crc(g_1198, "g_1198", print_hash_value);
+    platform_main_end(crc32_context ^ 0xFFFFFFFFUL, print_hash_value);
+    return 0;
+}
+
+/************************ statistics *************************
+XXX max struct depth: 0
+breakdown:
+   depth: 0, occurrence: 264
+XXX total union variables: 0
+
+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: 35
+breakdown:
+   depth: 1, occurrence: 46
+   depth: 2, occurrence: 6
+   depth: 3, occurrence: 1
+   depth: 4, occurrence: 1
+   depth: 5, occurrence: 1
+   depth: 20, occurrence: 1
+   depth: 35, occurrence: 1
+
+XXX total number of pointers: 293
+
+XXX times a variable address is taken: 776
+XXX times a pointer is dereferenced on RHS: 186
+breakdown:
+   depth: 1, occurrence: 147
+   depth: 2, occurrence: 36
+   depth: 3, occurrence: 3
+XXX times a pointer is dereferenced on LHS: 188
+breakdown:
+   depth: 1, occurrence: 182
+   depth: 2, occurrence: 5
+   depth: 3, occurrence: 1
+XXX times a pointer is compared with null: 24
+XXX times a pointer is compared with address of another variable: 4
+XXX times a pointer is compared with another pointer: 7
+XXX times a pointer is qualified to be dereferenced: 3636
+
+XXX max dereference level: 5
+breakdown:
+   level: 0, occurrence: 0
+   level: 1, occurrence: 896
+   level: 2, occurrence: 161
+   level: 3, occurrence: 56
+   level: 4, occurrence: 7
+   level: 5, occurrence: 2
+XXX number of pointers point to pointers: 121
+XXX number of pointers point to scalars: 172
+XXX number of pointers point to structs: 0
+XXX percent of pointers has null in alias set: 27.6
+XXX average alias set size: 1.38
+
+XXX times a non-volatile is read: 999
+XXX times a non-volatile is write: 502
+XXX times a volatile is read: 82
+XXX    times read thru a pointer: 39
+XXX times a volatile is write: 22
+XXX    times written thru a pointer: 0
+XXX times a volatile is available for access: 726
+XXX percentage of non-volatile access: 93.5
+
+XXX forward jumps: 0
+XXX backward jumps: 7
+
+XXX stmts: 36
+XXX max block depth: 2
+breakdown:
+   depth: 0, occurrence: 29
+   depth: 1, occurrence: 5
+   depth: 2, occurrence: 2
+
+XXX percentage a fresh-made variable is used: 15.5
+XXX percentage an existing variable is used: 84.5
+********************* end of statistics **********************/
+