astUtil.ml

(*
  Machine generated. Edit at your own risk 
  Reproduce with the following
 --line_width=74
 --no_action=false
 --output_directory=.
 --pickler=sexp
 --view=OCaml
 *)
(* module AstUtil*)
  
  let rec sexp_rd_name s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_name" s_);
        let tmp_ = let string1 = (StdPrimsUtil.sexp_rd_std_string s_) in
          (string1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_conv s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_conv" s_);
        let tmp_ = let string1 = (StdPrimsUtil.sexp_rd_std_string s_) in
          (string1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_hint s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_hint" s_);
        let tmp_ = let string1 = (StdPrimsUtil.sexp_rd_std_string s_) in
          (string1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_reg s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_reg" s_);
        let tmp_ = let string1 = (StdPrimsUtil.sexp_rd_std_string s_) in
          (string1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_target s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_target" s_);
        let tmp_ = let string1 = (StdPrimsUtil.sexp_rd_std_string s_) in
          (string1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_alias_set s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_alias_set" s_);
        let tmp_ = let string1 = (StdPrimsUtil.sexp_rd_std_string s_) in
          (string1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_size s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_size" s_);
        let tmp_ = let int1 = (StdPrimsUtil.sexp_rd_std_int s_) in
          (int1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_align s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_align" s_);
        let tmp_ = let int1 = (StdPrimsUtil.sexp_rd_std_int s_) in
          (int1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_aligned s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_aligned" s_);
        let tmp_ = let int1 = (StdPrimsUtil.sexp_rd_std_int s_) in
          (int1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_in_alias s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_in_alias" s_);
        let tmp_ = let string1 = (StdPrimsUtil.sexp_rd_std_string s_) in
          (string1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_op s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_op" s_);
        let tmp_ = let string1 = (StdPrimsUtil.sexp_rd_std_string s_) in
          (string1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_region s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_region" s_);
        let tmp_ = let int1 = (StdPrimsUtil.sexp_rd_std_int s_) in
          let int2 = (StdPrimsUtil.sexp_rd_std_int s_) in
          (int1, int2) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_ty s_ = 
      begin
        (SexpPkl.rd_lp s_);
        let tmp_ = let t = (SexpPkl.get_sym s_) in
          (match (t) with 
              "ast_TyAt" -> let ty1 = (sexp_rd_ty s_) in
              let region1 = (sexp_rd_region s_) in
              Ast.TyAt(ty1, region1)
            | "ast_BitsTy" -> let size1 = (sexp_rd_size s_) in
              Ast.BitsTy(size1)
            | "ast_TypeSynonym" -> let name1 = (sexp_rd_name s_) in
              Ast.TypeSynonym(name1)
            | _ -> (SexpPkl.die ()))
          (* end match *) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_name_or_mem s_ = 
      begin
        (SexpPkl.rd_lp s_);
        let tmp_ = let t = (SexpPkl.get_sym s_) in
          (match (t) with 
              "ast_NameOrMemAt" -> let name_or_mem1 = (sexp_rd_name_or_mem s_) in
              let region1 = (sexp_rd_region s_) in
              Ast.NameOrMemAt(name_or_mem1, region1)
            | "ast_Name" -> let hint_opt1 = (SexpPkl.rd_option sexp_rd_hint s_) in
              let name1 = (sexp_rd_name s_) in
              let aligned_opt1 = (SexpPkl.rd_option sexp_rd_aligned s_) in
              Ast.Name(hint_opt1, name1, aligned_opt1)
            | "ast_Mem" -> let ty1 = (sexp_rd_ty s_) in
              let expr1 = (sexp_rd_expr s_) in
              let aligned_opt1 = (SexpPkl.rd_option sexp_rd_aligned s_) in
              let in_alias_list1 = (SexpPkl.rd_list sexp_rd_in_alias s_) in
              Ast.Mem(ty1, expr1, aligned_opt1, in_alias_list1)
            | _ -> (SexpPkl.die ()))
          (* end match *) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_actual s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_actual" s_);
        let tmp_ = let hint_opt1 = (SexpPkl.rd_option sexp_rd_hint s_) in
          let expr1 = (sexp_rd_expr s_) in
          let aligned_opt1 = (SexpPkl.rd_option sexp_rd_aligned s_) in
          (hint_opt1, expr1, aligned_opt1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_expr s_ = 
      begin
        (SexpPkl.rd_lp s_);
        let tmp_ = let t = (SexpPkl.get_sym s_) in
          (match (t) with 
              "ast_ExprAt" -> let expr1 = (sexp_rd_expr s_) in
              let region1 = (sexp_rd_region s_) in
              Ast.ExprAt(expr1, region1)
            | "ast_Sint" -> let string1 = (StdPrimsUtil.sexp_rd_std_string s_) in
              let ty_opt1 = (SexpPkl.rd_option sexp_rd_ty s_) in
              Ast.Sint(string1, ty_opt1)
            | "ast_Uint" -> let string1 = (StdPrimsUtil.sexp_rd_std_string s_) in
              let ty_opt1 = (SexpPkl.rd_option sexp_rd_ty s_) in
              Ast.Uint(string1, ty_opt1)
            | "ast_Float" -> let string1 = (StdPrimsUtil.sexp_rd_std_string s_) in
              let ty_opt1 = (SexpPkl.rd_option sexp_rd_ty s_) in
              Ast.Float(string1, ty_opt1)
            | "ast_Char" -> let int1 = (StdPrimsUtil.sexp_rd_std_int s_) in
              let ty_opt1 = (SexpPkl.rd_option sexp_rd_ty s_) in
              Ast.Char(int1, ty_opt1)
            | "ast_Fetch" -> let name_or_mem1 = (sexp_rd_name_or_mem s_) in
              Ast.Fetch(name_or_mem1)
            | "ast_BinOp" -> let expr1 = (sexp_rd_expr s_) in
              let op1 = (sexp_rd_op s_) in
              let expr2 = (sexp_rd_expr s_) in
              Ast.BinOp(expr1, op1, expr2)
            | "ast_UnOp" -> let op1 = (sexp_rd_op s_) in
              let expr1 = (sexp_rd_expr s_) in
              Ast.UnOp(op1, expr1)
            | "ast_PrimOp" -> let name1 = (sexp_rd_name s_) in
              let actual_list1 = (SexpPkl.rd_list sexp_rd_actual s_) in
              Ast.PrimOp(name1, actual_list1)
            | _ -> (SexpPkl.die ()))
          (* end match *) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_import s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_import" s_);
        let tmp_ = let string_opt1 = (SexpPkl.rd_option
                StdPrimsUtil.sexp_rd_std_string
                s_) in
          let name1 = (sexp_rd_name s_) in
          (string_opt1, name1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_export s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_export" s_);
        let tmp_ = let name1 = (sexp_rd_name s_) in
          let string_opt1 = (SexpPkl.rd_option StdPrimsUtil.sexp_rd_std_string s_) in
          (name1, string_opt1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_variance s_ = 
      begin
        (SexpPkl.rd_lp s_);
        let tmp_ = let t = (SexpPkl.get_sym s_) in
          (match (t) with 
              "ast_Invariant" -> Ast.Invariant
            | "ast_Invisible" -> Ast.Invisible
            | "ast_Variant" -> Ast.Variant
            | _ -> (SexpPkl.die ()))
          (* end match *) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_register s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_register" s_);
        let tmp_ = let variance1 = (sexp_rd_variance s_) in
          let hint_opt1 = (SexpPkl.rd_option sexp_rd_hint s_) in
          let ty1 = (sexp_rd_ty s_) in
          let name1 = (sexp_rd_name s_) in
          let reg_opt1 = (SexpPkl.rd_option sexp_rd_reg s_) in
          (variance1, hint_opt1, ty1, name1, reg_opt1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_arch s_ = 
      begin
        (SexpPkl.rd_lp s_);
        let tmp_ = let t = (SexpPkl.get_sym s_) in
          (match (t) with 
              "ast_Memsize" -> let int1 = (StdPrimsUtil.sexp_rd_std_int s_) in
              Ast.Memsize(int1)
            | "ast_ByteorderBig" -> Ast.ByteorderBig
            | "ast_ByteorderLittle" -> Ast.ByteorderLittle
            | "ast_FloatRepr" -> let string1 = (StdPrimsUtil.sexp_rd_std_string s_) in
              Ast.FloatRepr(string1)
            | "ast_Charset" -> let string1 = (StdPrimsUtil.sexp_rd_std_string s_) in
              Ast.Charset(string1)
            | "ast_WordSize" -> let int1 = (StdPrimsUtil.sexp_rd_std_int s_) in
              Ast.WordSize(int1)
            | "ast_PointerSize" -> let int1 = (StdPrimsUtil.sexp_rd_std_int s_) in
              Ast.PointerSize(int1)
            | _ -> (SexpPkl.die ()))
          (* end match *) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_decl s_ = 
      begin
        (SexpPkl.rd_lp s_);
        let tmp_ = let t = (SexpPkl.get_sym s_) in
          (match (t) with 
              "ast_DeclAt" -> let decl1 = (sexp_rd_decl s_) in
              let region1 = (sexp_rd_region s_) in
              Ast.DeclAt(decl1, region1)
            | "ast_Import" -> let ty_opt1 = (SexpPkl.rd_option sexp_rd_ty s_) in
              let import_list1 = (SexpPkl.rd_list sexp_rd_import s_) in
              Ast.Import(ty_opt1, import_list1)
            | "ast_Export" -> let ty_opt1 = (SexpPkl.rd_option sexp_rd_ty s_) in
              let export_list1 = (SexpPkl.rd_list sexp_rd_export s_) in
              Ast.Export(ty_opt1, export_list1)
            | "ast_Const" -> let ty_opt1 = (SexpPkl.rd_option sexp_rd_ty s_) in
              let name1 = (sexp_rd_name s_) in
              let expr1 = (sexp_rd_expr s_) in
              Ast.Const(ty_opt1, name1, expr1)
            | "ast_Typedef" -> let ty1 = (sexp_rd_ty s_) in
              let name_list1 = (SexpPkl.rd_list sexp_rd_name s_) in
              Ast.Typedef(ty1, name_list1)
            | "ast_Registers" -> let register_list1 = (SexpPkl.rd_list sexp_rd_register s_) in
              Ast.Registers(register_list1)
            | "ast_Pragma" -> Ast.Pragma
            | "ast_Target" -> let arch_list1 = (SexpPkl.rd_list sexp_rd_arch s_) in
              Ast.Target(arch_list1)
            | _ -> (SexpPkl.die ()))
          (* end match *) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_bare_formal s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_bare_formal" s_);
        let tmp_ = let hint_opt1 = (SexpPkl.rd_option sexp_rd_hint s_) in
          let variance1 = (sexp_rd_variance s_) in
          let ty1 = (sexp_rd_ty s_) in
          let name1 = (sexp_rd_name s_) in
          let aligned_opt1 = (SexpPkl.rd_option sexp_rd_aligned s_) in
          (hint_opt1, variance1, ty1, name1, aligned_opt1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_formal s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_formal" s_);
        let tmp_ = let region1 = (sexp_rd_region s_) in
          let bare_formal1 = (sexp_rd_bare_formal s_) in
          (region1, bare_formal1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_memsize s_ = 
      begin
        (SexpPkl.rd_lp s_);
        let tmp_ = let t = (SexpPkl.get_sym s_) in
          (match (t) with 
              "ast_NoSize" -> Ast.NoSize
            | "ast_DynSize" -> Ast.DynSize
            | "ast_FixSize" -> let expr1 = (sexp_rd_expr s_) in
              Ast.FixSize(expr1)
            | _ -> (SexpPkl.die ()))
          (* end match *) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_init s_ = 
      begin
        (SexpPkl.rd_lp s_);
        let tmp_ = let t = (SexpPkl.get_sym s_) in
          (match (t) with 
              "ast_InitAt" -> let init1 = (sexp_rd_init s_) in
              let region1 = (sexp_rd_region s_) in
              Ast.InitAt(init1, region1)
            | "ast_InitExprs" -> let expr_list1 = (SexpPkl.rd_list sexp_rd_expr s_) in
              Ast.InitExprs(expr_list1)
            | "ast_InitStr" -> let string1 = (StdPrimsUtil.sexp_rd_std_string s_) in
              Ast.InitStr(string1)
            | "ast_InitUStr" -> let string1 = (StdPrimsUtil.sexp_rd_std_string s_) in
              Ast.InitUStr(string1)
            | _ -> (SexpPkl.die ()))
          (* end match *) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_datum s_ = 
      begin
        (SexpPkl.rd_lp s_);
        let tmp_ = let t = (SexpPkl.get_sym s_) in
          (match (t) with 
              "ast_DatumAt" -> let datum1 = (sexp_rd_datum s_) in
              let region1 = (sexp_rd_region s_) in
              Ast.DatumAt(datum1, region1)
            | "ast_Label" -> let name1 = (sexp_rd_name s_) in
              Ast.Label(name1)
            | "ast_Align" -> let align1 = (sexp_rd_align s_) in
              Ast.Align(align1)
            | "ast_MemDecl" -> let ty1 = (sexp_rd_ty s_) in
              let memsize1 = (sexp_rd_memsize s_) in
              let init_opt1 = (SexpPkl.rd_option sexp_rd_init s_) in
              Ast.MemDecl(ty1, memsize1, init_opt1)
            | _ -> (SexpPkl.die ()))
          (* end match *) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_cformal s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_cformal" s_);
        let tmp_ = let region1 = (sexp_rd_region s_) in
          let hint_opt1 = (SexpPkl.rd_option sexp_rd_hint s_) in
          let name1 = (sexp_rd_name s_) in
          let aligned_opt1 = (SexpPkl.rd_option sexp_rd_aligned s_) in
          (region1, hint_opt1, name1, aligned_opt1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_flow s_ = 
      begin
        (SexpPkl.rd_lp s_);
        let tmp_ = let t = (SexpPkl.get_sym s_) in
          (match (t) with 
              "ast_FlowAt" -> let flow1 = (sexp_rd_flow s_) in
              let region1 = (sexp_rd_region s_) in
              Ast.FlowAt(flow1, region1)
            | "ast_CutsTo" -> let name_list1 = (SexpPkl.rd_list sexp_rd_name s_) in
              Ast.CutsTo(name_list1)
            | "ast_UnwindsTo" -> let name_list1 = (SexpPkl.rd_list sexp_rd_name s_) in
              Ast.UnwindsTo(name_list1)
            | "ast_ReturnsTo" -> let name_list1 = (SexpPkl.rd_list sexp_rd_name s_) in
              Ast.ReturnsTo(name_list1)
            | "ast_NeverReturns" -> Ast.NeverReturns
            | "ast_Aborts" -> Ast.Aborts
            | _ -> (SexpPkl.die ()))
          (* end match *) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_mem s_ = 
      begin
        (SexpPkl.rd_lp s_);
        let tmp_ = let t = (SexpPkl.get_sym s_) in
          (match (t) with 
              "ast_AliasAt" -> let mem1 = (sexp_rd_mem s_) in
              let region1 = (sexp_rd_region s_) in
              Ast.AliasAt(mem1, region1)
            | "ast_Reads" -> let name_list1 = (SexpPkl.rd_list sexp_rd_name s_) in
              Ast.Reads(name_list1)
            | "ast_Writes" -> let name_list1 = (SexpPkl.rd_list sexp_rd_name s_) in
              Ast.Writes(name_list1)
            | _ -> (SexpPkl.die ()))
          (* end match *) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_procann s_ = 
      begin
        (SexpPkl.rd_lp s_);
        let tmp_ = let t = (SexpPkl.get_sym s_) in
          (match (t) with 
              "ast_Flow" -> let flow1 = (sexp_rd_flow s_) in
              Ast.Flow(flow1)
            | "ast_Alias" -> let mem1 = (sexp_rd_mem s_) in
              Ast.Alias(mem1)
            | _ -> (SexpPkl.die ()))
          (* end match *) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_altcont s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_altcont" s_);
        let tmp_ = let expr1 = (sexp_rd_expr s_) in
          let expr2 = (sexp_rd_expr s_) in
          (expr1, expr2) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_range s_ = 
      begin
        (SexpPkl.rd_lp s_);
        let tmp_ = let t = (SexpPkl.get_sym s_) in
          (match (t) with 
              "ast_Point" -> let expr1 = (sexp_rd_expr s_) in
              Ast.Point(expr1)
            | "ast_Range" -> let expr1 = (sexp_rd_expr s_) in
              let expr2 = (sexp_rd_expr s_) in
              Ast.Range(expr1, expr2)
            | _ -> (SexpPkl.die ()))
          (* end match *) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_guarded s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_guarded" s_);
        let tmp_ = let guard = (SexpPkl.rd_option sexp_rd_expr s_) in
          let value = (sexp_rd_expr s_) in
          (guard, value) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_arm s_ = 
      begin
        (SexpPkl.rd_lp s_);
        let tmp_ = let t = (SexpPkl.get_sym s_) in
          (match (t) with 
              "ast_ArmAt" -> let arm1 = (sexp_rd_arm s_) in
              let region1 = (sexp_rd_region s_) in
              Ast.ArmAt(arm1, region1)
            | "ast_Case" -> let range_list1 = (SexpPkl.rd_list sexp_rd_range s_) in
              let body_list1 = (SexpPkl.rd_list sexp_rd_body s_) in
              Ast.Case(range_list1, body_list1)
            | _ -> (SexpPkl.die ()))
          (* end match *) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_stmt s_ = 
      begin
        (SexpPkl.rd_lp s_);
        let tmp_ = let t = (SexpPkl.get_sym s_) in
          (match (t) with 
              "ast_StmtAt" -> let stmt1 = (sexp_rd_stmt s_) in
              let region1 = (sexp_rd_region s_) in
              Ast.StmtAt(stmt1, region1)
            | "ast_IfStmt" -> let expr1 = (sexp_rd_expr s_) in
              let body_list1 = (SexpPkl.rd_list sexp_rd_body s_) in
              let body_list2 = (SexpPkl.rd_list sexp_rd_body s_) in
              Ast.IfStmt(expr1, body_list1, body_list2)
            | "ast_SwitchStmt" -> let range_opt1 = (SexpPkl.rd_option sexp_rd_range s_) in
              let expr1 = (sexp_rd_expr s_) in
              let arm_list1 = (SexpPkl.rd_list sexp_rd_arm s_) in
              Ast.SwitchStmt(range_opt1, expr1, arm_list1)
            | "ast_LabelStmt" -> let name1 = (sexp_rd_name s_) in
              Ast.LabelStmt(name1)
            | "ast_ContStmt" -> let name1 = (sexp_rd_name s_) in
              let cformal_list1 = (SexpPkl.rd_list sexp_rd_cformal s_) in
              Ast.ContStmt(name1, cformal_list1)
            | "ast_SpanStmt" -> let key = (sexp_rd_expr s_) in
              let value = (sexp_rd_expr s_) in
              let body_list1 = (SexpPkl.rd_list sexp_rd_body s_) in
              Ast.SpanStmt(key, value, body_list1)
            | "ast_AssignStmt" -> let name_or_mem_list1 = (SexpPkl.rd_list sexp_rd_name_or_mem s_) in
              let guarded_list1 = (SexpPkl.rd_list sexp_rd_guarded s_) in
              Ast.AssignStmt(name_or_mem_list1, guarded_list1)
            | "ast_CallStmt" -> let name_or_mem_list1 = (SexpPkl.rd_list sexp_rd_name_or_mem s_) in
              let conv_opt1 = (SexpPkl.rd_option sexp_rd_conv s_) in
              let expr1 = (sexp_rd_expr s_) in
              let actual_list1 = (SexpPkl.rd_list sexp_rd_actual s_) in
              let target_list1 = (SexpPkl.rd_list sexp_rd_target s_) in
              let procann_list1 = (SexpPkl.rd_list sexp_rd_procann s_) in
              Ast.CallStmt(name_or_mem_list1, conv_opt1, expr1, actual_list1, target_list1, procann_list1)
            | "ast_PrimStmt" -> let name_or_mem_list1 = (SexpPkl.rd_list sexp_rd_name_or_mem s_) in
              let conv_opt1 = (SexpPkl.rd_option sexp_rd_conv s_) in
              let name1 = (sexp_rd_name s_) in
              let actual_list1 = (SexpPkl.rd_list sexp_rd_actual s_) in
              let flow_list1 = (SexpPkl.rd_list sexp_rd_flow s_) in
              Ast.PrimStmt(name_or_mem_list1, conv_opt1, name1, actual_list1, flow_list1)
            | "ast_GotoStmt" -> let expr1 = (sexp_rd_expr s_) in
              let target_list1 = (SexpPkl.rd_list sexp_rd_target s_) in
              Ast.GotoStmt(expr1, target_list1)
            | "ast_JumpStmt" -> let conv_opt1 = (SexpPkl.rd_option sexp_rd_conv s_) in
              let expr1 = (sexp_rd_expr s_) in
              let actual_list1 = (SexpPkl.rd_list sexp_rd_actual s_) in
              let target_list1 = (SexpPkl.rd_list sexp_rd_target s_) in
              Ast.JumpStmt(conv_opt1, expr1, actual_list1, target_list1)
            | "ast_CutStmt" -> let expr1 = (sexp_rd_expr s_) in
              let actual_list1 = (SexpPkl.rd_list sexp_rd_actual s_) in
              let flow_list1 = (SexpPkl.rd_list sexp_rd_flow s_) in
              Ast.CutStmt(expr1, actual_list1, flow_list1)
            | "ast_ReturnStmt" -> let conv_opt1 = (SexpPkl.rd_option sexp_rd_conv s_) in
              let altcont_opt1 = (SexpPkl.rd_option sexp_rd_altcont s_) in
              let actual_list1 = (SexpPkl.rd_list sexp_rd_actual s_) in
              Ast.ReturnStmt(conv_opt1, altcont_opt1, actual_list1)
            | "ast_EmptyStmt" -> Ast.EmptyStmt
            | "ast_CommentStmt" -> let string1 = (StdPrimsUtil.sexp_rd_std_string s_) in
              Ast.CommentStmt(string1)
            | "ast_LimitcheckStmt" -> let expr1 = (sexp_rd_expr s_) in
              let expr_opt1 = (SexpPkl.rd_option sexp_rd_expr s_) in
              Ast.LimitcheckStmt(expr1, expr_opt1)
            | _ -> (SexpPkl.die ()))
          (* end match *) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_body s_ = 
      begin
        (SexpPkl.rd_lp s_);
        let tmp_ = let t = (SexpPkl.get_sym s_) in
          (match (t) with 
              "ast_BodyAt" -> let body1 = (sexp_rd_body s_) in
              let region1 = (sexp_rd_region s_) in
              Ast.BodyAt(body1, region1)
            | "ast_DeclBody" -> let decl1 = (sexp_rd_decl s_) in
              Ast.DeclBody(decl1)
            | "ast_StmtBody" -> let stmt1 = (sexp_rd_stmt s_) in
              Ast.StmtBody(stmt1)
            | "ast_DataBody" -> let datum_list1 = (SexpPkl.rd_list sexp_rd_datum s_) in
              Ast.DataBody(datum_list1)
            | _ -> (SexpPkl.die ()))
          (* end match *) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_proc s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_proc" s_);
        let tmp_ = let conv_opt1 = (SexpPkl.rd_option sexp_rd_conv s_) in
          let name1 = (sexp_rd_name s_) in
          let formal_list1 = (SexpPkl.rd_list sexp_rd_formal s_) in
          let body_list1 = (SexpPkl.rd_list sexp_rd_body s_) in
          let region1 = (sexp_rd_region s_) in
          (conv_opt1, name1, formal_list1, body_list1, region1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_section s_ = 
      begin
        (SexpPkl.rd_lp s_);
        let tmp_ = let t = (SexpPkl.get_sym s_) in
          (match (t) with 
              "ast_SectionAt" -> let section1 = (sexp_rd_section s_) in
              let region1 = (sexp_rd_region s_) in
              Ast.SectionAt(section1, region1)
            | "ast_Decl" -> let decl1 = (sexp_rd_decl s_) in
              Ast.Decl(decl1)
            | "ast_Procedure" -> let proc1 = (sexp_rd_proc s_) in
              Ast.Procedure(proc1)
            | "ast_Datum" -> let datum1 = (sexp_rd_datum s_) in
              Ast.Datum(datum1)
            | "ast_SSpan" -> let key = (sexp_rd_expr s_) in
              let value = (sexp_rd_expr s_) in
              let section_list1 = (SexpPkl.rd_list sexp_rd_section s_) in
              Ast.SSpan(key, value, section_list1)
            | _ -> (SexpPkl.die ()))
          (* end match *) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_toplevel s_ = 
      begin
        (SexpPkl.rd_lp s_);
        let tmp_ = let t = (SexpPkl.get_sym s_) in
          (match (t) with 
              "ast_ToplevelAt" -> let toplevel1 = (sexp_rd_toplevel s_) in
              let region1 = (sexp_rd_region s_) in
              Ast.ToplevelAt(toplevel1, region1)
            | "ast_Section" -> let name1 = (sexp_rd_name s_) in
              let section_list1 = (SexpPkl.rd_list sexp_rd_section s_) in
              Ast.Section(name1, section_list1)
            | "ast_TopDecl" -> let decl1 = (sexp_rd_decl s_) in
              Ast.TopDecl(decl1)
            | "ast_TopProcedure" -> let proc1 = (sexp_rd_proc s_) in
              Ast.TopProcedure(proc1)
            | _ -> (SexpPkl.die ()))
          (* end match *) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_program s_ = 
      begin
        (SexpPkl.rd_lp s_);
        (SexpPkl.rd_sym "ast_program" s_);
        let tmp_ = let toplevel_list1 = (SexpPkl.rd_list
                sexp_rd_toplevel
                s_) in
          (toplevel_list1) in
        begin
          (SexpPkl.rd_rp s_);
          tmp_
        end
      end
  
  and sexp_rd_guarded_list s_ = 
      (SexpPkl.rd_list sexp_rd_guarded s_)
  
  and sexp_rd_arm_list s_ = 
      (SexpPkl.rd_list sexp_rd_arm s_)
  
  and sexp_rd_range_list s_ = 
      (SexpPkl.rd_list sexp_rd_range s_)
  
  and sexp_rd_range_option s_ = 
      (SexpPkl.rd_option sexp_rd_range s_)
  
  and sexp_rd_altcont_option s_ = 
      (SexpPkl.rd_option sexp_rd_altcont s_)
  
  and sexp_rd_name_or_mem_list s_ = 
      (SexpPkl.rd_list sexp_rd_name_or_mem s_)
  
  and sexp_rd_procann_list s_ = 
      (SexpPkl.rd_list sexp_rd_procann s_)
  
  and sexp_rd_flow_list s_ = 
      (SexpPkl.rd_list sexp_rd_flow s_)
  
  and sexp_rd_cformal_list s_ = 
      (SexpPkl.rd_list sexp_rd_cformal s_)
  
  and sexp_rd_actual_list s_ = 
      (SexpPkl.rd_list sexp_rd_actual s_)
  
  and sexp_rd_init_option s_ = 
      (SexpPkl.rd_option sexp_rd_init s_)
  
  and sexp_rd_body_list s_ = 
      (SexpPkl.rd_list sexp_rd_body s_)
  
  and sexp_rd_formal_list s_ = 
      (SexpPkl.rd_list sexp_rd_formal s_)
  
  and sexp_rd_arch_list s_ = 
      (SexpPkl.rd_list sexp_rd_arch s_)
  
  and sexp_rd_register_list s_ = 
      (SexpPkl.rd_list sexp_rd_register s_)
  
  and sexp_rd_export_list s_ = 
      (SexpPkl.rd_list sexp_rd_export s_)
  
  and sexp_rd_import_list s_ = 
      (SexpPkl.rd_list sexp_rd_import s_)
  
  and sexp_rd_ty_option s_ = 
      (SexpPkl.rd_option sexp_rd_ty s_)
  
  and sexp_rd_expr_list s_ = 
      (SexpPkl.rd_list sexp_rd_expr s_)
  
  and sexp_rd_expr_option s_ = 
      (SexpPkl.rd_option sexp_rd_expr s_)
  
  and sexp_rd_datum_list s_ = 
      (SexpPkl.rd_list sexp_rd_datum s_)
  
  and sexp_rd_section_list s_ = 
      (SexpPkl.rd_list sexp_rd_section s_)
  
  and sexp_rd_toplevel_list s_ = 
      (SexpPkl.rd_list sexp_rd_toplevel s_)
  
  and sexp_rd_in_alias_list s_ = 
      (SexpPkl.rd_list sexp_rd_in_alias s_)
  
  and sexp_rd_aligned_option s_ = 
      (SexpPkl.rd_option sexp_rd_aligned s_)
  
  and sexp_rd_target_list s_ = 
      (SexpPkl.rd_list sexp_rd_target s_)
  
  and sexp_rd_reg_option s_ = 
      (SexpPkl.rd_option sexp_rd_reg s_)
  
  and sexp_rd_hint_option s_ = 
      (SexpPkl.rd_option sexp_rd_hint s_)
  
  and sexp_rd_conv_option s_ = 
      (SexpPkl.rd_option sexp_rd_conv s_)
  
  and sexp_rd_name_list s_ = 
      (SexpPkl.rd_list sexp_rd_name s_)
  
  and sexp_wr_name x_ s_ = 
      (match (x_) with 
          ((string1) : Ast.name) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_name" s_);
            (StdPrimsUtil.sexp_wr_std_string string1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_conv x_ s_ = 
      (match (x_) with 
          ((string1) : Ast.conv) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_conv" s_);
            (StdPrimsUtil.sexp_wr_std_string string1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_hint x_ s_ = 
      (match (x_) with 
          ((string1) : Ast.hint) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_hint" s_);
            (StdPrimsUtil.sexp_wr_std_string string1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_reg x_ s_ = 
      (match (x_) with 
          ((string1) : Ast.reg) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_reg" s_);
            (StdPrimsUtil.sexp_wr_std_string string1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_target x_ s_ = 
      (match (x_) with 
          ((string1) : Ast.target) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_target" s_);
            (StdPrimsUtil.sexp_wr_std_string string1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_alias_set x_ s_ = 
      (match (x_) with 
          ((string1) : Ast.alias_set) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_alias_set" s_);
            (StdPrimsUtil.sexp_wr_std_string string1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_size x_ s_ = 
      (match (x_) with 
          ((int1) : Ast.size) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_size" s_);
            (StdPrimsUtil.sexp_wr_std_int int1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_align x_ s_ = 
      (match (x_) with 
          ((int1) : Ast.align) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_align" s_);
            (StdPrimsUtil.sexp_wr_std_int int1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_aligned x_ s_ = 
      (match (x_) with 
          ((int1) : Ast.aligned) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_aligned" s_);
            (StdPrimsUtil.sexp_wr_std_int int1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_in_alias x_ s_ = 
      (match (x_) with 
          ((string1) : Ast.in_alias) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_in_alias" s_);
            (StdPrimsUtil.sexp_wr_std_string string1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_op x_ s_ = 
      (match (x_) with 
          ((string1) : Ast.op) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_op" s_);
            (StdPrimsUtil.sexp_wr_std_string string1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_region x_ s_ = 
      (match (x_) with 
          ((int1, int2) : Ast.region) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_region" s_);
            (StdPrimsUtil.sexp_wr_std_int int1 s_);
            (StdPrimsUtil.sexp_wr_std_int int2 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_ty x_ s_ = 
      (match (x_) with 
          (Ast.TyAt(ty1, region1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_TyAt" s_);
            (sexp_wr_ty ty1 s_);
            (sexp_wr_region region1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.BitsTy(size1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_BitsTy" s_);
            (sexp_wr_size size1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.TypeSynonym(name1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_TypeSynonym" s_);
            (sexp_wr_name name1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_name_or_mem x_ s_ = 
      (match (x_) with 
          (Ast.NameOrMemAt(name_or_mem1, region1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_NameOrMemAt" s_);
            (sexp_wr_name_or_mem name_or_mem1 s_);
            (sexp_wr_region region1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Name(hint_opt1, name1, aligned_opt1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Name" s_);
            (SexpPkl.wr_option sexp_wr_hint hint_opt1 s_);
            (sexp_wr_name name1 s_);
            (SexpPkl.wr_option sexp_wr_aligned aligned_opt1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Mem(ty1, expr1, aligned_opt1, in_alias_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Mem" s_);
            (sexp_wr_ty ty1 s_);
            (sexp_wr_expr expr1 s_);
            (SexpPkl.wr_option sexp_wr_aligned aligned_opt1 s_);
            (SexpPkl.wr_list sexp_wr_in_alias in_alias_list1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_actual x_ s_ = 
      (match (x_) with 
          ((hint_opt1, expr1, aligned_opt1) : Ast.actual) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_actual" s_);
            (SexpPkl.wr_option sexp_wr_hint hint_opt1 s_);
            (sexp_wr_expr expr1 s_);
            (SexpPkl.wr_option sexp_wr_aligned aligned_opt1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_expr x_ s_ = 
      (match (x_) with 
          (Ast.ExprAt(expr1, region1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_ExprAt" s_);
            (sexp_wr_expr expr1 s_);
            (sexp_wr_region region1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Sint(string1, ty_opt1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Sint" s_);
            (StdPrimsUtil.sexp_wr_std_string string1 s_);
            (SexpPkl.wr_option sexp_wr_ty ty_opt1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Uint(string1, ty_opt1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Uint" s_);
            (StdPrimsUtil.sexp_wr_std_string string1 s_);
            (SexpPkl.wr_option sexp_wr_ty ty_opt1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Float(string1, ty_opt1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Float" s_);
            (StdPrimsUtil.sexp_wr_std_string string1 s_);
            (SexpPkl.wr_option sexp_wr_ty ty_opt1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Char(int1, ty_opt1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Char" s_);
            (StdPrimsUtil.sexp_wr_std_int int1 s_);
            (SexpPkl.wr_option sexp_wr_ty ty_opt1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Fetch(name_or_mem1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Fetch" s_);
            (sexp_wr_name_or_mem name_or_mem1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.BinOp(expr1, op1, expr2)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_BinOp" s_);
            (sexp_wr_expr expr1 s_);
            (sexp_wr_op op1 s_);
            (sexp_wr_expr expr2 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.UnOp(op1, expr1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_UnOp" s_);
            (sexp_wr_op op1 s_);
            (sexp_wr_expr expr1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.PrimOp(name1, actual_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_PrimOp" s_);
            (sexp_wr_name name1 s_);
            (SexpPkl.wr_list sexp_wr_actual actual_list1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_import x_ s_ = 
      (match (x_) with 
          ((string_opt1, name1) : Ast.import) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_import" s_);
            (SexpPkl.wr_option StdPrimsUtil.sexp_wr_std_string string_opt1 s_);
            (sexp_wr_name name1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_export x_ s_ = 
      (match (x_) with 
          ((name1, string_opt1) : Ast.export) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_export" s_);
            (sexp_wr_name name1 s_);
            (SexpPkl.wr_option StdPrimsUtil.sexp_wr_std_string string_opt1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_variance x_ s_ = 
      (match (x_) with 
          Ast.Invariant -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Invariant" s_);
            (SexpPkl.wr_rp s_)
          end
        | Ast.Invisible -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Invisible" s_);
            (SexpPkl.wr_rp s_)
          end
        | Ast.Variant -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Variant" s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_register x_ s_ = 
      (match (x_) with 
          ((variance1,
            hint_opt1,
            ty1,
            name1,
            reg_opt1) : Ast.register) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_register" s_);
            (sexp_wr_variance variance1 s_);
            (SexpPkl.wr_option sexp_wr_hint hint_opt1 s_);
            (sexp_wr_ty ty1 s_);
            (sexp_wr_name name1 s_);
            (SexpPkl.wr_option sexp_wr_reg reg_opt1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_arch x_ s_ = 
      (match (x_) with 
          (Ast.Memsize(int1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Memsize" s_);
            (StdPrimsUtil.sexp_wr_std_int int1 s_);
            (SexpPkl.wr_rp s_)
          end
        | Ast.ByteorderBig -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_ByteorderBig" s_);
            (SexpPkl.wr_rp s_)
          end
        | Ast.ByteorderLittle -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_ByteorderLittle" s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.FloatRepr(string1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_FloatRepr" s_);
            (StdPrimsUtil.sexp_wr_std_string string1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Charset(string1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Charset" s_);
            (StdPrimsUtil.sexp_wr_std_string string1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.WordSize(int1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_WordSize" s_);
            (StdPrimsUtil.sexp_wr_std_int int1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.PointerSize(int1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_PointerSize" s_);
            (StdPrimsUtil.sexp_wr_std_int int1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_decl x_ s_ = 
      (match (x_) with 
          (Ast.DeclAt(decl1, region1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_DeclAt" s_);
            (sexp_wr_decl decl1 s_);
            (sexp_wr_region region1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Import(ty_opt1, import_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Import" s_);
            (SexpPkl.wr_option sexp_wr_ty ty_opt1 s_);
            (SexpPkl.wr_list sexp_wr_import import_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Export(ty_opt1, export_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Export" s_);
            (SexpPkl.wr_option sexp_wr_ty ty_opt1 s_);
            (SexpPkl.wr_list sexp_wr_export export_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Const(ty_opt1, name1, expr1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Const" s_);
            (SexpPkl.wr_option sexp_wr_ty ty_opt1 s_);
            (sexp_wr_name name1 s_);
            (sexp_wr_expr expr1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Typedef(ty1, name_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Typedef" s_);
            (sexp_wr_ty ty1 s_);
            (SexpPkl.wr_list sexp_wr_name name_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Registers(register_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Registers" s_);
            (SexpPkl.wr_list sexp_wr_register register_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | Ast.Pragma -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Pragma" s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Target(arch_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Target" s_);
            (SexpPkl.wr_list sexp_wr_arch arch_list1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_bare_formal x_ s_ = 
      (match (x_) with 
          ((hint_opt1,
            variance1,
            ty1,
            name1,
            aligned_opt1) : Ast.bare_formal) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_bare_formal" s_);
            (SexpPkl.wr_option sexp_wr_hint hint_opt1 s_);
            (sexp_wr_variance variance1 s_);
            (sexp_wr_ty ty1 s_);
            (sexp_wr_name name1 s_);
            (SexpPkl.wr_option sexp_wr_aligned aligned_opt1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_formal x_ s_ = 
      (match (x_) with 
          ((region1, bare_formal1) : Ast.formal) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_formal" s_);
            (sexp_wr_region region1 s_);
            (sexp_wr_bare_formal bare_formal1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_memsize x_ s_ = 
      (match (x_) with 
          Ast.NoSize -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_NoSize" s_);
            (SexpPkl.wr_rp s_)
          end
        | Ast.DynSize -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_DynSize" s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.FixSize(expr1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_FixSize" s_);
            (sexp_wr_expr expr1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_init x_ s_ = 
      (match (x_) with 
          (Ast.InitAt(init1, region1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_InitAt" s_);
            (sexp_wr_init init1 s_);
            (sexp_wr_region region1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.InitExprs(expr_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_InitExprs" s_);
            (SexpPkl.wr_list sexp_wr_expr expr_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.InitStr(string1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_InitStr" s_);
            (StdPrimsUtil.sexp_wr_std_string string1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.InitUStr(string1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_InitUStr" s_);
            (StdPrimsUtil.sexp_wr_std_string string1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_datum x_ s_ = 
      (match (x_) with 
          (Ast.DatumAt(datum1, region1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_DatumAt" s_);
            (sexp_wr_datum datum1 s_);
            (sexp_wr_region region1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Label(name1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Label" s_);
            (sexp_wr_name name1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Align(align1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Align" s_);
            (sexp_wr_align align1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.MemDecl(ty1, memsize1, init_opt1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_MemDecl" s_);
            (sexp_wr_ty ty1 s_);
            (sexp_wr_memsize memsize1 s_);
            (SexpPkl.wr_option sexp_wr_init init_opt1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_cformal x_ s_ = 
      (match (x_) with 
          ((region1,
            hint_opt1,
            name1,
            aligned_opt1) : Ast.cformal) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_cformal" s_);
            (sexp_wr_region region1 s_);
            (SexpPkl.wr_option sexp_wr_hint hint_opt1 s_);
            (sexp_wr_name name1 s_);
            (SexpPkl.wr_option sexp_wr_aligned aligned_opt1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_flow x_ s_ = 
      (match (x_) with 
          (Ast.FlowAt(flow1, region1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_FlowAt" s_);
            (sexp_wr_flow flow1 s_);
            (sexp_wr_region region1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.CutsTo(name_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_CutsTo" s_);
            (SexpPkl.wr_list sexp_wr_name name_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.UnwindsTo(name_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_UnwindsTo" s_);
            (SexpPkl.wr_list sexp_wr_name name_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.ReturnsTo(name_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_ReturnsTo" s_);
            (SexpPkl.wr_list sexp_wr_name name_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | Ast.NeverReturns -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_NeverReturns" s_);
            (SexpPkl.wr_rp s_)
          end
        | Ast.Aborts -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Aborts" s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_mem x_ s_ = 
      (match (x_) with 
          (Ast.AliasAt(mem1, region1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_AliasAt" s_);
            (sexp_wr_mem mem1 s_);
            (sexp_wr_region region1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Reads(name_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Reads" s_);
            (SexpPkl.wr_list sexp_wr_name name_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Writes(name_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Writes" s_);
            (SexpPkl.wr_list sexp_wr_name name_list1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_procann x_ s_ = 
      (match (x_) with 
          (Ast.Flow(flow1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Flow" s_);
            (sexp_wr_flow flow1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Alias(mem1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Alias" s_);
            (sexp_wr_mem mem1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_altcont x_ s_ = 
      (match (x_) with 
          ((expr1, expr2) : Ast.altcont) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_altcont" s_);
            (sexp_wr_expr expr1 s_);
            (sexp_wr_expr expr2 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_range x_ s_ = 
      (match (x_) with 
          (Ast.Point(expr1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Point" s_);
            (sexp_wr_expr expr1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Range(expr1, expr2)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Range" s_);
            (sexp_wr_expr expr1 s_);
            (sexp_wr_expr expr2 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_guarded x_ s_ = 
      (match (x_) with 
          ((guard, value) : Ast.guarded) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_guarded" s_);
            (SexpPkl.wr_option sexp_wr_expr guard s_);
            (sexp_wr_expr value s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_arm x_ s_ = 
      (match (x_) with 
          (Ast.ArmAt(arm1, region1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_ArmAt" s_);
            (sexp_wr_arm arm1 s_);
            (sexp_wr_region region1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Case(range_list1, body_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Case" s_);
            (SexpPkl.wr_list sexp_wr_range range_list1 s_);
            (SexpPkl.wr_list sexp_wr_body body_list1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_stmt x_ s_ = 
      (match (x_) with 
          (Ast.StmtAt(stmt1, region1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_StmtAt" s_);
            (sexp_wr_stmt stmt1 s_);
            (sexp_wr_region region1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.IfStmt(expr1, body_list1, body_list2)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_IfStmt" s_);
            (sexp_wr_expr expr1 s_);
            (SexpPkl.wr_list sexp_wr_body body_list1 s_);
            (SexpPkl.wr_list sexp_wr_body body_list2 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.SwitchStmt(range_opt1, expr1, arm_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_SwitchStmt" s_);
            (SexpPkl.wr_option sexp_wr_range range_opt1 s_);
            (sexp_wr_expr expr1 s_);
            (SexpPkl.wr_list sexp_wr_arm arm_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.LabelStmt(name1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_LabelStmt" s_);
            (sexp_wr_name name1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.ContStmt(name1, cformal_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_ContStmt" s_);
            (sexp_wr_name name1 s_);
            (SexpPkl.wr_list sexp_wr_cformal cformal_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.SpanStmt(key, value, body_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_SpanStmt" s_);
            (sexp_wr_expr key s_);
            (sexp_wr_expr value s_);
            (SexpPkl.wr_list sexp_wr_body body_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.AssignStmt(name_or_mem_list1, guarded_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_AssignStmt" s_);
            (SexpPkl.wr_list sexp_wr_name_or_mem name_or_mem_list1 s_);
            (SexpPkl.wr_list sexp_wr_guarded guarded_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.CallStmt(name_or_mem_list1,
            conv_opt1,
            expr1,
            actual_list1,
            target_list1,
            procann_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_CallStmt" s_);
            (SexpPkl.wr_list sexp_wr_name_or_mem name_or_mem_list1 s_);
            (SexpPkl.wr_option sexp_wr_conv conv_opt1 s_);
            (sexp_wr_expr expr1 s_);
            (SexpPkl.wr_list sexp_wr_actual actual_list1 s_);
            (SexpPkl.wr_list sexp_wr_target target_list1 s_);
            (SexpPkl.wr_list sexp_wr_procann procann_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.PrimStmt(name_or_mem_list1,
            conv_opt1,
            name1,
            actual_list1,
            flow_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_PrimStmt" s_);
            (SexpPkl.wr_list sexp_wr_name_or_mem name_or_mem_list1 s_);
            (SexpPkl.wr_option sexp_wr_conv conv_opt1 s_);
            (sexp_wr_name name1 s_);
            (SexpPkl.wr_list sexp_wr_actual actual_list1 s_);
            (SexpPkl.wr_list sexp_wr_flow flow_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.GotoStmt(expr1, target_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_GotoStmt" s_);
            (sexp_wr_expr expr1 s_);
            (SexpPkl.wr_list sexp_wr_target target_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.JumpStmt(conv_opt1,
            expr1,
            actual_list1,
            target_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_JumpStmt" s_);
            (SexpPkl.wr_option sexp_wr_conv conv_opt1 s_);
            (sexp_wr_expr expr1 s_);
            (SexpPkl.wr_list sexp_wr_actual actual_list1 s_);
            (SexpPkl.wr_list sexp_wr_target target_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.CutStmt(expr1, actual_list1, flow_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_CutStmt" s_);
            (sexp_wr_expr expr1 s_);
            (SexpPkl.wr_list sexp_wr_actual actual_list1 s_);
            (SexpPkl.wr_list sexp_wr_flow flow_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.ReturnStmt(conv_opt1, altcont_opt1, actual_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_ReturnStmt" s_);
            (SexpPkl.wr_option sexp_wr_conv conv_opt1 s_);
            (SexpPkl.wr_option sexp_wr_altcont altcont_opt1 s_);
            (SexpPkl.wr_list sexp_wr_actual actual_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | Ast.EmptyStmt -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_EmptyStmt" s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.CommentStmt(string1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_CommentStmt" s_);
            (StdPrimsUtil.sexp_wr_std_string string1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.LimitcheckStmt(expr1, expr_opt1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_LimitcheckStmt" s_);
            (sexp_wr_expr expr1 s_);
            (SexpPkl.wr_option sexp_wr_expr expr_opt1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_body x_ s_ = 
      (match (x_) with 
          (Ast.BodyAt(body1, region1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_BodyAt" s_);
            (sexp_wr_body body1 s_);
            (sexp_wr_region region1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.DeclBody(decl1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_DeclBody" s_);
            (sexp_wr_decl decl1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.StmtBody(stmt1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_StmtBody" s_);
            (sexp_wr_stmt stmt1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.DataBody(datum_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_DataBody" s_);
            (SexpPkl.wr_list sexp_wr_datum datum_list1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_proc x_ s_ = 
      (match (x_) with 
          ((conv_opt1,
            name1,
            formal_list1,
            body_list1,
            region1) : Ast.proc) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_proc" s_);
            (SexpPkl.wr_option sexp_wr_conv conv_opt1 s_);
            (sexp_wr_name name1 s_);
            (SexpPkl.wr_list sexp_wr_formal formal_list1 s_);
            (SexpPkl.wr_list sexp_wr_body body_list1 s_);
            (sexp_wr_region region1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_section x_ s_ = 
      (match (x_) with 
          (Ast.SectionAt(section1, region1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_SectionAt" s_);
            (sexp_wr_section section1 s_);
            (sexp_wr_region region1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Decl(decl1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Decl" s_);
            (sexp_wr_decl decl1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Procedure(proc1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Procedure" s_);
            (sexp_wr_proc proc1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Datum(datum1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Datum" s_);
            (sexp_wr_datum datum1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.SSpan(key, value, section_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_SSpan" s_);
            (sexp_wr_expr key s_);
            (sexp_wr_expr value s_);
            (SexpPkl.wr_list sexp_wr_section section_list1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_toplevel x_ s_ = 
      (match (x_) with 
          (Ast.ToplevelAt(toplevel1, region1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_ToplevelAt" s_);
            (sexp_wr_toplevel toplevel1 s_);
            (sexp_wr_region region1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.Section(name1, section_list1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_Section" s_);
            (sexp_wr_name name1 s_);
            (SexpPkl.wr_list sexp_wr_section section_list1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.TopDecl(decl1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_TopDecl" s_);
            (sexp_wr_decl decl1 s_);
            (SexpPkl.wr_rp s_)
          end
        | (Ast.TopProcedure(proc1)) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_TopProcedure" s_);
            (sexp_wr_proc proc1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_program x_ s_ = 
      (match (x_) with 
          ((toplevel_list1) : Ast.program) -> begin
            (SexpPkl.wr_lp s_);
            (SexpPkl.wr_sym "ast_program" s_);
            (SexpPkl.wr_list sexp_wr_toplevel toplevel_list1 s_);
            (SexpPkl.wr_rp s_)
          end)
      (* end match *)
  
  and sexp_wr_guarded_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_guarded x_ s_)
  
  and sexp_wr_arm_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_arm x_ s_)
  
  and sexp_wr_range_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_range x_ s_)
  
  and sexp_wr_range_option x_ s_ = 
      (SexpPkl.wr_option sexp_wr_range x_ s_)
  
  and sexp_wr_altcont_option x_ s_ = 
      (SexpPkl.wr_option sexp_wr_altcont x_ s_)
  
  and sexp_wr_name_or_mem_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_name_or_mem x_ s_)
  
  and sexp_wr_procann_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_procann x_ s_)
  
  and sexp_wr_flow_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_flow x_ s_)
  
  and sexp_wr_cformal_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_cformal x_ s_)
  
  and sexp_wr_actual_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_actual x_ s_)
  
  and sexp_wr_init_option x_ s_ = 
      (SexpPkl.wr_option sexp_wr_init x_ s_)
  
  and sexp_wr_body_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_body x_ s_)
  
  and sexp_wr_formal_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_formal x_ s_)
  
  and sexp_wr_arch_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_arch x_ s_)
  
  and sexp_wr_register_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_register x_ s_)
  
  and sexp_wr_export_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_export x_ s_)
  
  and sexp_wr_import_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_import x_ s_)
  
  and sexp_wr_ty_option x_ s_ = 
      (SexpPkl.wr_option sexp_wr_ty x_ s_)
  
  and sexp_wr_expr_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_expr x_ s_)
  
  and sexp_wr_expr_option x_ s_ = 
      (SexpPkl.wr_option sexp_wr_expr x_ s_)
  
  and sexp_wr_datum_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_datum x_ s_)
  
  and sexp_wr_section_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_section x_ s_)
  
  and sexp_wr_toplevel_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_toplevel x_ s_)
  
  and sexp_wr_in_alias_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_in_alias x_ s_)
  
  and sexp_wr_aligned_option x_ s_ = 
      (SexpPkl.wr_option sexp_wr_aligned x_ s_)
  
  and sexp_wr_target_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_target x_ s_)
  
  and sexp_wr_reg_option x_ s_ = 
      (SexpPkl.wr_option sexp_wr_reg x_ s_)
  
  and sexp_wr_hint_option x_ s_ = 
      (SexpPkl.wr_option sexp_wr_hint x_ s_)
  
  and sexp_wr_conv_option x_ s_ = 
      (SexpPkl.wr_option sexp_wr_conv x_ s_)
  
  and sexp_wr_name_list x_ s_ = 
      (SexpPkl.wr_list sexp_wr_name x_ s_)