#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("&$0")>]
type Ref<'T> = class end
#else
type Ref<'T> = 'T
#endif

#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("clap::Command")>]
#endif
type clap_Command = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("clap::Arg")>]
#endif
type clap_Arg = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::string::String")>]
type std_string_String = class end
#else
type std_string_String = string
#endif

#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("mut $0")>]
#endif
type Mut<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("Vec<$0>")>]
#endif
type Vec<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("clap::ArgMatches")>]
#endif
type clap_ArgMatches = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::path::PathBuf")>]
type std_path_PathBuf = class end
#else
type std_path_PathBuf = string
#endif

#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::path::Display")>]
type std_path_Display = class end
#else
type std_path_Display = string
#endif

#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::io::Error")>]
type std_io_Error = class end
#else
type std_io_Error = string
#endif

#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::ffi::OsString")>]
#endif
type std_ffi_OsString = class end
#if FABLE_COMPILER
type file_info = unit
#else
type file_info = System.IO.FileInfo
#endif

#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("regex::Regex")>]
#endif
type regex_Regex = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::borrow::Cow<$0>")>]
#endif
type std_borrow_Cow<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("async_walkdir::WalkDir")>]
#endif
type async_walkdir_WalkDir = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("async_walkdir::DirEntry")>]
#endif
type async_walkdir_DirEntry = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::pin::Pin<$0>")>]
#endif
type std_pin_Pin<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::fs::FileType")>]
#endif
type std_fs_FileType = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("async_walkdir::Filtering")>]
#endif
type async_walkdir_Filtering = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("async_walkdir::Error")>]
#endif
type async_walkdir_Error = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("rayon::vec::IntoIter<$0>")>]
#endif
type rayon_vec_IntoIter<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::process::Command")>]
#endif
type std_process_Command = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::process::Stdio")>]
#endif
type std_process_Stdio = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::process::Child")>]
#endif
type std_process_Child = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::sync::Mutex<$0>")>]
#endif
type std_sync_Mutex<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::sync::Arc<$0>")>]
#endif
type std_sync_Arc<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::sync::MutexGuard<$0>")>]
#endif
type std_sync_MutexGuard<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::process::ChildStdout")>]
#endif
type std_process_ChildStdout = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::process::ChildStderr")>]
#endif
type std_process_ChildStderr = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::process::ChildStdin")>]
#endif
type std_process_ChildStdin = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::sync::mpsc::Sender<$0>")>]
#endif
type std_sync_mpsc_Sender<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("encoding_rs_io::DecodeReaderBytes<$0, $1>")>]
#endif
type encoding_rs_io_DecodeReaderBytes<'T, 'U> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::io::BufReader<$0>")>]
#endif
type std_io_BufReader<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::io::Lines<$0>")>]
#endif
type std_io_Lines<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::sync::mpsc::SendError<$0>")>]
#endif
type std_sync_mpsc_SendError<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("_")>]
#endif
type core_ops_Try<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::thread::JoinHandle<$0>")>]
#endif
type std_thread_JoinHandle<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::process::Output")>]
#endif
type std_process_Output = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::process::ExitStatus")>]
#endif
type std_process_ExitStatus = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::fs::File")>]
#endif
type std_fs_File = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("sha2::Sha256")>]
#endif
type sha2_Sha256 = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("_")>]
#endif
type Slice'<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("rayon::iter::Map<$0, _>")>]
#endif
type rayon_iter_Map<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("$0 $1")>]
#endif
type Lifetime<'T, 'U> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("'static")>]
#endif
type StaticLifetime = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("str")>]
type Str = class end
#else
type Str = string
#endif

module TraceState = let mutable trace_state = None
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::env::VarError")>]
#endif
type std_env_VarError = class end
type IOsEnviron = abstract environ: x: unit -> obj
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("Box<$0>")>]
#endif
type Box<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("dyn $0")>]
#endif
type Dyn<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::future::Future<Output = $0>")>]
#endif
type std_future_Future<'T> = class end
type IPathJoin = abstract join: [<System.ParamArray>] paths: string[] -> string
type IFsExistsSync = abstract existsSync: path: string -> bool
type IPathDirname = abstract dirname: path: string -> string
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::ffi::OsStr")>]
#endif
type std_ffi_OsStr = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("regex::Error")>]
#endif
type regex_Error = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("Send")>]
#endif
type Send<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("$0 + $1")>]
#endif
type LifetimeJoin<'T, 'U> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::sync::mpsc::Receiver<$0>")>]
#endif
type std_sync_mpsc_Receiver<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::sync::PoisonError<$0>")>]
#endif
type std_sync_PoisonError<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("encoding_rs::Encoding")>]
#endif
type encoding_rs_Encoding = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("[$0]")>]
#endif
type Slice<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::str::Utf8Error")>]
#endif
type std_str_Utf8Error = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("$0")>]
#endif
type LifetimeRef<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("core::any::Any")>]
type core_any_Any = class end
#else
type core_any_Any = obj
#endif

#if FABLE_COMPILER
[<CompilationRepresentation (CompilationRepresentationFlags.ModuleSuffix)>]
module System =
 module Diagnostics =
  type Process = unit
  type DataReceivedEventArgs = unit
#endif
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("std::string::FromUtf8Error")>]
#endif
type std_string_FromUtf8Error = class end
type [<Struct>] US0 =
    | US0_0
    | US0_1
    | US0_2
    | US0_3
    | US0_4
and Mut0 = {mutable l0 : int64}
and Mut1 = {mutable l0 : (string -> unit)}
and Mut2 = {mutable l0 : bool}
and Mut3 = {mutable l0 : string}
and Mut4 = {mutable l0 : US0}
and [<Struct>] US1 =
    | US1_0 of f0_0 : string
    | US1_1
and [<Struct>] US2 =
    | US2_0 of f0_0 : US0
    | US2_1
and [<Struct>] US3 =
    | US3_0 of f0_0 : int64
    | US3_1
and [<Struct>] US4 =
    | US4_0 of f0_0 : std_string_String
    | US4_1
and [<Struct>] US5 =
    | US5_0
    | US5_1
    | US5_2
and [<Struct>] US6 =
    | US6_0 of f0_0 : US5
    | US6_1 of f1_0 : US5
    | US6_2 of f2_0 : US5
    | US6_3 of f3_0 : US5
    | US6_4 of f4_0 : US5
and [<Struct>] US7 =
    | US7_0 of f0_0 : string
    | US7_1 of f1_0 : string
and [<Struct>] US8 =
    | US8_0 of f0_0 : std_path_PathBuf
    | US8_1 of f1_0 : string
and [<Struct>] US9 =
    | US9_0 of f0_0 : std_path_PathBuf
    | US9_1
and Mut5 = {mutable l0 : int32; mutable l1 : int32; mutable l2 : (string [])}
and Mut6 = {mutable l0 : int32}
and [<Struct>] US10 =
    | US10_0 of f0_0 : std_fs_FileType
    | US10_1 of f1_0 : std_string_String
and [<Struct>] US11 =
    | US11_0
    | US11_1
    | US11_2
and [<Struct>] US12 =
    | US12_0 of f0_0 : async_walkdir_DirEntry
    | US12_1 of f1_0 : std_string_String
and [<Struct>] US13 =
    | US13_0 of f0_0 : string * f0_1 : US1
    | US13_1 of f1_0 : string
and [<Struct>] US14 =
    | US14_0 of f0_0 : char * f0_1 : string * f0_2 : System.Text.StringBuilder * f0_3 : int32 * f0_4 : int32
    | US14_1 of f1_0 : string
and UH0 =
    | UH0_0
    | UH0_1 of char * UH0
and UH1 =
    | UH1_0
    | UH1_1 of (struct (string * System.Text.StringBuilder * int32 * int32) -> US14) * UH1
and [<Struct>] US15 =
    | US15_0 of f0_0 : string * f0_1 : string * f0_2 : System.Text.StringBuilder * f0_3 : int32 * f0_4 : int32
    | US15_1 of f1_0 : string
and [<Struct>] US16 =
    | US16_0 of f0_0 : char
    | US16_1
and [<Struct>] US17 =
    | US17_0 of f0_0 : string * f0_1 : System.Text.StringBuilder * f0_2 : int32 * f0_3 : int32
    | US17_1 of f1_0 : string
and [<Struct>] US18 =
    | US18_0 of f0_0 : string * f0_1 : US1 * f0_2 : string * f0_3 : System.Text.StringBuilder * f0_4 : int32 * f0_5 : int32
    | US18_1 of f1_0 : string
and [<Struct>] US19 =
    | US19_0 of f0_0 : US16 * f0_1 : string * f0_2 : System.Text.StringBuilder * f0_3 : int32 * f0_4 : int32
    | US19_1 of f1_0 : string
and [<Struct>] US20 =
    | US20_0 of f0_0 : US1 * f0_1 : string * f0_2 : System.Text.StringBuilder * f0_3 : int32 * f0_4 : int32
    | US20_1 of f1_0 : string
and [<Struct>] US21 =
    | US21_0 of f0_0 : (string [])
    | US21_1 of f1_0 : string
and UH2 =
    | UH2_0
    | UH2_1 of string * UH2
and [<Struct>] US22 =
    | US22_0 of f0_0 : UH2 * f0_1 : string * f0_2 : System.Text.StringBuilder * f0_3 : int32 * f0_4 : int32
    | US22_1 of f1_0 : string
and UH3 =
    | UH3_0
    | UH3_1 of (struct (string * System.Text.StringBuilder * int32 * int32) -> US15) * UH3
and [<Struct>] US23 =
    | US23_0 of f0_0 : std_sync_Arc<std_sync_Mutex<std_process_Child option>>
    | US23_1 of f1_0 : std_string_String
and [<Struct>] US24 =
    | US24_0 of f0_0 : std_sync_Arc<std_sync_Mutex<std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>>>
    | US24_1
and [<Struct>] US25 =
    | US25_0 of f0_0 : std_string_String
    | US25_1 of f1_0 : std_string_String
and [<Struct>] US26 =
    | US26_0 of f0_0 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit)
    | US26_1
and [<Struct>] US27 =
    | US27_0 of f0_0 : std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>>
    | US27_1
and [<Struct>] US28 =
    | US28_0 of f0_0 : std_process_Output
    | US28_1 of f1_0 : std_string_String
and [<Struct>] US29 =
    | US29_0 of f0_0 : int32
    | US29_1
and [<Struct>] US30 =
    | US30_0 of f0_0 : (struct (int32 * string * bool) -> Async<unit>)
    | US30_1
and [<Struct>] US31 =
    | US31_0 of f0_0 : System.Threading.CancellationToken
    | US31_1
and [<Struct>] US32 =
    | US32_0 of f0_0 : Result<string, (string * string)>
    | US32_1
and UH5 =
    | UH5_0
    | UH5_1 of string * string * (string -> (string -> US32)) * UH5
and UH4 =
    | UH4_0
    | UH4_1 of UH5 * UH4
and [<Struct>] US33 =
    | US33_0 of f0_0 : string
    | US33_1 of f1_0 : std_string_String
and [<Struct>] US34 =
    | US34_0 of f0_0 : uint64
    | US34_1 of f1_0 : std_string_String
and [<Struct>] US35 =
    | US35_0 of f0_0 : int32 * f0_1 : string
    | US35_1 of f1_0 : int32 * f1_1 : string
and Mut7 = {mutable l0 : int32; mutable l1 : int32}
and Mut8 = {mutable l0 : int32; mutable l1 : string; mutable l2 : int32; mutable l3 : int32}
and Mut9 = {mutable l0 : int32; mutable l1 : Vec<Result<string, (string * string)> option>}
and [<Struct>] US36 =
    | US36_0 of f0_0 : Vec<Result<(string * Vec<Result<string, (string * string)> option>), std_string_String>>
    | US36_1 of f1_0 : std_string_String
let rec method0 () : clap_Command =
    let v0 : string = "command"
    let v1 : string = "r#\"" + v0 + "\"#"
    let v2 : Ref<Lifetime<StaticLifetime, Str>> = Fable.Core.RustInterop.emitRustExpr () v1 
    let v3 : string = "clap::Command::new($0)"
    let v4 : clap_Command = Fable.Core.RustInterop.emitRustExpr v2 v3 
    let v5 : string = "source-dir"
    let v6 : string = "r#\"" + v5 + "\"#"
    let v7 : Ref<Lifetime<StaticLifetime, Str>> = Fable.Core.RustInterop.emitRustExpr () v6 
    let v8 : string = "clap::Arg::new($0)"
    let v9 : clap_Arg = Fable.Core.RustInterop.emitRustExpr v7 v8 
    let v10 : string = "$0.short($1)"
    let v11 : clap_Arg = Fable.Core.RustInterop.emitRustExpr struct (v9, 's') v10 
    let v12 : string = "r#\"" + v5 + "\"#"
    let v13 : Ref<Lifetime<StaticLifetime, Str>> = Fable.Core.RustInterop.emitRustExpr () v12 
    let v14 : string = "$0.long($1)"
    let v15 : clap_Arg = Fable.Core.RustInterop.emitRustExpr struct (v11, v13) v14 
    let v16 : string = "$0.required($1)"
    let v17 : clap_Arg = Fable.Core.RustInterop.emitRustExpr struct (v15, true) v16 
    let v18 : string = "clap::Command::arg($0, $1)"
    let v19 : clap_Command = Fable.Core.RustInterop.emitRustExpr struct (v4, v17) v18 
    let v20 : string = "dist-dir"
    let v21 : string = "r#\"" + v20 + "\"#"
    let v22 : Ref<Lifetime<StaticLifetime, Str>> = Fable.Core.RustInterop.emitRustExpr () v21 
    let v23 : string = "clap::Arg::new($0)"
    let v24 : clap_Arg = Fable.Core.RustInterop.emitRustExpr v22 v23 
    let v25 : string = "$0.short($1)"
    let v26 : clap_Arg = Fable.Core.RustInterop.emitRustExpr struct (v24, 'd') v25 
    let v27 : string = "r#\"" + v20 + "\"#"
    let v28 : Ref<Lifetime<StaticLifetime, Str>> = Fable.Core.RustInterop.emitRustExpr () v27 
    let v29 : string = "$0.long($1)"
    let v30 : clap_Arg = Fable.Core.RustInterop.emitRustExpr struct (v26, v28) v29 
    let v31 : string = "$0.required($1)"
    let v32 : clap_Arg = Fable.Core.RustInterop.emitRustExpr struct (v30, true) v31 
    let v33 : string = "clap::Command::arg($0, $1)"
    let v34 : clap_Command = Fable.Core.RustInterop.emitRustExpr struct (v19, v32) v33 
    let v35 : string = "cache-dir"
    let v36 : string = "r#\"" + v35 + "\"#"
    let v37 : Ref<Lifetime<StaticLifetime, Str>> = Fable.Core.RustInterop.emitRustExpr () v36 
    let v38 : string = "clap::Arg::new($0)"
    let v39 : clap_Arg = Fable.Core.RustInterop.emitRustExpr v37 v38 
    let v40 : string = "$0.short($1)"
    let v41 : clap_Arg = Fable.Core.RustInterop.emitRustExpr struct (v39, 'c') v40 
    let v42 : string = "r#\"" + v35 + "\"#"
    let v43 : Ref<Lifetime<StaticLifetime, Str>> = Fable.Core.RustInterop.emitRustExpr () v42 
    let v44 : string = "$0.long($1)"
    let v45 : clap_Arg = Fable.Core.RustInterop.emitRustExpr struct (v41, v43) v44 
    let v46 : string = "$0.required($1)"
    let v47 : clap_Arg = Fable.Core.RustInterop.emitRustExpr struct (v45, true) v46 
    let v48 : string = "clap::Command::arg($0, $1)"
    let v49 : clap_Command = Fable.Core.RustInterop.emitRustExpr struct (v34, v47) v48 
    let v50 : string = "hangul-spec"
    let v51 : string = "r#\"" + v50 + "\"#"
    let v52 : Ref<Lifetime<StaticLifetime, Str>> = Fable.Core.RustInterop.emitRustExpr () v51 
    let v53 : string = "clap::Arg::new($0)"
    let v54 : clap_Arg = Fable.Core.RustInterop.emitRustExpr v52 v53 
    let v55 : string = "$0.short($1)"
    let v56 : clap_Arg = Fable.Core.RustInterop.emitRustExpr struct (v54, 'h') v55 
    let v57 : string = "r#\"" + v50 + "\"#"
    let v58 : Ref<Lifetime<StaticLifetime, Str>> = Fable.Core.RustInterop.emitRustExpr () v57 
    let v59 : string = "$0.long($1)"
    let v60 : clap_Arg = Fable.Core.RustInterop.emitRustExpr struct (v56, v58) v59 
    let v61 : string = "$0.required($1)"
    let v62 : clap_Arg = Fable.Core.RustInterop.emitRustExpr struct (v60, true) v61 
    let v63 : string = "clap::Command::arg($0, $1)"
    let v64 : clap_Command = Fable.Core.RustInterop.emitRustExpr struct (v49, v62) v63 
    v64
and closure0 () () : unit =
    let v0 : string = "true; () //"
    let v1 : bool = Fable.Core.RustInterop.emitRustExpr () v0 
    let v2 : string = "} /* /*"
    Fable.Core.RustInterop.emitRustExpr () v2 
    let v3 : string = "verify_app"
    let v4 : string = $"*/ #[test] fn " + v3 + "() { //"
    let v5 : bool = Fable.Core.RustInterop.emitRustExpr () v4 
    let v6 : clap_Command = method0()
    let v7 : string = "clap::Command::debug_assert($0)"
    Fable.Core.RustInterop.emitRustExpr v6 v7 
    let v8 : string = "{ //"
    Fable.Core.RustInterop.emitRustExpr () v8 
    ()
and method2 () : string =
    let v0 : string = "TRACE_LEVEL"
    v0
and method4 () : string =
    let v0 : string = ""
    v0
and closure3 () (v0 : string) : US1 =
    US1_0(v0)
and method5 () : (string -> US1) =
    closure3()
and method3 (v0 : string) : string =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : string = "std::env::var(&*$0)"
    let v3 : Result<std_string_String, std_env_VarError> = Fable.Core.RustInterop.emitRustExpr v0 v2 
    let v4 : string = "true; let _result_map_ = $0.map(|x| { //"
    let v5 : bool = Fable.Core.RustInterop.emitRustExpr v3 v4 
    let v6 : string = "x"
    let v7 : std_string_String = Fable.Core.RustInterop.emitRustExpr () v6 
    let v8 : string = "fable_library_rust::String_::fromString($0)"
    let v9 : string = Fable.Core.RustInterop.emitRustExpr v7 v8 
    let v10 : string = "true; $0 })"
    let v11 : bool = Fable.Core.RustInterop.emitRustExpr v9 v10 
    let v12 : string = "_result_map_"
    let v13 : Result<string, std_env_VarError> = Fable.Core.RustInterop.emitRustExpr () v12 
    let v14 : string = method4()
    let v15 : string = "$0.unwrap_or($1)"
    let v16 : string = Fable.Core.RustInterop.emitRustExpr struct (v13, v14) v15 
    let _v1 = v16 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v17 : string = "std::env::var(&*$0)"
    let v18 : Result<std_string_String, std_env_VarError> = Fable.Core.RustInterop.emitRustExpr v0 v17 
    let v19 : string = "true; let _result_map_ = $0.map(|x| { //"
    let v20 : bool = Fable.Core.RustInterop.emitRustExpr v18 v19 
    let v21 : string = "x"
    let v22 : std_string_String = Fable.Core.RustInterop.emitRustExpr () v21 
    let v23 : string = "fable_library_rust::String_::fromString($0)"
    let v24 : string = Fable.Core.RustInterop.emitRustExpr v22 v23 
    let v25 : string = "true; $0 })"
    let v26 : bool = Fable.Core.RustInterop.emitRustExpr v24 v25 
    let v27 : string = "_result_map_"
    let v28 : Result<string, std_env_VarError> = Fable.Core.RustInterop.emitRustExpr () v27 
    let v29 : string = method4()
    let v30 : string = "$0.unwrap_or($1)"
    let v31 : string = Fable.Core.RustInterop.emitRustExpr struct (v28, v29) v30 
    let _v1 = v31 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v32 : string = "std::env::var(&*$0)"
    let v33 : Result<std_string_String, std_env_VarError> = Fable.Core.RustInterop.emitRustExpr v0 v32 
    let v34 : string = "true; let _result_map_ = $0.map(|x| { //"
    let v35 : bool = Fable.Core.RustInterop.emitRustExpr v33 v34 
    let v36 : string = "x"
    let v37 : std_string_String = Fable.Core.RustInterop.emitRustExpr () v36 
    let v38 : string = "fable_library_rust::String_::fromString($0)"
    let v39 : string = Fable.Core.RustInterop.emitRustExpr v37 v38 
    let v40 : string = "true; $0 })"
    let v41 : bool = Fable.Core.RustInterop.emitRustExpr v39 v40 
    let v42 : string = "_result_map_"
    let v43 : Result<string, std_env_VarError> = Fable.Core.RustInterop.emitRustExpr () v42 
    let v44 : string = method4()
    let v45 : string = "$0.unwrap_or($1)"
    let v46 : string = Fable.Core.RustInterop.emitRustExpr struct (v43, v44) v45 
    let _v1 = v46 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v47 : string = "process.env[$0] ?? \"\""
    let v48 : string = Fable.Core.JsInterop.emitJsExpr v0 v47 
    let _v1 = v48 
    #endif
#if FABLE_COMPILER_PYTHON
    let v49 : string = "os"
    let v50 : IOsEnviron = Fable.Core.PyInterop.importAll v49 
    let v51 : string = "v50.environ"
    let v52 : obj = Fable.Core.PyInterop.emitPyExpr () v51 
    let v55 : string = "v52.get($0)"
    let v56 : string = Fable.Core.PyInterop.emitPyExpr v0 v55 
    let mutable _v56 = None
    #if !FABLE_COMPILER && !WASM && !CONTRACT
    let v59 : (string -> string option) = Option.ofObj
    let v60 : string option = v59 v56
    v60 
    #else
    Some v56 
    #endif
    |> fun x -> _v56 <- Some x
    let v61 : string option = match _v56 with Some x -> x | None -> failwith "optionm'.of_obj / _v56=None"
    let v64 : (string -> US1) = method5()
    let v65 : US1 option = v61 |> Option.map v64 
    let v76 : US1 = US1_1
    let v77 : US1 = v65 |> Option.defaultValue v76 
    let v84 : string =
        match v77 with
        | US1_1 -> (* None *)
            let v82 : string = ""
            v82
        | US1_0(v81) -> (* Some *)
            v81
    let _v1 = v84 
    #endif
#else
    let v85 : (string -> string) = System.Environment.GetEnvironmentVariable
    let v86 : string = v85 v0
    let mutable _v86 = None
    #if !FABLE_COMPILER && !WASM && !CONTRACT
    let v87 : (string -> string option) = Option.ofObj
    let v88 : string option = v87 v86
    v88 
    #else
    Some v86 
    #endif
    |> fun x -> _v86 <- Some x
    let v89 : string option = match _v86 with Some x -> x | None -> failwith "optionm'.of_obj / _v86=None"
    let v92 : (string -> US1) = method5()
    let v93 : US1 option = v89 |> Option.map v92 
    let v104 : US1 = US1_1
    let v105 : US1 = v93 |> Option.defaultValue v104 
    let v112 : string =
        match v105 with
        | US1_1 -> (* None *)
            let v110 : string = ""
            v110
        | US1_0(v109) -> (* Some *)
            v109
    let _v1 = v112 
    #endif
    let v113 : string = _v1 
    v113
and method6 () : string =
    let v0 : string = "AUTOMATION"
    v0
and closure4 () (v0 : string) : unit =
    ()
and method1 (v0 : US0) : struct (Mut0 * Mut1 * Mut2 * Mut3 * Mut4 * int64 option) =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : string = method2()
    let v3 : string = method3(v2)
    
    
    
    
    
    let v4 : bool = "Verbose" = v3
    let v8 : US2 =
        if v4 then
            let v5 : US0 = US0_0
            US2_0(v5)
        else
            US2_1
    let v49 : US2 =
        match v8 with
        | US2_1 -> (* None *)
            let v11 : bool = "Debug" = v3
            let v15 : US2 =
                if v11 then
                    let v12 : US0 = US0_1
                    US2_0(v12)
                else
                    US2_1
            match v15 with
            | US2_1 -> (* None *)
                let v18 : bool = "Info" = v3
                let v22 : US2 =
                    if v18 then
                        let v19 : US0 = US0_2
                        US2_0(v19)
                    else
                        US2_1
                match v22 with
                | US2_1 -> (* None *)
                    let v25 : bool = "Warning" = v3
                    let v29 : US2 =
                        if v25 then
                            let v26 : US0 = US0_3
                            US2_0(v26)
                        else
                            US2_1
                    match v29 with
                    | US2_1 -> (* None *)
                        let v32 : bool = "Critical" = v3
                        let v36 : US2 =
                            if v32 then
                                let v33 : US0 = US0_4
                                US2_0(v33)
                            else
                                US2_1
                        match v36 with
                        | US2_1 -> (* None *)
                            US2_1
                        | US2_0(v37) -> (* Some *)
                            US2_0(v37)
                    | US2_0(v30) -> (* Some *)
                        US2_0(v30)
                | US2_0(v23) -> (* Some *)
                    US2_0(v23)
            | US2_0(v16) -> (* Some *)
                US2_0(v16)
        | US2_0(v9) -> (* Some *)
            US2_0(v9)
    let v50 : string = method6()
    let v51 : string = method3(v50)
    let v52 : bool = v51 = "True"
    let v62 : US3 =
        if v52 then
            let v53 : System.DateTime = System.DateTime.Now
            let v56 : (System.DateTime -> int64) = _.Ticks
            let v57 : int64 = v56 v53
            US3_0(v57)
        else
            US3_1
    let _v1 = struct (v49, v62) 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v63 : US2 = US2_1
    let v64 : US3 = US3_1
    let _v1 = struct (v63, v64) 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v65 : string = "AUTOMATION"
    let v66 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v67 : string = "env!(\"" + v65 + "\")"
    let v68 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v67 
    let v69 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v70 : string = "String::from($0)"
    let v71 : std_string_String = Fable.Core.RustInterop.emitRustExpr v68 v70 
    let _v69 = v71 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v72 : string = "String::from($0)"
    let v73 : std_string_String = Fable.Core.RustInterop.emitRustExpr v68 v72 
    let _v69 = v73 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v74 : string = "String::from($0)"
    let v75 : std_string_String = Fable.Core.RustInterop.emitRustExpr v68 v74 
    let _v69 = v75 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v76 : std_string_String = v68 |> unbox<std_string_String>
    let _v69 = v76 
    #endif
#if FABLE_COMPILER_PYTHON
    let v79 : std_string_String = v68 |> unbox<std_string_String>
    let _v69 = v79 
    #endif
#else
    let v82 : std_string_String = v68 |> unbox<std_string_String>
    let _v69 = v82 
    #endif
    let v85 : std_string_String = _v69 
    let v90 : string = "fable_library_rust::String_::fromString($0)"
    let v91 : string = Fable.Core.RustInterop.emitRustExpr v85 v90 
    let _v66 = v91 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v92 : string = "env!(\"" + v65 + "\")"
    let v93 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v92 
    let v94 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v95 : string = "String::from($0)"
    let v96 : std_string_String = Fable.Core.RustInterop.emitRustExpr v93 v95 
    let _v94 = v96 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v97 : string = "String::from($0)"
    let v98 : std_string_String = Fable.Core.RustInterop.emitRustExpr v93 v97 
    let _v94 = v98 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v99 : string = "String::from($0)"
    let v100 : std_string_String = Fable.Core.RustInterop.emitRustExpr v93 v99 
    let _v94 = v100 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v101 : std_string_String = v93 |> unbox<std_string_String>
    let _v94 = v101 
    #endif
#if FABLE_COMPILER_PYTHON
    let v104 : std_string_String = v93 |> unbox<std_string_String>
    let _v94 = v104 
    #endif
#else
    let v107 : std_string_String = v93 |> unbox<std_string_String>
    let _v94 = v107 
    #endif
    let v110 : std_string_String = _v94 
    let v115 : string = "fable_library_rust::String_::fromString($0)"
    let v116 : string = Fable.Core.RustInterop.emitRustExpr v110 v115 
    let _v66 = v116 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v117 : string = "env!(\"" + v65 + "\")"
    let v118 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v117 
    let v119 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v120 : string = "String::from($0)"
    let v121 : std_string_String = Fable.Core.RustInterop.emitRustExpr v118 v120 
    let _v119 = v121 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v122 : string = "String::from($0)"
    let v123 : std_string_String = Fable.Core.RustInterop.emitRustExpr v118 v122 
    let _v119 = v123 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v124 : string = "String::from($0)"
    let v125 : std_string_String = Fable.Core.RustInterop.emitRustExpr v118 v124 
    let _v119 = v125 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v126 : std_string_String = v118 |> unbox<std_string_String>
    let _v119 = v126 
    #endif
#if FABLE_COMPILER_PYTHON
    let v129 : std_string_String = v118 |> unbox<std_string_String>
    let _v119 = v129 
    #endif
#else
    let v132 : std_string_String = v118 |> unbox<std_string_String>
    let _v119 = v132 
    #endif
    let v135 : std_string_String = _v119 
    let v140 : string = "fable_library_rust::String_::fromString($0)"
    let v141 : string = Fable.Core.RustInterop.emitRustExpr v135 v140 
    let _v66 = v141 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v142 : string = null |> unbox<string>
    let _v66 = v142 
    #endif
#if FABLE_COMPILER_PYTHON
    let v145 : string = null |> unbox<string>
    let _v66 = v145 
    #endif
#else
    let v148 : string = null |> unbox<string>
    let _v66 = v148 
    #endif
    let v151 : string = _v66 
    let v156 : string = "True"
    let v157 : bool = v151 <> v156 
    let v166 : US3 =
        if v157 then
            US3_1
        else
            let v161 : string = $"near_sdk::env::block_timestamp()"
            let v162 : uint64 = Fable.Core.RustInterop.emitRustExpr () v161 
            let v163 : (uint64 -> int64) = int64
            let v164 : int64 = v163 v162
            US3_0(v164)
    let v167 : US2 = US2_1
    let _v1 = struct (v167, v166) 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v168 : string = method2()
    let v169 : string = method3(v168)
    
    
    
    
    
    let v170 : bool = "Verbose" = v169
    let v174 : US2 =
        if v170 then
            let v171 : US0 = US0_0
            US2_0(v171)
        else
            US2_1
    let v215 : US2 =
        match v174 with
        | US2_1 -> (* None *)
            let v177 : bool = "Debug" = v169
            let v181 : US2 =
                if v177 then
                    let v178 : US0 = US0_1
                    US2_0(v178)
                else
                    US2_1
            match v181 with
            | US2_1 -> (* None *)
                let v184 : bool = "Info" = v169
                let v188 : US2 =
                    if v184 then
                        let v185 : US0 = US0_2
                        US2_0(v185)
                    else
                        US2_1
                match v188 with
                | US2_1 -> (* None *)
                    let v191 : bool = "Warning" = v169
                    let v195 : US2 =
                        if v191 then
                            let v192 : US0 = US0_3
                            US2_0(v192)
                        else
                            US2_1
                    match v195 with
                    | US2_1 -> (* None *)
                        let v198 : bool = "Critical" = v169
                        let v202 : US2 =
                            if v198 then
                                let v199 : US0 = US0_4
                                US2_0(v199)
                            else
                                US2_1
                        match v202 with
                        | US2_1 -> (* None *)
                            US2_1
                        | US2_0(v203) -> (* Some *)
                            US2_0(v203)
                    | US2_0(v196) -> (* Some *)
                        US2_0(v196)
                | US2_0(v189) -> (* Some *)
                    US2_0(v189)
            | US2_0(v182) -> (* Some *)
                US2_0(v182)
        | US2_0(v175) -> (* Some *)
            US2_0(v175)
    let v216 : string = method6()
    let v217 : string = method3(v216)
    let v218 : bool = v217 = "True"
    let v228 : US3 =
        if v218 then
            let v219 : System.DateTime = System.DateTime.Now
            let v222 : (System.DateTime -> int64) = _.Ticks
            let v223 : int64 = v222 v219
            US3_0(v223)
        else
            US3_1
    let _v1 = struct (v215, v228) 
    #endif
#if FABLE_COMPILER_PYTHON
    let v229 : string = method2()
    let v230 : string = method3(v229)
    
    
    
    
    
    let v231 : bool = "Verbose" = v230
    let v235 : US2 =
        if v231 then
            let v232 : US0 = US0_0
            US2_0(v232)
        else
            US2_1
    let v276 : US2 =
        match v235 with
        | US2_1 -> (* None *)
            let v238 : bool = "Debug" = v230
            let v242 : US2 =
                if v238 then
                    let v239 : US0 = US0_1
                    US2_0(v239)
                else
                    US2_1
            match v242 with
            | US2_1 -> (* None *)
                let v245 : bool = "Info" = v230
                let v249 : US2 =
                    if v245 then
                        let v246 : US0 = US0_2
                        US2_0(v246)
                    else
                        US2_1
                match v249 with
                | US2_1 -> (* None *)
                    let v252 : bool = "Warning" = v230
                    let v256 : US2 =
                        if v252 then
                            let v253 : US0 = US0_3
                            US2_0(v253)
                        else
                            US2_1
                    match v256 with
                    | US2_1 -> (* None *)
                        let v259 : bool = "Critical" = v230
                        let v263 : US2 =
                            if v259 then
                                let v260 : US0 = US0_4
                                US2_0(v260)
                            else
                                US2_1
                        match v263 with
                        | US2_1 -> (* None *)
                            US2_1
                        | US2_0(v264) -> (* Some *)
                            US2_0(v264)
                    | US2_0(v257) -> (* Some *)
                        US2_0(v257)
                | US2_0(v250) -> (* Some *)
                    US2_0(v250)
            | US2_0(v243) -> (* Some *)
                US2_0(v243)
        | US2_0(v236) -> (* Some *)
            US2_0(v236)
    let v277 : string = method6()
    let v278 : string = method3(v277)
    let v279 : bool = v278 = "True"
    let v289 : US3 =
        if v279 then
            let v280 : System.DateTime = System.DateTime.Now
            let v283 : (System.DateTime -> int64) = _.Ticks
            let v284 : int64 = v283 v280
            US3_0(v284)
        else
            US3_1
    let _v1 = struct (v276, v289) 
    #endif
#else
    let v290 : string = method2()
    let v291 : string = method3(v290)
    
    
    
    
    
    let v292 : bool = "Verbose" = v291
    let v296 : US2 =
        if v292 then
            let v293 : US0 = US0_0
            US2_0(v293)
        else
            US2_1
    let v337 : US2 =
        match v296 with
        | US2_1 -> (* None *)
            let v299 : bool = "Debug" = v291
            let v303 : US2 =
                if v299 then
                    let v300 : US0 = US0_1
                    US2_0(v300)
                else
                    US2_1
            match v303 with
            | US2_1 -> (* None *)
                let v306 : bool = "Info" = v291
                let v310 : US2 =
                    if v306 then
                        let v307 : US0 = US0_2
                        US2_0(v307)
                    else
                        US2_1
                match v310 with
                | US2_1 -> (* None *)
                    let v313 : bool = "Warning" = v291
                    let v317 : US2 =
                        if v313 then
                            let v314 : US0 = US0_3
                            US2_0(v314)
                        else
                            US2_1
                    match v317 with
                    | US2_1 -> (* None *)
                        let v320 : bool = "Critical" = v291
                        let v324 : US2 =
                            if v320 then
                                let v321 : US0 = US0_4
                                US2_0(v321)
                            else
                                US2_1
                        match v324 with
                        | US2_1 -> (* None *)
                            US2_1
                        | US2_0(v325) -> (* Some *)
                            US2_0(v325)
                    | US2_0(v318) -> (* Some *)
                        US2_0(v318)
                | US2_0(v311) -> (* Some *)
                    US2_0(v311)
            | US2_0(v304) -> (* Some *)
                US2_0(v304)
        | US2_0(v297) -> (* Some *)
            US2_0(v297)
    let v338 : string = method6()
    let v339 : string = method3(v338)
    let v340 : bool = v339 = "True"
    let v350 : US3 =
        if v340 then
            let v341 : System.DateTime = System.DateTime.Now
            let v344 : (System.DateTime -> int64) = _.Ticks
            let v345 : int64 = v344 v341
            US3_0(v345)
        else
            US3_1
    let _v1 = struct (v337, v350) 
    #endif
    let struct (v351 : US2, v352 : US3) = _v1 
    let v416 : Mut0 = {l0 = 1L} : Mut0
    let v417 : (string -> unit) = closure4()
    let v418 : Mut1 = {l0 = v417} : Mut1
    let v419 : Mut2 = {l0 = true} : Mut2
    let v420 : string = ""
    let v421 : Mut3 = {l0 = v420} : Mut3
    let v424 : US0 =
        match v351 with
        | US2_1 -> (* None *)
            v0
        | US2_0(v422) -> (* Some *)
            v422
    let v425 : Mut4 = {l0 = v424} : Mut4
    let v432 : int64 option =
        match v352 with
        | US3_1 -> (* None *)
            let v430 : int64 option = None
            v430
        | US3_0(v426) -> (* Some *)
            let v427 : int64 option = Some v426 
            v427
    struct (v416, v418, v419, v421, v425, v432)
and closure2 () () : unit =
    let v0 : bool = TraceState.trace_state.IsNone
    if v0 then
        let v1 : US0 = US0_2
        let struct (v2 : Mut0, v3 : Mut1, v4 : Mut2, v5 : Mut3, v6 : Mut4, v7 : int64 option) = method1(v1)
        let v8 : struct (Mut0 * Mut1 * Mut2 * Mut3 * Mut4 * int64 option) option = Some struct (v2, v3, v4, v5, v6, v7) 
        TraceState.trace_state <- v8 
        ()
and closure6 () () : unit =
    let v0 : bool = TraceState.trace_state.IsNone
    if v0 then
        let v1 : US0 = US0_0
        let struct (v2 : Mut0, v3 : Mut1, v4 : Mut2, v5 : Mut3, v6 : Mut4, v7 : int64 option) = method1(v1)
        let v8 : struct (Mut0 * Mut1 * Mut2 * Mut3 * Mut4 * int64 option) option = Some struct (v2, v3, v4, v5, v6, v7) 
        TraceState.trace_state <- v8 
        ()
and method7 (v0 : US0) : bool =
    let v1 : unit = ()
    let v2 : (unit -> unit) = closure6()
    let v3 : unit = (fun () -> v2 (); v1) ()
    let struct (v17 : Mut0, v18 : Mut1, v19 : Mut2, v20 : Mut3, v21 : Mut4, v22 : int64 option) = TraceState.trace_state.Value
    let v35 : US0 = v21.l0
    let v36 : bool = v19.l0
    let v37 : bool = v36 = false
    if v37 then
        false
    else
        let v38 : int32 = [ US0_0, 0; US0_1, 1; US0_2, 2; US0_3, 3; US0_4, 4 ] |> Map |> Map.find v0
        let v39 : int32 = [ US0_0, 0; US0_1, 1; US0_2, 2; US0_3, 3; US0_4, 4 ] |> Map |> Map.find v35
        let v40 : bool = v38 >= v39
        v40
and closure7 () (v0 : int64) : US3 =
    US3_0(v0)
and method9 () : (int64 -> US3) =
    closure7()
and method10 () : string =
    let v0 : string = "hh:mm:ss"
    v0
and method11 () : string =
    let v0 : string = "HH:mm:ss"
    v0
and method8 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option) : string =
    let v6 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v7 : (int64 -> US3) = method9()
    let v8 : US3 option = v5 |> Option.map v7 
    let v19 : US3 = US3_1
    let v20 : US3 = v8 |> Option.defaultValue v19 
    let v60 : System.DateTime =
        match v20 with
        | US3_1 -> (* None *)
            let v56 : System.DateTime = System.DateTime.Now
            v56
        | US3_0(v24) -> (* Some *)
            let v25 : System.DateTime = System.DateTime.Now
            let v28 : (System.DateTime -> int64) = _.Ticks
            let v29 : int64 = v28 v25
            let v32 : int64 = v29 - v24
            let v33 : (int64 -> System.TimeSpan) = System.TimeSpan 
            let v34 : System.TimeSpan = v33 v32
            let v37 : (System.TimeSpan -> int32) = _.Hours
            let v38 : int32 = v37 v34
            let v41 : (System.TimeSpan -> int32) = _.Minutes
            let v42 : int32 = v41 v34
            let v45 : (System.TimeSpan -> int32) = _.Seconds
            let v46 : int32 = v45 v34
            let v49 : (System.TimeSpan -> int32) = _.Milliseconds
            let v50 : int32 = v49 v34
            let v53 : System.DateTime = System.DateTime (1, 1, 1, v38, v42, v46, v50)
            v53
    let v61 : string = method10()
    let v64 : (string -> string) = v60.ToString
    let v65 : string = v64 v61
    let _v6 = v65 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v68 : (int64 -> US3) = method9()
    let v69 : US3 option = v5 |> Option.map v68 
    let v80 : US3 = US3_1
    let v81 : US3 = v69 |> Option.defaultValue v80 
    let v121 : System.DateTime =
        match v81 with
        | US3_1 -> (* None *)
            let v117 : System.DateTime = System.DateTime.Now
            v117
        | US3_0(v85) -> (* Some *)
            let v86 : System.DateTime = System.DateTime.Now
            let v89 : (System.DateTime -> int64) = _.Ticks
            let v90 : int64 = v89 v86
            let v93 : int64 = v90 - v85
            let v94 : (int64 -> System.TimeSpan) = System.TimeSpan 
            let v95 : System.TimeSpan = v94 v93
            let v98 : (System.TimeSpan -> int32) = _.Hours
            let v99 : int32 = v98 v95
            let v102 : (System.TimeSpan -> int32) = _.Minutes
            let v103 : int32 = v102 v95
            let v106 : (System.TimeSpan -> int32) = _.Seconds
            let v107 : int32 = v106 v95
            let v110 : (System.TimeSpan -> int32) = _.Milliseconds
            let v111 : int32 = v110 v95
            let v114 : System.DateTime = System.DateTime (1, 1, 1, v99, v103, v107, v111)
            v114
    let v122 : string = method10()
    let v125 : (string -> string) = v121.ToString
    let v126 : string = v125 v122
    let _v6 = v126 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v129 : string = $"near_sdk::env::block_timestamp()"
    let v130 : uint64 = Fable.Core.RustInterop.emitRustExpr () v129 
    let v131 : (int64 -> US3) = method9()
    let v132 : US3 option = v5 |> Option.map v131 
    let v143 : US3 = US3_1
    let v144 : US3 = v132 |> Option.defaultValue v143 
    let v153 : uint64 =
        match v144 with
        | US3_1 -> (* None *)
            v130
        | US3_0(v148) -> (* Some *)
            let v149 : (int64 -> uint64) = uint64
            let v150 : uint64 = v149 v148
            let v151 : uint64 = v130 - v150
            v151
    let v154 : uint64 = v153 / 1000000000UL
    let v155 : uint64 = v154 % 60UL
    let v156 : uint64 = v154 / 60UL
    let v157 : uint64 = v156 % 60UL
    let v158 : uint64 = v154 / 3600UL
    let v159 : uint64 = v158 % 24UL
    let v160 : string = $"format!(\"{{:02}}:{{:02}}:{{:02}}\", $0, $1, $2)"
    let v161 : std_string_String = Fable.Core.RustInterop.emitRustExpr struct (v159, v157, v155) v160 
    let v162 : string = "fable_library_rust::String_::fromString($0)"
    let v163 : string = Fable.Core.RustInterop.emitRustExpr v161 v162 
    let _v6 = v163 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v164 : (int64 -> US3) = method9()
    let v165 : US3 option = v5 |> Option.map v164 
    let v176 : US3 = US3_1
    let v177 : US3 = v165 |> Option.defaultValue v176 
    let v217 : System.DateTime =
        match v177 with
        | US3_1 -> (* None *)
            let v213 : System.DateTime = System.DateTime.Now
            v213
        | US3_0(v181) -> (* Some *)
            let v182 : System.DateTime = System.DateTime.Now
            let v185 : (System.DateTime -> int64) = _.Ticks
            let v186 : int64 = v185 v182
            let v189 : int64 = v186 - v181
            let v190 : (int64 -> System.TimeSpan) = System.TimeSpan 
            let v191 : System.TimeSpan = v190 v189
            let v194 : (System.TimeSpan -> int32) = _.Hours
            let v195 : int32 = v194 v191
            let v198 : (System.TimeSpan -> int32) = _.Minutes
            let v199 : int32 = v198 v191
            let v202 : (System.TimeSpan -> int32) = _.Seconds
            let v203 : int32 = v202 v191
            let v206 : (System.TimeSpan -> int32) = _.Milliseconds
            let v207 : int32 = v206 v191
            let v210 : System.DateTime = System.DateTime (1, 1, 1, v195, v199, v203, v207)
            v210
    let v218 : string = method11()
    let v221 : (string -> string) = v217.ToString
    let v222 : string = v221 v218
    let _v6 = v222 
    #endif
#if FABLE_COMPILER_PYTHON
    let v225 : (int64 -> US3) = method9()
    let v226 : US3 option = v5 |> Option.map v225 
    let v237 : US3 = US3_1
    let v238 : US3 = v226 |> Option.defaultValue v237 
    let v278 : System.DateTime =
        match v238 with
        | US3_1 -> (* None *)
            let v274 : System.DateTime = System.DateTime.Now
            v274
        | US3_0(v242) -> (* Some *)
            let v243 : System.DateTime = System.DateTime.Now
            let v246 : (System.DateTime -> int64) = _.Ticks
            let v247 : int64 = v246 v243
            let v250 : int64 = v247 - v242
            let v251 : (int64 -> System.TimeSpan) = System.TimeSpan 
            let v252 : System.TimeSpan = v251 v250
            let v255 : (System.TimeSpan -> int32) = _.Hours
            let v256 : int32 = v255 v252
            let v259 : (System.TimeSpan -> int32) = _.Minutes
            let v260 : int32 = v259 v252
            let v263 : (System.TimeSpan -> int32) = _.Seconds
            let v264 : int32 = v263 v252
            let v267 : (System.TimeSpan -> int32) = _.Milliseconds
            let v268 : int32 = v267 v252
            let v271 : System.DateTime = System.DateTime (1, 1, 1, v256, v260, v264, v268)
            v271
    let v279 : string = method11()
    let v282 : (string -> string) = v278.ToString
    let v283 : string = v282 v279
    let _v6 = v283 
    #endif
#else
    let v286 : (int64 -> US3) = method9()
    let v287 : US3 option = v5 |> Option.map v286 
    let v298 : US3 = US3_1
    let v299 : US3 = v287 |> Option.defaultValue v298 
    let v339 : System.DateTime =
        match v299 with
        | US3_1 -> (* None *)
            let v335 : System.DateTime = System.DateTime.Now
            v335
        | US3_0(v303) -> (* Some *)
            let v304 : System.DateTime = System.DateTime.Now
            let v307 : (System.DateTime -> int64) = _.Ticks
            let v308 : int64 = v307 v304
            let v311 : int64 = v308 - v303
            let v312 : (int64 -> System.TimeSpan) = System.TimeSpan 
            let v313 : System.TimeSpan = v312 v311
            let v316 : (System.TimeSpan -> int32) = _.Hours
            let v317 : int32 = v316 v313
            let v320 : (System.TimeSpan -> int32) = _.Minutes
            let v321 : int32 = v320 v313
            let v324 : (System.TimeSpan -> int32) = _.Seconds
            let v325 : int32 = v324 v313
            let v328 : (System.TimeSpan -> int32) = _.Milliseconds
            let v329 : int32 = v328 v313
            let v332 : System.DateTime = System.DateTime (1, 1, 1, v317, v321, v325, v329)
            v332
    let v340 : string = method11()
    let v343 : (string -> string) = v339.ToString
    let v344 : string = v343 v340
    let _v6 = v344 
    #endif
    let v347 : string = _v6 
    v347
and method14 () : string =
    let v0 : string = ""
    v0
and closure8 (v0 : Mut3, v1 : string) () : unit =
    let v2 : string = v0.l0
    let v3 : string = v2 + v1 
    v0.l0 <- v3
    ()
and method13 (v0 : char) : string =
    let v1 : string = method14()
    let v2 : Mut3 = {l0 = v1} : Mut3
    let v3 : string = $"{v0}"
    let v6 : unit = ()
    let v7 : (unit -> unit) = closure8(v2, v3)
    let v8 : unit = (fun () -> v7 (); v6) ()
    let v11 : string = v2.l0
    v11
and method15 () : string =
    let v0 : string = "\u001b[0m"
    v0
and method12 () : string =
    
    
    
    
    
    let v0 : string = "Info"
    let v1 : (unit -> string) = v0.ToLower
    let v2 : string = v1 ()
    let v5 : char = v2.[int 0]
    let v6 : string = method13(v5)
    let v7 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v8 : string = "inline_colorization::color_bright_green"
    let v9 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v8 
    let v10 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v11 : string = "&*$0"
    let v12 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v11 
    let _v10 = v12 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v13 : string = "&*$0"
    let v14 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v13 
    let _v10 = v14 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v15 : string = "&*$0"
    let v16 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v15 
    let _v10 = v16 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v17 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v10 = v17 
    #endif
#if FABLE_COMPILER_PYTHON
    let v20 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v10 = v20 
    #endif
#else
    let v23 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v10 = v23 
    #endif
    let v26 : Ref<Str> = _v10 
    let v31 : string = "inline_colorization::color_reset"
    let v32 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v31 
    let v33 : string = $"format!(\"{{}}{{}}{{}}\", $0, $1, $2)"
    let v34 : std_string_String = Fable.Core.RustInterop.emitRustExpr struct (v9, v26, v32) v33 
    let v35 : string = "fable_library_rust::String_::fromString($0)"
    let v36 : string = Fable.Core.RustInterop.emitRustExpr v34 v35 
    let _v7 = v36 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v37 : string = "inline_colorization::color_bright_green"
    let v38 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v37 
    let v39 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v40 : string = "&*$0"
    let v41 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v40 
    let _v39 = v41 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v42 : string = "&*$0"
    let v43 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v42 
    let _v39 = v43 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v44 : string = "&*$0"
    let v45 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v44 
    let _v39 = v45 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v46 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v39 = v46 
    #endif
#if FABLE_COMPILER_PYTHON
    let v49 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v39 = v49 
    #endif
#else
    let v52 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v39 = v52 
    #endif
    let v55 : Ref<Str> = _v39 
    let v60 : string = "inline_colorization::color_reset"
    let v61 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v60 
    let v62 : string = $"format!(\"{{}}{{}}{{}}\", $0, $1, $2)"
    let v63 : std_string_String = Fable.Core.RustInterop.emitRustExpr struct (v38, v55, v61) v62 
    let v64 : string = "fable_library_rust::String_::fromString($0)"
    let v65 : string = Fable.Core.RustInterop.emitRustExpr v63 v64 
    let _v7 = v65 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v66 : string = "inline_colorization::color_bright_green"
    let v67 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v66 
    let v68 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v69 : string = "&*$0"
    let v70 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v69 
    let _v68 = v70 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v71 : string = "&*$0"
    let v72 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v71 
    let _v68 = v72 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v73 : string = "&*$0"
    let v74 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v73 
    let _v68 = v74 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v75 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v68 = v75 
    #endif
#if FABLE_COMPILER_PYTHON
    let v78 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v68 = v78 
    #endif
#else
    let v81 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v68 = v81 
    #endif
    let v84 : Ref<Str> = _v68 
    let v89 : string = "inline_colorization::color_reset"
    let v90 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v89 
    let v91 : string = $"format!(\"{{}}{{}}{{}}\", $0, $1, $2)"
    let v92 : std_string_String = Fable.Core.RustInterop.emitRustExpr struct (v67, v84, v90) v91 
    let v93 : string = "fable_library_rust::String_::fromString($0)"
    let v94 : string = Fable.Core.RustInterop.emitRustExpr v92 v93 
    let _v7 = v94 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v95 : string = "\u001b[92m"
    let v96 : string = method15()
    let v97 : string = v95 + v6 
    let v98 : string = v97 + v96 
    let _v7 = v98 
    #endif
#if FABLE_COMPILER_PYTHON
    let v99 : string = "\u001b[92m"
    let v100 : string = method15()
    let v101 : string = v99 + v6 
    let v102 : string = v101 + v100 
    let _v7 = v102 
    #endif
#else
    let v103 : string = "\u001b[92m"
    let v104 : string = method15()
    let v105 : string = v103 + v6 
    let v106 : string = v105 + v104 
    let _v7 = v106 
    #endif
    let v107 : string = _v7 
    v107
and method17 (v0 : (string [])) : string =
    let v1 : string = method14()
    let v2 : Mut3 = {l0 = v1} : Mut3
    let v3 : string = "{ "
    let v4 : string = $"{v3}"
    let v7 : unit = ()
    let v8 : (unit -> unit) = closure8(v2, v4)
    let v9 : unit = (fun () -> v8 (); v7) ()
    let v12 : string = "args"
    let v13 : string = $"{v12}"
    let v16 : unit = ()
    let v17 : (unit -> unit) = closure8(v2, v13)
    let v18 : unit = (fun () -> v17 (); v16) ()
    let v21 : string = " = "
    let v22 : string = $"{v21}"
    let v25 : unit = ()
    let v26 : (unit -> unit) = closure8(v2, v22)
    let v27 : unit = (fun () -> v26 (); v25) ()
    let v30 : string = $"%A{v0}"
    let v33 : string = $"{v30}"
    let v36 : unit = ()
    let v37 : (unit -> unit) = closure8(v2, v33)
    let v38 : unit = (fun () -> v37 (); v36) ()
    let v41 : string = " }"
    let v42 : string = $"{v41}"
    let v45 : unit = ()
    let v46 : (unit -> unit) = closure8(v2, v42)
    let v47 : unit = (fun () -> v46 (); v45) ()
    let v50 : string = v2.l0
    v50
and method18 (v0 : string) : string =
    let v1 : char list = []
    let v2 : (char list -> (char [])) = List.toArray
    let v3 : (char []) = v2 v1
    let v6 : string = v0.TrimStart v3 
    let v24 : char list = []
    let v25 : char list = '/' :: v24 
    let v28 : char list = ' ' :: v25 
    let v31 : (char list -> (char [])) = List.toArray
    let v32 : (char []) = v31 v28
    let v35 : string = v6.TrimEnd v32 
    v35
and method16 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : (string [])) : string =
    let v9 : string = method17(v8)
    let v10 : int64 = v0.l0
    let v11 : string = "documents.main"
    let v12 : string = $"{v6} {v7} #{v10} %s{v11} / {v9}"
    method18(v12)
and closure9 (v0 : Mut0) () : unit =
    let v1 : int64 = v0.l0
    let v2 : int64 = v1 + 1L
    v0.l0 <- v2
    ()
and closure11 (v0 : string) () : unit =
    let v1 : (string -> unit) = System.Console.WriteLine
    v1 v0
and closure10 () (v0 : string) : unit =
    let v1 : unit = ()
    let v2 : (unit -> unit) = closure11(v0)
    let v3 : unit = (fun () -> v2 (); v1) ()
    ()
and method19 (v0 : string) : unit =
    let v1 : unit = ()
    let v2 : (unit -> unit) = closure6()
    let v3 : unit = (fun () -> v2 (); v1) ()
    let struct (v17 : Mut0, v18 : Mut1, v19 : Mut2, v20 : Mut3, v21 : Mut4, v22 : int64 option) = TraceState.trace_state.Value
    let v35 : unit = ()
    let v36 : (unit -> unit) = closure9(v17)
    let v37 : unit = (fun () -> v36 (); v35) ()
    let v40 : (string -> unit) = closure10()
    let v41 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v42 : string = @"println!(""{}"", $0)"
    Fable.Core.RustInterop.emitRustExpr v0 v42 
    let _v41 = () 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v43 : string = @"println!(""{}"", $0)"
    Fable.Core.RustInterop.emitRustExpr v0 v43 
    let _v41 = () 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v44 : string = v20.l0
    let v45 : bool = v44 = ""
    let v53 : string =
        if v45 then
            v0
        else
            let v46 : bool = v0 = ""
            if v46 then
                let v47 : string = v20.l0
                v47
            else
                let v48 : string = v20.l0
                let v49 : string = "\n"
                let v50 : string = v48 + v49 
                let v51 : string = v50 + v0 
                v51
    let v54 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v55 : string = "&*$0"
    let v56 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v53 v55 
    let _v54 = v56 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v57 : string = "&*$0"
    let v58 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v53 v57 
    let _v54 = v58 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v59 : string = "&*$0"
    let v60 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v53 v59 
    let _v54 = v60 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v61 : Ref<Str> = v53 |> unbox<Ref<Str>>
    let _v54 = v61 
    #endif
#if FABLE_COMPILER_PYTHON
    let v64 : Ref<Str> = v53 |> unbox<Ref<Str>>
    let _v54 = v64 
    #endif
#else
    let v67 : Ref<Str> = v53 |> unbox<Ref<Str>>
    let _v54 = v67 
    #endif
    let v70 : Ref<Str> = _v54 
    let v75 : string = $"$0.chars()"
    let v76 : Mut<_> = Fable.Core.RustInterop.emitRustExpr v70 v75 
    let v77 : string = "$0"
    let v78 : _ = Fable.Core.RustInterop.emitRustExpr v76 v77 
    let v79 : string = "$0.collect::<Vec<_>>()"
    let v80 : Vec<char> = Fable.Core.RustInterop.emitRustExpr v78 v79 
    let v81 : string = "$0.chunks(15000).map(|x| x.into_iter().map(|x| x.clone()).collect::<Vec<_>>()).collect::<Vec<_>>()"
    let v82 : Vec<Vec<char>> = Fable.Core.RustInterop.emitRustExpr v80 v81 
    let v83 : string = "true; let _vec_map : Vec<_> = $0.into_iter().map(|x| { //"
    let v84 : bool = Fable.Core.RustInterop.emitRustExpr v82 v83 
    let v85 : string = "x"
    let v86 : Vec<char> = Fable.Core.RustInterop.emitRustExpr () v85 
    let v87 : string = "String::from_iter($0)"
    let v88 : std_string_String = Fable.Core.RustInterop.emitRustExpr v86 v87 
    let v89 : string = "true; $0 }).collect::<Vec<_>>()"
    let v90 : bool = Fable.Core.RustInterop.emitRustExpr v88 v89 
    let v91 : string = "_vec_map"
    let v92 : Vec<std_string_String> = Fable.Core.RustInterop.emitRustExpr () v91 
    let v93 : string = "$0.len()"
    let v94 : unativeint = Fable.Core.RustInterop.emitRustExpr v92 v93 
    let v95 : (unativeint -> int32) = int32
    let v96 : int32 = v95 v94
    let v97 : string = ""
    let v98 : bool = v0 <> v97 
    let v102 : bool =
        if v98 then
            let v101 : bool = v96 <= 1
            v101
        else
            false
    if v102 then
        v20.l0 <- v53
        ()
    else
        v20.l0 <- v97
        let v103 : string = "true; $0.into_iter().for_each(|x| { //"
        let v104 : bool = Fable.Core.RustInterop.emitRustExpr v92 v103 
        let v105 : string = "x"
        let v106 : std_string_String = Fable.Core.RustInterop.emitRustExpr () v105 
        let v107 : string = $"true; near_sdk::log!(\"{{}}\", $0)"
        let v108 : bool = Fable.Core.RustInterop.emitRustExpr v106 v107 
        let v109 : string = $"true"
        let v110 : bool = Fable.Core.RustInterop.emitRustExpr () v109 
        let v111 : string = "true; }); //"
        let v112 : bool = Fable.Core.RustInterop.emitRustExpr () v111 
        ()
    let _v41 = () 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    v40 v0
    let _v41 = () 
    #endif
#if FABLE_COMPILER_PYTHON
    v40 v0
    let _v41 = () 
    #endif
#else
    v40 v0
    let _v41 = () 
    #endif
    _v41 
    let v113 : (string -> unit) = v18.l0
    v113 v0
and closure5 (v0 : (string [])) () : unit =
    let v1 : US0 = US0_2
    let v2 : bool = method7(v1)
    if v2 then
        let v3 : unit = ()
        let v4 : (unit -> unit) = closure6()
        let v5 : unit = (fun () -> v4 (); v3) ()
        let struct (v19 : Mut0, v20 : Mut1, v21 : Mut2, v22 : Mut3, v23 : Mut4, v24 : int64 option) = TraceState.trace_state.Value
        let v37 : string = method8(v19, v20, v21, v22, v23, v24)
        let v38 : string = method12()
        let v39 : string = method16(v19, v20, v21, v22, v23, v24, v37, v38, v0)
        method19(v39)
and method20 () : string =
    let v0 : string = "source-dir"
    v0
and closure12 () (v0 : std_string_String) : US4 =
    US4_0(v0)
and method21 () : (std_string_String -> US4) =
    closure12()
and method22 () : string =
    let v0 : string = "dist-dir"
    v0
and method23 () : string =
    let v0 : string = "cache-dir"
    v0
and method24 () : string =
    let v0 : string = "hangul-spec"
    v0
and method28 (v0 : string) : string =
    v0
and method27 (v0 : string, v1 : string) : struct (string * string) =
    let v2 : string = method28(v0)
    struct (v1, v2)
and method26 (v0 : string, v1 : string) : string =
    let v2 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v3 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v4 : string = "&*$0"
    let v5 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v0 v4 
    let _v3 = v5 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v6 : string = "&*$0"
    let v7 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v0 v6 
    let _v3 = v7 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v8 : string = "&*$0"
    let v9 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v0 v8 
    let _v3 = v9 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v10 : Ref<Str> = v0 |> unbox<Ref<Str>>
    let _v3 = v10 
    #endif
#if FABLE_COMPILER_PYTHON
    let v13 : Ref<Str> = v0 |> unbox<Ref<Str>>
    let _v3 = v13 
    #endif
#else
    let v16 : Ref<Str> = v0 |> unbox<Ref<Str>>
    let _v3 = v16 
    #endif
    let v19 : Ref<Str> = _v3 
    let v24 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v25 : string = "String::from($0)"
    let v26 : std_string_String = Fable.Core.RustInterop.emitRustExpr v19 v25 
    let _v24 = v26 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v27 : string = "String::from($0)"
    let v28 : std_string_String = Fable.Core.RustInterop.emitRustExpr v19 v27 
    let _v24 = v28 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v29 : string = "String::from($0)"
    let v30 : std_string_String = Fable.Core.RustInterop.emitRustExpr v19 v29 
    let _v24 = v30 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v31 : std_string_String = v19 |> unbox<std_string_String>
    let _v24 = v31 
    #endif
#if FABLE_COMPILER_PYTHON
    let v34 : std_string_String = v19 |> unbox<std_string_String>
    let _v24 = v34 
    #endif
#else
    let v37 : std_string_String = v19 |> unbox<std_string_String>
    let _v24 = v37 
    #endif
    let v40 : std_string_String = _v24 
    let v45 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v46 : string = "std::path::PathBuf::from($0)"
    let v47 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v40 v46 
    let _v45 = v47 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v48 : string = "std::path::PathBuf::from($0)"
    let v49 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v40 v48 
    let _v45 = v49 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v50 : string = "std::path::PathBuf::from($0)"
    let v51 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v40 v50 
    let _v45 = v51 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v52 : std_path_PathBuf = v40 |> std_path_PathBuf 
    let _v45 = v52 
    #endif
#if FABLE_COMPILER_PYTHON
    let v55 : std_path_PathBuf = v40 |> std_path_PathBuf 
    let _v45 = v55 
    #endif
#else
    let v58 : std_path_PathBuf = v40 |> std_path_PathBuf 
    let _v45 = v58 
    #endif
    let v61 : std_path_PathBuf = _v45 
    let v66 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v67 : string = "&*$0"
    let v68 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1 v67 
    let _v66 = v68 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v69 : string = "&*$0"
    let v70 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1 v69 
    let _v66 = v70 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v71 : string = "&*$0"
    let v72 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1 v71 
    let _v66 = v72 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v73 : Ref<Str> = v1 |> unbox<Ref<Str>>
    let _v66 = v73 
    #endif
#if FABLE_COMPILER_PYTHON
    let v76 : Ref<Str> = v1 |> unbox<Ref<Str>>
    let _v66 = v76 
    #endif
#else
    let v79 : Ref<Str> = v1 |> unbox<Ref<Str>>
    let _v66 = v79 
    #endif
    let v82 : Ref<Str> = _v66 
    let v87 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v88 : string = "String::from($0)"
    let v89 : std_string_String = Fable.Core.RustInterop.emitRustExpr v82 v88 
    let _v87 = v89 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v90 : string = "String::from($0)"
    let v91 : std_string_String = Fable.Core.RustInterop.emitRustExpr v82 v90 
    let _v87 = v91 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v92 : string = "String::from($0)"
    let v93 : std_string_String = Fable.Core.RustInterop.emitRustExpr v82 v92 
    let _v87 = v93 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v94 : std_string_String = v82 |> unbox<std_string_String>
    let _v87 = v94 
    #endif
#if FABLE_COMPILER_PYTHON
    let v97 : std_string_String = v82 |> unbox<std_string_String>
    let _v87 = v97 
    #endif
#else
    let v100 : std_string_String = v82 |> unbox<std_string_String>
    let _v87 = v100 
    #endif
    let v103 : std_string_String = _v87 
    let v108 : string = "$0.join($1)"
    let v109 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr struct (v61, v103) v108 
    let v110 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v111 : string = "$0.display()"
    let v112 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v109 v111 
    let _v110 = v112 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v113 : string = "$0.display()"
    let v114 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v109 v113 
    let _v110 = v114 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v115 : string = "$0.display()"
    let v116 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v109 v115 
    let _v110 = v116 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v117 : std_path_Display = v109 |> unbox<std_path_Display>
    let _v110 = v117 
    #endif
#if FABLE_COMPILER_PYTHON
    let v120 : std_path_Display = v109 |> unbox<std_path_Display>
    let _v110 = v120 
    #endif
#else
    let v123 : std_path_Display = v109 |> unbox<std_path_Display>
    let _v110 = v123 
    #endif
    let v126 : std_path_Display = _v110 
    let v131 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v132 : string = "format!(\"{}\", $0)"
    let v133 : std_string_String = Fable.Core.RustInterop.emitRustExpr v126 v132 
    let _v131 = v133 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v134 : string = "format!(\"{}\", $0)"
    let v135 : std_string_String = Fable.Core.RustInterop.emitRustExpr v126 v134 
    let _v131 = v135 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v136 : string = "format!(\"{}\", $0)"
    let v137 : std_string_String = Fable.Core.RustInterop.emitRustExpr v126 v136 
    let _v131 = v137 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v138 : std_string_String = null |> unbox<std_string_String>
    let _v131 = v138 
    #endif
#if FABLE_COMPILER_PYTHON
    let v141 : std_string_String = null |> unbox<std_string_String>
    let _v131 = v141 
    #endif
#else
    let v144 : std_string_String = null |> unbox<std_string_String>
    let _v131 = v144 
    #endif
    let v147 : std_string_String = _v131 
    let v152 : string = "fable_library_rust::String_::fromString($0)"
    let v153 : string = Fable.Core.RustInterop.emitRustExpr v147 v152 
    let _v2 = v153 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v154 : US5 = US5_1
    let v155 : US6 = US6_2(v154)
    let v156 : string = $"file_system.(</>) / target: {v155} / a: {v0} / b: {v1}"
    let v157 : string = failwith<string> v156
    let _v2 = v157 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v158 : string = null |> unbox<string>
    let _v2 = v158 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v161 : string = "path"
    let v162 : IPathJoin = Fable.Core.JsInterop.importAll v161 
    let struct (v163 : string, v164 : string) = method27(v1, v0)
    let v165 : string = "v162.join($0, $1)"
    let v166 : string = Fable.Core.JsInterop.emitJsExpr struct (v163, v164) v165 
    let _v2 = v166 
    #endif
#if FABLE_COMPILER_PYTHON
    let v167 : US5 = US5_0
    let v168 : US6 = US6_4(v167)
    let v169 : string = $"file_system.(</>) / target: {v168} / a: {v0} / b: {v1}"
    let v170 : string = failwith<string> v169
    let _v2 = v170 
    #endif
#else
    let v171 : string = System.IO.Path.Combine (v0, v1)
    let _v2 = v171 
    #endif
    let v172 : string = _v2 
    v172
and method30 (v0 : string) : bool =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v3 : string = "&*$0"
    let v4 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v0 v3 
    let _v2 = v4 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v5 : string = "&*$0"
    let v6 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v0 v5 
    let _v2 = v6 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v7 : string = "&*$0"
    let v8 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v0 v7 
    let _v2 = v8 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v9 : Ref<Str> = v0 |> unbox<Ref<Str>>
    let _v2 = v9 
    #endif
#if FABLE_COMPILER_PYTHON
    let v12 : Ref<Str> = v0 |> unbox<Ref<Str>>
    let _v2 = v12 
    #endif
#else
    let v15 : Ref<Str> = v0 |> unbox<Ref<Str>>
    let _v2 = v15 
    #endif
    let v18 : Ref<Str> = _v2 
    let v23 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v24 : string = "String::from($0)"
    let v25 : std_string_String = Fable.Core.RustInterop.emitRustExpr v18 v24 
    let _v23 = v25 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v26 : string = "String::from($0)"
    let v27 : std_string_String = Fable.Core.RustInterop.emitRustExpr v18 v26 
    let _v23 = v27 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v28 : string = "String::from($0)"
    let v29 : std_string_String = Fable.Core.RustInterop.emitRustExpr v18 v28 
    let _v23 = v29 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v30 : std_string_String = v18 |> unbox<std_string_String>
    let _v23 = v30 
    #endif
#if FABLE_COMPILER_PYTHON
    let v33 : std_string_String = v18 |> unbox<std_string_String>
    let _v23 = v33 
    #endif
#else
    let v36 : std_string_String = v18 |> unbox<std_string_String>
    let _v23 = v36 
    #endif
    let v39 : std_string_String = _v23 
    let v44 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v45 : string = "std::path::PathBuf::from($0)"
    let v46 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v39 v45 
    let _v44 = v46 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v47 : string = "std::path::PathBuf::from($0)"
    let v48 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v39 v47 
    let _v44 = v48 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v49 : string = "std::path::PathBuf::from($0)"
    let v50 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v39 v49 
    let _v44 = v50 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v51 : std_path_PathBuf = v39 |> std_path_PathBuf 
    let _v44 = v51 
    #endif
#if FABLE_COMPILER_PYTHON
    let v54 : std_path_PathBuf = v39 |> std_path_PathBuf 
    let _v44 = v54 
    #endif
#else
    let v57 : std_path_PathBuf = v39 |> std_path_PathBuf 
    let _v44 = v57 
    #endif
    let v60 : std_path_PathBuf = _v44 
    let v65 : string = "$0.exists()"
    let v66 : bool = Fable.Core.RustInterop.emitRustExpr v60 v65 
    let v69 : bool =
        if v66 then
            let v67 : string = "$0.is_dir()"
            let v68 : bool = Fable.Core.RustInterop.emitRustExpr v60 v67 
            v68
        else
            false
    let _v1 = v69 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v70 : bool = null |> unbox<bool>
    let _v1 = v70 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v73 : bool = null |> unbox<bool>
    let _v1 = v73 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v76 : string = "fs"
    let v77 : IFsExistsSync = Fable.Core.JsInterop.importAll v76 
    let v78 : string = "$0.existsSync($1)"
    let v79 : bool = Fable.Core.JsInterop.emitJsExpr struct (v77, v0) v78 
    let _v1 = v79 
    #endif
#if FABLE_COMPILER_PYTHON
    let v80 : bool = null |> unbox<bool>
    let _v1 = v80 
    #endif
#else
    let v83 : (string -> bool) = System.IO.Directory.Exists
    let v84 : bool = v83 v0
    let _v1 = v84 
    #endif
    let v85 : bool = _v1 
    v85
and method33 (v0 : string) : string =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v3 : string = "&*$0"
    let v4 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v0 v3 
    let _v2 = v4 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v5 : string = "&*$0"
    let v6 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v0 v5 
    let _v2 = v6 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v7 : string = "&*$0"
    let v8 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v0 v7 
    let _v2 = v8 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v9 : Ref<Str> = v0 |> unbox<Ref<Str>>
    let _v2 = v9 
    #endif
#if FABLE_COMPILER_PYTHON
    let v12 : Ref<Str> = v0 |> unbox<Ref<Str>>
    let _v2 = v12 
    #endif
#else
    let v15 : Ref<Str> = v0 |> unbox<Ref<Str>>
    let _v2 = v15 
    #endif
    let v18 : Ref<Str> = _v2 
    let v23 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v24 : string = "String::from($0)"
    let v25 : std_string_String = Fable.Core.RustInterop.emitRustExpr v18 v24 
    let _v23 = v25 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v26 : string = "String::from($0)"
    let v27 : std_string_String = Fable.Core.RustInterop.emitRustExpr v18 v26 
    let _v23 = v27 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v28 : string = "String::from($0)"
    let v29 : std_string_String = Fable.Core.RustInterop.emitRustExpr v18 v28 
    let _v23 = v29 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v30 : std_string_String = v18 |> unbox<std_string_String>
    let _v23 = v30 
    #endif
#if FABLE_COMPILER_PYTHON
    let v33 : std_string_String = v18 |> unbox<std_string_String>
    let _v23 = v33 
    #endif
#else
    let v36 : std_string_String = v18 |> unbox<std_string_String>
    let _v23 = v36 
    #endif
    let v39 : std_string_String = _v23 
    let v44 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v45 : string = "std::path::PathBuf::from($0)"
    let v46 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v39 v45 
    let _v44 = v46 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v47 : string = "std::path::PathBuf::from($0)"
    let v48 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v39 v47 
    let _v44 = v48 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v49 : string = "std::path::PathBuf::from($0)"
    let v50 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v39 v49 
    let _v44 = v50 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v51 : std_path_PathBuf = v39 |> std_path_PathBuf 
    let _v44 = v51 
    #endif
#if FABLE_COMPILER_PYTHON
    let v54 : std_path_PathBuf = v39 |> std_path_PathBuf 
    let _v44 = v54 
    #endif
#else
    let v57 : std_path_PathBuf = v39 |> std_path_PathBuf 
    let _v44 = v57 
    #endif
    let v60 : std_path_PathBuf = _v44 
    let v65 : string = "$0.parent().map(std::path::PathBuf::from)"
    let v66 : std_path_PathBuf option = Fable.Core.RustInterop.emitRustExpr v60 v65 
    let v67 : string = "true; let _optionm_map_ = $0.map(|x| { //"
    let v68 : bool = Fable.Core.RustInterop.emitRustExpr v66 v67 
    let v69 : string = "x"
    let v70 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr () v69 
    let v71 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v72 : string = "$0.display()"
    let v73 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v70 v72 
    let _v71 = v73 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v74 : string = "$0.display()"
    let v75 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v70 v74 
    let _v71 = v75 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v76 : string = "$0.display()"
    let v77 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v70 v76 
    let _v71 = v77 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v78 : std_path_Display = v70 |> unbox<std_path_Display>
    let _v71 = v78 
    #endif
#if FABLE_COMPILER_PYTHON
    let v81 : std_path_Display = v70 |> unbox<std_path_Display>
    let _v71 = v81 
    #endif
#else
    let v84 : std_path_Display = v70 |> unbox<std_path_Display>
    let _v71 = v84 
    #endif
    let v87 : std_path_Display = _v71 
    let v92 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v93 : string = "format!(\"{}\", $0)"
    let v94 : std_string_String = Fable.Core.RustInterop.emitRustExpr v87 v93 
    let _v92 = v94 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v95 : string = "format!(\"{}\", $0)"
    let v96 : std_string_String = Fable.Core.RustInterop.emitRustExpr v87 v95 
    let _v92 = v96 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v97 : string = "format!(\"{}\", $0)"
    let v98 : std_string_String = Fable.Core.RustInterop.emitRustExpr v87 v97 
    let _v92 = v98 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v99 : std_string_String = null |> unbox<std_string_String>
    let _v92 = v99 
    #endif
#if FABLE_COMPILER_PYTHON
    let v102 : std_string_String = null |> unbox<std_string_String>
    let _v92 = v102 
    #endif
#else
    let v105 : std_string_String = null |> unbox<std_string_String>
    let _v92 = v105 
    #endif
    let v108 : std_string_String = _v92 
    let v113 : string = "fable_library_rust::String_::fromString($0)"
    let v114 : string = Fable.Core.RustInterop.emitRustExpr v108 v113 
    let v115 : string = "true; $0 })"
    let v116 : bool = Fable.Core.RustInterop.emitRustExpr v114 v115 
    let v117 : string = "_optionm_map_"
    let v118 : string option = Fable.Core.RustInterop.emitRustExpr () v117 
    let v119 : string = ""
    let v120 : string = v118 |> Option.defaultValue v119 
    let _v1 = v120 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v123 : string = null |> unbox<string>
    let _v1 = v123 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v126 : string = null |> unbox<string>
    let _v1 = v126 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v129 : string = null |> unbox<string>
    let _v1 = v129 
    #endif
#if FABLE_COMPILER_PYTHON
    let v132 : string = null |> unbox<string>
    let _v1 = v132 
    #endif
#else
    let v135 : (string -> string) = System.IO.Path.GetDirectoryName
    let v136 : string = v135 v0
    let _v1 = v136 
    #endif
    let v137 : string = _v1 
    v137
and method32 (v0 : string) : string option =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : string = method33(v0)
    let v3 : US1 = US1_0(v2)
    let _v1 = v3 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v4 : US1 = null |> unbox<US1>
    let _v1 = v4 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v7 : US1 = null |> unbox<US1>
    let _v1 = v7 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v10 : string = "path"
    let v11 : IPathDirname = Fable.Core.JsInterop.importAll v10 
    let v12 : string = "v11.dirname($0)"
    let v13 : string = Fable.Core.JsInterop.emitJsExpr v0 v12 
    let v14 : US1 = US1_0(v13)
    let _v1 = v14 
    #endif
#if FABLE_COMPILER_PYTHON
    let v15 : US1 = null |> unbox<US1>
    let _v1 = v15 
    #endif
#else
    let v18 : (string -> System.IO.DirectoryInfo) = System.IO.Directory.GetParent
    let v19 : System.IO.DirectoryInfo = v18 v0
    let v20 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let v23 : bool = v19 = v20 
    let v50 : US1 =
        if v23 then
            US1_1
        else
            let v27 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v28 : string = null |> unbox<string>
            let _v27 = v28 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v31 : string = null |> unbox<string>
            let _v27 = v31 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v34 : string = null |> unbox<string>
            let _v27 = v34 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v37 : string = null |> unbox<string>
            let _v27 = v37 
            #endif
#if FABLE_COMPILER_PYTHON
            let v40 : string = null |> unbox<string>
            let _v27 = v40 
            #endif
#else
            let v43 : string = v19.FullName
            let _v27 = v43 
            #endif
            let v44 : string = _v27 
            US1_0(v44)
    let _v1 = v50 
    #endif
    let v51 : US1 = _v1 
    match v51 with
    | US1_1 -> (* None *)
        let v60 : string option = None
        v60
    | US1_0(v56) -> (* Some *)
        let v57 : string option = Some v56 
        v57
and closure13 () (v0 : string) : string option =
    method32(v0)
and method31 () : (string -> string option) =
    closure13()
and method34 (v0 : string, v1 : string, v2 : string) : US7 =
    let v3 : string = method26(v2, v0)
    let v4 : bool = method30(v3)
    if v4 then
        US7_0(v2)
    else
        let v6 : (string -> string option) = method31()
        let v7 : string option = v6 v2
        let v8 : (string -> US1) = method5()
        let v9 : US1 option = v7 |> Option.map v8 
        let v20 : US1 = US1_1
        let v21 : US1 = v9 |> Option.defaultValue v20 
        match v21 with
        | US1_1 -> (* None *)
            let v27 : string = $"""No parent for {if false then "file" else "dir"} '{v0}' at '{v1}' (until '{v2}')"""
            US7_1(v27)
        | US1_0(v25) -> (* Some *)
            method34(v0, v1, v25)
and method29 (v0 : string, v1 : string) : US7 =
    let v2 : string = method26(v1, v0)
    let v3 : bool = method30(v2)
    if v3 then
        US7_0(v1)
    else
        let v5 : (string -> string option) = method31()
        let v6 : string option = v5 v1
        let v7 : (string -> US1) = method5()
        let v8 : US1 option = v6 |> Option.map v7 
        let v19 : US1 = US1_1
        let v20 : US1 = v8 |> Option.defaultValue v19 
        match v20 with
        | US1_1 -> (* None *)
            let v26 : string = $"""No parent for {if false then "file" else "dir"} '{v0}' at '{v1}' (until '{v1}')"""
            US7_1(v26)
        | US1_0(v24) -> (* Some *)
            method34(v0, v1, v24)
and method35 () : string =
    
    
    
    
    
    let v0 : string = "Warning"
    let v1 : (unit -> string) = v0.ToLower
    let v2 : string = v1 ()
    let v5 : char = v2.[int 0]
    let v6 : string = method13(v5)
    let v7 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v8 : string = "inline_colorization::color_yellow"
    let v9 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v8 
    let v10 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v11 : string = "&*$0"
    let v12 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v11 
    let _v10 = v12 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v13 : string = "&*$0"
    let v14 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v13 
    let _v10 = v14 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v15 : string = "&*$0"
    let v16 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v15 
    let _v10 = v16 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v17 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v10 = v17 
    #endif
#if FABLE_COMPILER_PYTHON
    let v20 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v10 = v20 
    #endif
#else
    let v23 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v10 = v23 
    #endif
    let v26 : Ref<Str> = _v10 
    let v31 : string = "inline_colorization::color_reset"
    let v32 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v31 
    let v33 : string = $"format!(\"{{}}{{}}{{}}\", $0, $1, $2)"
    let v34 : std_string_String = Fable.Core.RustInterop.emitRustExpr struct (v9, v26, v32) v33 
    let v35 : string = "fable_library_rust::String_::fromString($0)"
    let v36 : string = Fable.Core.RustInterop.emitRustExpr v34 v35 
    let _v7 = v36 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v37 : string = "inline_colorization::color_yellow"
    let v38 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v37 
    let v39 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v40 : string = "&*$0"
    let v41 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v40 
    let _v39 = v41 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v42 : string = "&*$0"
    let v43 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v42 
    let _v39 = v43 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v44 : string = "&*$0"
    let v45 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v44 
    let _v39 = v45 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v46 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v39 = v46 
    #endif
#if FABLE_COMPILER_PYTHON
    let v49 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v39 = v49 
    #endif
#else
    let v52 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v39 = v52 
    #endif
    let v55 : Ref<Str> = _v39 
    let v60 : string = "inline_colorization::color_reset"
    let v61 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v60 
    let v62 : string = $"format!(\"{{}}{{}}{{}}\", $0, $1, $2)"
    let v63 : std_string_String = Fable.Core.RustInterop.emitRustExpr struct (v38, v55, v61) v62 
    let v64 : string = "fable_library_rust::String_::fromString($0)"
    let v65 : string = Fable.Core.RustInterop.emitRustExpr v63 v64 
    let _v7 = v65 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v66 : string = "inline_colorization::color_yellow"
    let v67 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v66 
    let v68 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v69 : string = "&*$0"
    let v70 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v69 
    let _v68 = v70 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v71 : string = "&*$0"
    let v72 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v71 
    let _v68 = v72 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v73 : string = "&*$0"
    let v74 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v73 
    let _v68 = v74 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v75 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v68 = v75 
    #endif
#if FABLE_COMPILER_PYTHON
    let v78 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v68 = v78 
    #endif
#else
    let v81 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v68 = v81 
    #endif
    let v84 : Ref<Str> = _v68 
    let v89 : string = "inline_colorization::color_reset"
    let v90 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v89 
    let v91 : string = $"format!(\"{{}}{{}}{{}}\", $0, $1, $2)"
    let v92 : std_string_String = Fable.Core.RustInterop.emitRustExpr struct (v67, v84, v90) v91 
    let v93 : string = "fable_library_rust::String_::fromString($0)"
    let v94 : string = Fable.Core.RustInterop.emitRustExpr v92 v93 
    let _v7 = v94 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v95 : string = "\u001b[93m"
    let v96 : string = method15()
    let v97 : string = v95 + v6 
    let v98 : string = v97 + v96 
    let _v7 = v98 
    #endif
#if FABLE_COMPILER_PYTHON
    let v99 : string = "\u001b[93m"
    let v100 : string = method15()
    let v101 : string = v99 + v6 
    let v102 : string = v101 + v100 
    let _v7 = v102 
    #endif
#else
    let v103 : string = "\u001b[93m"
    let v104 : string = method15()
    let v105 : string = v103 + v6 
    let v106 : string = v105 + v104 
    let _v7 = v106 
    #endif
    let v107 : string = _v7 
    v107
and method37 (v0 : string) : string =
    let v1 : string = method14()
    let v2 : Mut3 = {l0 = v1} : Mut3
    let v3 : string = "{ "
    let v4 : string = $"{v3}"
    let v7 : unit = ()
    let v8 : (unit -> unit) = closure8(v2, v4)
    let v9 : unit = (fun () -> v8 (); v7) ()
    let v12 : string = "error"
    let v13 : string = $"{v12}"
    let v16 : unit = ()
    let v17 : (unit -> unit) = closure8(v2, v13)
    let v18 : unit = (fun () -> v17 (); v16) ()
    let v21 : string = " = "
    let v22 : string = $"{v21}"
    let v25 : unit = ()
    let v26 : (unit -> unit) = closure8(v2, v22)
    let v27 : unit = (fun () -> v26 (); v25) ()
    let v30 : string = $"{v0}"
    let v33 : unit = ()
    let v34 : (unit -> unit) = closure8(v2, v30)
    let v35 : unit = (fun () -> v34 (); v33) ()
    let v38 : string = " }"
    let v39 : string = $"{v38}"
    let v42 : unit = ()
    let v43 : (unit -> unit) = closure8(v2, v39)
    let v44 : unit = (fun () -> v43 (); v42) ()
    let v47 : string = v2.l0
    v47
and method36 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : string) : string =
    let v9 : string = method37(v8)
    let v10 : int64 = v0.l0
    let v11 : string = "file_system.get_workspace_root"
    let v12 : string = $"{v6} {v7} #{v10} %s{v11} / {v9}"
    method18(v12)
and closure14 (v0 : string) () : unit =
    let v1 : US0 = US0_3
    let v2 : bool = method7(v1)
    if v2 then
        let v3 : unit = ()
        let v4 : (unit -> unit) = closure6()
        let v5 : unit = (fun () -> v4 (); v3) ()
        let struct (v19 : Mut0, v20 : Mut1, v21 : Mut2, v22 : Mut3, v23 : Mut4, v24 : int64 option) = TraceState.trace_state.Value
        let v37 : string = method8(v19, v20, v21, v22, v23, v24)
        let v38 : string = method35()
        let v39 : string = method36(v19, v20, v21, v22, v23, v24, v37, v38, v0)
        method19(v39)
and method38 () : string =
    let v0 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v1 : string = "std::env::current_dir()"
    let v2 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr () v1 
    let v3 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v4 : string = "$0.unwrap()"
    let v5 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2 v4 
    let _v3 = v5 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v6 : string = "$0.unwrap()"
    let v7 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2 v6 
    let _v3 = v7 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v8 : string = "$0.unwrap()"
    let v9 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2 v8 
    let _v3 = v9 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v10 : std_path_PathBuf = match v2 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
    let _v3 = v10 
    #endif
#if FABLE_COMPILER_PYTHON
    let v11 : std_path_PathBuf = match v2 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
    let _v3 = v11 
    #endif
#else
    let v12 : std_path_PathBuf = match v2 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
    let _v3 = v12 
    #endif
    let v13 : std_path_PathBuf = _v3 
    let v16 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v17 : string = "$0.display()"
    let v18 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v13 v17 
    let _v16 = v18 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v19 : string = "$0.display()"
    let v20 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v13 v19 
    let _v16 = v20 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v21 : string = "$0.display()"
    let v22 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v13 v21 
    let _v16 = v22 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v23 : std_path_Display = v13 |> unbox<std_path_Display>
    let _v16 = v23 
    #endif
#if FABLE_COMPILER_PYTHON
    let v26 : std_path_Display = v13 |> unbox<std_path_Display>
    let _v16 = v26 
    #endif
#else
    let v29 : std_path_Display = v13 |> unbox<std_path_Display>
    let _v16 = v29 
    #endif
    let v32 : std_path_Display = _v16 
    let v37 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v38 : string = "format!(\"{}\", $0)"
    let v39 : std_string_String = Fable.Core.RustInterop.emitRustExpr v32 v38 
    let _v37 = v39 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v40 : string = "format!(\"{}\", $0)"
    let v41 : std_string_String = Fable.Core.RustInterop.emitRustExpr v32 v40 
    let _v37 = v41 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v42 : string = "format!(\"{}\", $0)"
    let v43 : std_string_String = Fable.Core.RustInterop.emitRustExpr v32 v42 
    let _v37 = v43 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v44 : std_string_String = null |> unbox<std_string_String>
    let _v37 = v44 
    #endif
#if FABLE_COMPILER_PYTHON
    let v47 : std_string_String = null |> unbox<std_string_String>
    let _v37 = v47 
    #endif
#else
    let v50 : std_string_String = null |> unbox<std_string_String>
    let _v37 = v50 
    #endif
    let v53 : std_string_String = _v37 
    let v58 : string = "fable_library_rust::String_::fromString($0)"
    let v59 : string = Fable.Core.RustInterop.emitRustExpr v53 v58 
    let _v0 = v59 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v60 : string = null |> unbox<string>
    let _v0 = v60 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v63 : string = null |> unbox<string>
    let _v0 = v63 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v66 : string = null |> unbox<string>
    let _v0 = v66 
    #endif
#if FABLE_COMPILER_PYTHON
    let v69 : string = null |> unbox<string>
    let _v0 = v69 
    #endif
#else
    let v72 : (unit -> string) = System.IO.Directory.GetCurrentDirectory
    let v73 : string = v72 ()
    let _v0 = v73 
    #endif
    let v74 : string = _v0 
    v74
and method42 (v0 : std_io_Error) : string =
    let v1 : string = method14()
    let v2 : Mut3 = {l0 = v1} : Mut3
    let v3 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v4 : string = "format!(\"{:#?}\", $0)"
    let v5 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v4 
    let v6 : string = "fable_library_rust::String_::fromString($0)"
    let v7 : string = Fable.Core.RustInterop.emitRustExpr v5 v6 
    let _v3 = v7 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v8 : string = "format!(\"{:#?}\", $0)"
    let v9 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v8 
    let v10 : string = "fable_library_rust::String_::fromString($0)"
    let v11 : string = Fable.Core.RustInterop.emitRustExpr v9 v10 
    let _v3 = v11 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v12 : string = "format!(\"{:#?}\", $0)"
    let v13 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v12 
    let v14 : string = "fable_library_rust::String_::fromString($0)"
    let v15 : string = Fable.Core.RustInterop.emitRustExpr v13 v14 
    let _v3 = v15 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v16 : string = $"%A{v0}"
    let _v3 = v16 
    #endif
#if FABLE_COMPILER_PYTHON
    let v19 : string = $"%A{v0}"
    let _v3 = v19 
    #endif
#else
    let v22 : string = $"%A{v0}"
    let _v3 = v22 
    #endif
    let v25 : string = _v3 
    let v30 : string = $"{v25}"
    let v33 : unit = ()
    let v34 : (unit -> unit) = closure8(v2, v30)
    let v35 : unit = (fun () -> v34 (); v33) ()
    let v38 : string = v2.l0
    v38
and closure15 () (v0 : std_io_Error) : string =
    method42(v0)
and method41 () : (std_io_Error -> string) =
    closure15()
and closure16 () (v0 : std_path_PathBuf) : US8 =
    US8_0(v0)
and closure17 () (v0 : string) : US8 =
    US8_1(v0)
and method43 (v0 : string) : string =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v3 : string = "&*$0"
    let v4 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v0 v3 
    let _v2 = v4 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v5 : string = "&*$0"
    let v6 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v0 v5 
    let _v2 = v6 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v7 : string = "&*$0"
    let v8 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v0 v7 
    let _v2 = v8 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v9 : Ref<Str> = v0 |> unbox<Ref<Str>>
    let _v2 = v9 
    #endif
#if FABLE_COMPILER_PYTHON
    let v12 : Ref<Str> = v0 |> unbox<Ref<Str>>
    let _v2 = v12 
    #endif
#else
    let v15 : Ref<Str> = v0 |> unbox<Ref<Str>>
    let _v2 = v15 
    #endif
    let v18 : Ref<Str> = _v2 
    let v23 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v24 : string = "String::from($0)"
    let v25 : std_string_String = Fable.Core.RustInterop.emitRustExpr v18 v24 
    let _v23 = v25 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v26 : string = "String::from($0)"
    let v27 : std_string_String = Fable.Core.RustInterop.emitRustExpr v18 v26 
    let _v23 = v27 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v28 : string = "String::from($0)"
    let v29 : std_string_String = Fable.Core.RustInterop.emitRustExpr v18 v28 
    let _v23 = v29 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v30 : std_string_String = v18 |> unbox<std_string_String>
    let _v23 = v30 
    #endif
#if FABLE_COMPILER_PYTHON
    let v33 : std_string_String = v18 |> unbox<std_string_String>
    let _v23 = v33 
    #endif
#else
    let v36 : std_string_String = v18 |> unbox<std_string_String>
    let _v23 = v36 
    #endif
    let v39 : std_string_String = _v23 
    let v44 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v45 : string = "std::path::PathBuf::from($0)"
    let v46 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v39 v45 
    let _v44 = v46 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v47 : string = "std::path::PathBuf::from($0)"
    let v48 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v39 v47 
    let _v44 = v48 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v49 : string = "std::path::PathBuf::from($0)"
    let v50 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v39 v49 
    let _v44 = v50 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v51 : std_path_PathBuf = v39 |> std_path_PathBuf 
    let _v44 = v51 
    #endif
#if FABLE_COMPILER_PYTHON
    let v54 : std_path_PathBuf = v39 |> std_path_PathBuf 
    let _v44 = v54 
    #endif
#else
    let v57 : std_path_PathBuf = v39 |> std_path_PathBuf 
    let _v44 = v57 
    #endif
    let v60 : std_path_PathBuf = _v44 
    let v65 : string = "$0.file_name()"
    let v66 : Ref<std_ffi_OsStr> option = Fable.Core.RustInterop.emitRustExpr v60 v65 
    let v67 : string = "true; let _optionm_map_ = $0.map(|x| { //"
    let v68 : bool = Fable.Core.RustInterop.emitRustExpr v66 v67 
    let v69 : string = "x"
    let v70 : Ref<std_ffi_OsStr> = Fable.Core.RustInterop.emitRustExpr () v69 
    let v71 : string = "$0.to_os_string()"
    let v72 : std_ffi_OsString = Fable.Core.RustInterop.emitRustExpr v70 v71 
    let v73 : string = "$0.to_str()"
    let v74 : Ref<Str> option = Fable.Core.RustInterop.emitRustExpr v72 v73 
    let v75 : string = "$0.unwrap()"
    let v76 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v74 v75 
    let v77 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v78 : string = "String::from($0)"
    let v79 : std_string_String = Fable.Core.RustInterop.emitRustExpr v76 v78 
    let _v77 = v79 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v80 : string = "String::from($0)"
    let v81 : std_string_String = Fable.Core.RustInterop.emitRustExpr v76 v80 
    let _v77 = v81 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v82 : string = "String::from($0)"
    let v83 : std_string_String = Fable.Core.RustInterop.emitRustExpr v76 v82 
    let _v77 = v83 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v84 : std_string_String = v76 |> unbox<std_string_String>
    let _v77 = v84 
    #endif
#if FABLE_COMPILER_PYTHON
    let v87 : std_string_String = v76 |> unbox<std_string_String>
    let _v77 = v87 
    #endif
#else
    let v90 : std_string_String = v76 |> unbox<std_string_String>
    let _v77 = v90 
    #endif
    let v93 : std_string_String = _v77 
    let v98 : string = "fable_library_rust::String_::fromString($0)"
    let v99 : string = Fable.Core.RustInterop.emitRustExpr v93 v98 
    let v100 : string = "true; $0 })"
    let v101 : bool = Fable.Core.RustInterop.emitRustExpr v99 v100 
    let v102 : string = "_optionm_map_"
    let v103 : string option = Fable.Core.RustInterop.emitRustExpr () v102 
    let v104 : (string -> US1) = method5()
    let v105 : US1 option = v103 |> Option.map v104 
    let v116 : US1 = US1_1
    let v117 : US1 = v105 |> Option.defaultValue v116 
    let v124 : string =
        match v117 with
        | US1_1 -> (* None *)
            let v122 : string = ""
            v122
        | US1_0(v121) -> (* Some *)
            v121
    let _v1 = v124 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v125 : US5 = US5_1
    let v126 : US6 = US6_2(v125)
    let v127 : string = $"file_system.get_file_name / target: {v126} / path: {v0}"
    let v128 : string = failwith<string> v127
    let _v1 = v128 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v129 : string = null |> unbox<string>
    let _v1 = v129 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v132 : US5 = US5_0
    let v133 : US6 = US6_3(v132)
    let v134 : string = $"file_system.get_file_name / target: {v133} / path: {v0}"
    let v135 : string = failwith<string> v134
    let _v1 = v135 
    #endif
#if FABLE_COMPILER_PYTHON
    let v136 : US5 = US5_0
    let v137 : US6 = US6_4(v136)
    let v138 : string = $"file_system.get_file_name / target: {v137} / path: {v0}"
    let v139 : string = failwith<string> v138
    let _v1 = v139 
    #endif
#else
    let v140 : (string -> string) = System.IO.Path.GetFileName
    let v141 : string = v140 v0
    let _v1 = v141 
    #endif
    let v142 : string = _v1 
    v142
and closure18 () (v0 : std_path_PathBuf) : US9 =
    US9_0(v0)
and method44 () : (std_path_PathBuf -> US9) =
    closure18()
and method46 (v0 : string) : string =
    v0
and method45 (v0 : string, v1 : string, v2 : string) : string =
    let v3 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v4 : string = $"regex::Regex::new(&$0)"
    let v5 : Result<regex_Regex, regex_Error> = Fable.Core.RustInterop.emitRustExpr v0 v4 
    let v6 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v7 : string = "$0.unwrap()"
    let v8 : regex_Regex = Fable.Core.RustInterop.emitRustExpr v5 v7 
    let _v6 = v8 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v9 : string = "$0.unwrap()"
    let v10 : regex_Regex = Fable.Core.RustInterop.emitRustExpr v5 v9 
    let _v6 = v10 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v11 : string = "$0.unwrap()"
    let v12 : regex_Regex = Fable.Core.RustInterop.emitRustExpr v5 v11 
    let _v6 = v12 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v13 : regex_Regex = match v5 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
    let _v6 = v13 
    #endif
#if FABLE_COMPILER_PYTHON
    let v14 : regex_Regex = match v5 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
    let _v6 = v14 
    #endif
#else
    let v15 : regex_Regex = match v5 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
    let _v6 = v15 
    #endif
    let v16 : regex_Regex = _v6 
    let v19 : string = method46(v2)
    let v20 : string = $"$0.replace_all(&*$1, &*$2)"
    let v21 : std_borrow_Cow<Str> = Fable.Core.RustInterop.emitRustExpr struct (v16, v19, v1) v20 
    let v22 : string = "String::from($0)"
    let v23 : std_string_String = Fable.Core.RustInterop.emitRustExpr v21 v22 
    let v24 : string = "fable_library_rust::String_::fromString($0)"
    let v25 : string = Fable.Core.RustInterop.emitRustExpr v23 v24 
    let _v3 = v25 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v26 : string = null |> unbox<string>
    let _v3 = v26 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v29 : string = null |> unbox<string>
    let _v3 = v29 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v32 : string = null |> unbox<string>
    let _v3 = v32 
    #endif
#if FABLE_COMPILER_PYTHON
    let v35 : string = null |> unbox<string>
    let _v3 = v35 
    #endif
#else
    let v38 : string = System.Text.RegularExpressions.Regex.Replace (v2, v0, v1)
    let _v3 = v38 
    #endif
    let v39 : string = _v3 
    v39
and method40 (v0 : string) : string =
    let v1 : bool = v0 = ""
    if v1 then
        let v2 : string = ""
        v2
    else
        let v3 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v4 : bool = method30(v0)
        let v2950 : Result<std_path_PathBuf, std_io_Error> =
            if v4 then
                let v5 : string = "std::fs::read_link(&*$0)"
                let v6 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v0 v5 
                v6
            else
                let v7 : string = "std::fs::read_link(&*$0)"
                let v8 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v0 v7 
                let v9 : (std_io_Error -> string) = method41()
                let v10 : unit = ()
                
#if FABLE_COMPILER || WASM || CONTRACT
                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                let v11 : string = "$0.map_err(|x| $1(x))"
                let v12 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8, v9) v11 
                let _v10 = v12 
                #endif
#if FABLE_COMPILER_RUST && WASM
                let v13 : string = "$0.map_err(|x| $1(x))"
                let v14 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8, v9) v13 
                let _v10 = v14 
                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                let v15 : string = "$0.map_err(|x| $1(x))"
                let v16 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8, v9) v15 
                let _v10 = v16 
                #endif
#if FABLE_COMPILER_TYPESCRIPT
                let v17 : Result<std_path_PathBuf, string> = match v8 with Ok x -> Ok x | Error x -> Error (v9 x)
                let _v10 = v17 
                #endif
#if FABLE_COMPILER_PYTHON
                let v18 : Result<std_path_PathBuf, string> = match v8 with Ok x -> Ok x | Error x -> Error (v9 x)
                let _v10 = v18 
                #endif
#else
                let v19 : Result<std_path_PathBuf, string> = match v8 with Ok x -> Ok x | Error x -> Error (v9 x)
                let _v10 = v19 
                #endif
                let v20 : Result<std_path_PathBuf, string> = _v10 
                let v23 : (std_path_PathBuf -> US8) = closure16()
                let v24 : (string -> US8) = closure17()
                let v25 : US8 = match v20 with Ok x -> v23 x | Error x -> v24 x
                match v25 with
                | US8_1(v40) -> (* Error *)
                    let v41 : string = method43(v0)
                    let v42 : string option = method32(v0)
                    let v43 : (string -> US1) = method5()
                    let v44 : US1 option = v42 |> Option.map v43 
                    let v55 : US1 = US1_1
                    let v56 : US1 = v44 |> Option.defaultValue v55 
                    match v56 with
                    | US1_0(v60) -> (* Some *)
                        let v61 : string = ""
                        let v62 : bool = v0 <> v61 
                        if v62 then
                            let v65 : string = "std::fs::read_link(&*$0)"
                            let v66 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v60 v65 
                            let v67 : (std_io_Error -> string) = method41()
                            let v68 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v69 : string = "$0.map_err(|x| $1(x))"
                            let v70 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v66, v67) v69 
                            let _v68 = v70 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v71 : string = "$0.map_err(|x| $1(x))"
                            let v72 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v66, v67) v71 
                            let _v68 = v72 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v73 : string = "$0.map_err(|x| $1(x))"
                            let v74 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v66, v67) v73 
                            let _v68 = v74 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v75 : Result<std_path_PathBuf, string> = match v66 with Ok x -> Ok x | Error x -> Error (v67 x)
                            let _v68 = v75 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v76 : Result<std_path_PathBuf, string> = match v66 with Ok x -> Ok x | Error x -> Error (v67 x)
                            let _v68 = v76 
                            #endif
#else
                            let v77 : Result<std_path_PathBuf, string> = match v66 with Ok x -> Ok x | Error x -> Error (v67 x)
                            let _v68 = v77 
                            #endif
                            let v78 : Result<std_path_PathBuf, string> = _v68 
                            let v81 : US8 = match v78 with Ok x -> v23 x | Error x -> v24 x
                            let v2744 : Result<std_path_PathBuf, std_io_Error> =
                                match v81 with
                                | US8_1(v96) -> (* Error *)
                                    let v97 : string = method43(v60)
                                    let v98 : string option = method32(v60)
                                    let v99 : (string -> US1) = method5()
                                    let v100 : US1 option = v98 |> Option.map v99 
                                    let v111 : US1 = US1_1
                                    let v112 : US1 = v100 |> Option.defaultValue v111 
                                    match v112 with
                                    | US1_0(v116) -> (* Some *)
                                        let v117 : bool = v60 <> v61 
                                        if v117 then
                                            let v120 : string = "std::fs::read_link(&*$0)"
                                            let v121 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v116 v120 
                                            let v122 : (std_io_Error -> string) = method41()
                                            let v123 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v124 : string = "$0.map_err(|x| $1(x))"
                                            let v125 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v121, v122) v124 
                                            let _v123 = v125 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v126 : string = "$0.map_err(|x| $1(x))"
                                            let v127 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v121, v122) v126 
                                            let _v123 = v127 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v128 : string = "$0.map_err(|x| $1(x))"
                                            let v129 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v121, v122) v128 
                                            let _v123 = v129 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v130 : Result<std_path_PathBuf, string> = match v121 with Ok x -> Ok x | Error x -> Error (v122 x)
                                            let _v123 = v130 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v131 : Result<std_path_PathBuf, string> = match v121 with Ok x -> Ok x | Error x -> Error (v122 x)
                                            let _v123 = v131 
                                            #endif
#else
                                            let v132 : Result<std_path_PathBuf, string> = match v121 with Ok x -> Ok x | Error x -> Error (v122 x)
                                            let _v123 = v132 
                                            #endif
                                            let v133 : Result<std_path_PathBuf, string> = _v123 
                                            let v136 : US8 = match v133 with Ok x -> v23 x | Error x -> v24 x
                                            let v2539 : Result<std_path_PathBuf, std_io_Error> =
                                                match v136 with
                                                | US8_1(v151) -> (* Error *)
                                                    let v152 : string = method43(v116)
                                                    let v153 : string option = method32(v116)
                                                    let v154 : (string -> US1) = method5()
                                                    let v155 : US1 option = v153 |> Option.map v154 
                                                    let v166 : US1 = US1_1
                                                    let v167 : US1 = v155 |> Option.defaultValue v166 
                                                    match v167 with
                                                    | US1_0(v171) -> (* Some *)
                                                        let v172 : bool = v116 <> v61 
                                                        if v172 then
                                                            let v175 : string = "std::fs::read_link(&*$0)"
                                                            let v176 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v171 v175 
                                                            let v177 : (std_io_Error -> string) = method41()
                                                            let v178 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v179 : string = "$0.map_err(|x| $1(x))"
                                                            let v180 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v176, v177) v179 
                                                            let _v178 = v180 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v181 : string = "$0.map_err(|x| $1(x))"
                                                            let v182 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v176, v177) v181 
                                                            let _v178 = v182 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v183 : string = "$0.map_err(|x| $1(x))"
                                                            let v184 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v176, v177) v183 
                                                            let _v178 = v184 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v185 : Result<std_path_PathBuf, string> = match v176 with Ok x -> Ok x | Error x -> Error (v177 x)
                                                            let _v178 = v185 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v186 : Result<std_path_PathBuf, string> = match v176 with Ok x -> Ok x | Error x -> Error (v177 x)
                                                            let _v178 = v186 
                                                            #endif
#else
                                                            let v187 : Result<std_path_PathBuf, string> = match v176 with Ok x -> Ok x | Error x -> Error (v177 x)
                                                            let _v178 = v187 
                                                            #endif
                                                            let v188 : Result<std_path_PathBuf, string> = _v178 
                                                            let v191 : US8 = match v188 with Ok x -> v23 x | Error x -> v24 x
                                                            let v2334 : Result<std_path_PathBuf, std_io_Error> =
                                                                match v191 with
                                                                | US8_1(v206) -> (* Error *)
                                                                    let v207 : string = method43(v171)
                                                                    let v208 : string option = method32(v171)
                                                                    let v209 : (string -> US1) = method5()
                                                                    let v210 : US1 option = v208 |> Option.map v209 
                                                                    let v221 : US1 = US1_1
                                                                    let v222 : US1 = v210 |> Option.defaultValue v221 
                                                                    match v222 with
                                                                    | US1_0(v226) -> (* Some *)
                                                                        let v227 : bool = v171 <> v61 
                                                                        if v227 then
                                                                            let v230 : string = "std::fs::read_link(&*$0)"
                                                                            let v231 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v226 v230 
                                                                            let v232 : (std_io_Error -> string) = method41()
                                                                            let v233 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v234 : string = "$0.map_err(|x| $1(x))"
                                                                            let v235 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v231, v232) v234 
                                                                            let _v233 = v235 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v236 : string = "$0.map_err(|x| $1(x))"
                                                                            let v237 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v231, v232) v236 
                                                                            let _v233 = v237 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v238 : string = "$0.map_err(|x| $1(x))"
                                                                            let v239 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v231, v232) v238 
                                                                            let _v233 = v239 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v240 : Result<std_path_PathBuf, string> = match v231 with Ok x -> Ok x | Error x -> Error (v232 x)
                                                                            let _v233 = v240 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v241 : Result<std_path_PathBuf, string> = match v231 with Ok x -> Ok x | Error x -> Error (v232 x)
                                                                            let _v233 = v241 
                                                                            #endif
#else
                                                                            let v242 : Result<std_path_PathBuf, string> = match v231 with Ok x -> Ok x | Error x -> Error (v232 x)
                                                                            let _v233 = v242 
                                                                            #endif
                                                                            let v243 : Result<std_path_PathBuf, string> = _v233 
                                                                            let v246 : US8 = match v243 with Ok x -> v23 x | Error x -> v24 x
                                                                            let v2129 : Result<std_path_PathBuf, std_io_Error> =
                                                                                match v246 with
                                                                                | US8_1(v261) -> (* Error *)
                                                                                    let v262 : string = method43(v226)
                                                                                    let v263 : string option = method32(v226)
                                                                                    let v264 : (string -> US1) = method5()
                                                                                    let v265 : US1 option = v263 |> Option.map v264 
                                                                                    let v276 : US1 = US1_1
                                                                                    let v277 : US1 = v265 |> Option.defaultValue v276 
                                                                                    match v277 with
                                                                                    | US1_0(v281) -> (* Some *)
                                                                                        let v282 : bool = v226 <> v61 
                                                                                        if v282 then
                                                                                            let v285 : string = "std::fs::read_link(&*$0)"
                                                                                            let v286 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v281 v285 
                                                                                            let v287 : (std_io_Error -> string) = method41()
                                                                                            let v288 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v289 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v290 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v286, v287) v289 
                                                                                            let _v288 = v290 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v291 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v292 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v286, v287) v291 
                                                                                            let _v288 = v292 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v293 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v294 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v286, v287) v293 
                                                                                            let _v288 = v294 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v295 : Result<std_path_PathBuf, string> = match v286 with Ok x -> Ok x | Error x -> Error (v287 x)
                                                                                            let _v288 = v295 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v296 : Result<std_path_PathBuf, string> = match v286 with Ok x -> Ok x | Error x -> Error (v287 x)
                                                                                            let _v288 = v296 
                                                                                            #endif
#else
                                                                                            let v297 : Result<std_path_PathBuf, string> = match v286 with Ok x -> Ok x | Error x -> Error (v287 x)
                                                                                            let _v288 = v297 
                                                                                            #endif
                                                                                            let v298 : Result<std_path_PathBuf, string> = _v288 
                                                                                            let v301 : US8 = match v298 with Ok x -> v23 x | Error x -> v24 x
                                                                                            let v1924 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                match v301 with
                                                                                                | US8_1(v316) -> (* Error *)
                                                                                                    let v317 : string = method43(v281)
                                                                                                    let v318 : string option = method32(v281)
                                                                                                    let v319 : (string -> US1) = method5()
                                                                                                    let v320 : US1 option = v318 |> Option.map v319 
                                                                                                    let v331 : US1 = US1_1
                                                                                                    let v332 : US1 = v320 |> Option.defaultValue v331 
                                                                                                    match v332 with
                                                                                                    | US1_0(v336) -> (* Some *)
                                                                                                        let v337 : bool = v281 <> v61 
                                                                                                        if v337 then
                                                                                                            let v340 : string = "std::fs::read_link(&*$0)"
                                                                                                            let v341 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v336 v340 
                                                                                                            let v342 : (std_io_Error -> string) = method41()
                                                                                                            let v343 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v344 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v345 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v341, v342) v344 
                                                                                                            let _v343 = v345 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v346 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v347 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v341, v342) v346 
                                                                                                            let _v343 = v347 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v348 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v349 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v341, v342) v348 
                                                                                                            let _v343 = v349 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v350 : Result<std_path_PathBuf, string> = match v341 with Ok x -> Ok x | Error x -> Error (v342 x)
                                                                                                            let _v343 = v350 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v351 : Result<std_path_PathBuf, string> = match v341 with Ok x -> Ok x | Error x -> Error (v342 x)
                                                                                                            let _v343 = v351 
                                                                                                            #endif
#else
                                                                                                            let v352 : Result<std_path_PathBuf, string> = match v341 with Ok x -> Ok x | Error x -> Error (v342 x)
                                                                                                            let _v343 = v352 
                                                                                                            #endif
                                                                                                            let v353 : Result<std_path_PathBuf, string> = _v343 
                                                                                                            let v356 : US8 = match v353 with Ok x -> v23 x | Error x -> v24 x
                                                                                                            let v1719 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                match v356 with
                                                                                                                | US8_1(v371) -> (* Error *)
                                                                                                                    let v372 : string = method43(v336)
                                                                                                                    let v373 : string option = method32(v336)
                                                                                                                    let v374 : (string -> US1) = method5()
                                                                                                                    let v375 : US1 option = v373 |> Option.map v374 
                                                                                                                    let v386 : US1 = US1_1
                                                                                                                    let v387 : US1 = v375 |> Option.defaultValue v386 
                                                                                                                    match v387 with
                                                                                                                    | US1_0(v391) -> (* Some *)
                                                                                                                        let v392 : bool = v336 <> v61 
                                                                                                                        if v392 then
                                                                                                                            let v395 : string = "std::fs::read_link(&*$0)"
                                                                                                                            let v396 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v391 v395 
                                                                                                                            let v397 : (std_io_Error -> string) = method41()
                                                                                                                            let v398 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v399 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v400 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v396, v397) v399 
                                                                                                                            let _v398 = v400 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v401 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v402 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v396, v397) v401 
                                                                                                                            let _v398 = v402 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v403 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v404 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v396, v397) v403 
                                                                                                                            let _v398 = v404 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v405 : Result<std_path_PathBuf, string> = match v396 with Ok x -> Ok x | Error x -> Error (v397 x)
                                                                                                                            let _v398 = v405 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v406 : Result<std_path_PathBuf, string> = match v396 with Ok x -> Ok x | Error x -> Error (v397 x)
                                                                                                                            let _v398 = v406 
                                                                                                                            #endif
#else
                                                                                                                            let v407 : Result<std_path_PathBuf, string> = match v396 with Ok x -> Ok x | Error x -> Error (v397 x)
                                                                                                                            let _v398 = v407 
                                                                                                                            #endif
                                                                                                                            let v408 : Result<std_path_PathBuf, string> = _v398 
                                                                                                                            let v411 : US8 = match v408 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                            let v1514 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                match v411 with
                                                                                                                                | US8_1(v426) -> (* Error *)
                                                                                                                                    let v427 : string = method43(v391)
                                                                                                                                    let v428 : string option = method32(v391)
                                                                                                                                    let v429 : (string -> US1) = method5()
                                                                                                                                    let v430 : US1 option = v428 |> Option.map v429 
                                                                                                                                    let v441 : US1 = US1_1
                                                                                                                                    let v442 : US1 = v430 |> Option.defaultValue v441 
                                                                                                                                    match v442 with
                                                                                                                                    | US1_0(v446) -> (* Some *)
                                                                                                                                        let v447 : bool = v391 <> v61 
                                                                                                                                        if v447 then
                                                                                                                                            let v450 : string = "std::fs::read_link(&*$0)"
                                                                                                                                            let v451 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v446 v450 
                                                                                                                                            let v452 : (std_io_Error -> string) = method41()
                                                                                                                                            let v453 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v454 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v455 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v451, v452) v454 
                                                                                                                                            let _v453 = v455 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v456 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v457 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v451, v452) v456 
                                                                                                                                            let _v453 = v457 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v458 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v459 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v451, v452) v458 
                                                                                                                                            let _v453 = v459 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v460 : Result<std_path_PathBuf, string> = match v451 with Ok x -> Ok x | Error x -> Error (v452 x)
                                                                                                                                            let _v453 = v460 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v461 : Result<std_path_PathBuf, string> = match v451 with Ok x -> Ok x | Error x -> Error (v452 x)
                                                                                                                                            let _v453 = v461 
                                                                                                                                            #endif
#else
                                                                                                                                            let v462 : Result<std_path_PathBuf, string> = match v451 with Ok x -> Ok x | Error x -> Error (v452 x)
                                                                                                                                            let _v453 = v462 
                                                                                                                                            #endif
                                                                                                                                            let v463 : Result<std_path_PathBuf, string> = _v453 
                                                                                                                                            let v466 : US8 = match v463 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                                            let v1309 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                match v466 with
                                                                                                                                                | US8_1(v481) -> (* Error *)
                                                                                                                                                    let v482 : string = method43(v446)
                                                                                                                                                    let v483 : string option = method32(v446)
                                                                                                                                                    let v484 : (string -> US1) = method5()
                                                                                                                                                    let v485 : US1 option = v483 |> Option.map v484 
                                                                                                                                                    let v496 : US1 = US1_1
                                                                                                                                                    let v497 : US1 = v485 |> Option.defaultValue v496 
                                                                                                                                                    match v497 with
                                                                                                                                                    | US1_0(v501) -> (* Some *)
                                                                                                                                                        let v502 : bool = v446 <> v61 
                                                                                                                                                        if v502 then
                                                                                                                                                            let v505 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                            let v506 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v501 v505 
                                                                                                                                                            let v507 : (std_io_Error -> string) = method41()
                                                                                                                                                            let v508 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v509 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v510 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v506, v507) v509 
                                                                                                                                                            let _v508 = v510 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v511 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v512 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v506, v507) v511 
                                                                                                                                                            let _v508 = v512 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v513 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v514 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v506, v507) v513 
                                                                                                                                                            let _v508 = v514 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v515 : Result<std_path_PathBuf, string> = match v506 with Ok x -> Ok x | Error x -> Error (v507 x)
                                                                                                                                                            let _v508 = v515 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v516 : Result<std_path_PathBuf, string> = match v506 with Ok x -> Ok x | Error x -> Error (v507 x)
                                                                                                                                                            let _v508 = v516 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v517 : Result<std_path_PathBuf, string> = match v506 with Ok x -> Ok x | Error x -> Error (v507 x)
                                                                                                                                                            let _v508 = v517 
                                                                                                                                                            #endif
                                                                                                                                                            let v518 : Result<std_path_PathBuf, string> = _v508 
                                                                                                                                                            let v521 : US8 = match v518 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                                                            let v1104 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                match v521 with
                                                                                                                                                                | US8_1(v536) -> (* Error *)
                                                                                                                                                                    let v537 : string = method43(v501)
                                                                                                                                                                    let v538 : string option = method32(v501)
                                                                                                                                                                    let v539 : (string -> US1) = method5()
                                                                                                                                                                    let v540 : US1 option = v538 |> Option.map v539 
                                                                                                                                                                    let v551 : US1 = US1_1
                                                                                                                                                                    let v552 : US1 = v540 |> Option.defaultValue v551 
                                                                                                                                                                    match v552 with
                                                                                                                                                                    | US1_0(v556) -> (* Some *)
                                                                                                                                                                        let v557 : bool = v501 <> v61 
                                                                                                                                                                        if v557 then
                                                                                                                                                                            let v560 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                                            let v561 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v556 v560 
                                                                                                                                                                            let v562 : (std_io_Error -> string) = method41()
                                                                                                                                                                            let v563 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v564 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v565 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v561, v562) v564 
                                                                                                                                                                            let _v563 = v565 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v566 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v567 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v561, v562) v566 
                                                                                                                                                                            let _v563 = v567 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v568 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v569 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v561, v562) v568 
                                                                                                                                                                            let _v563 = v569 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v570 : Result<std_path_PathBuf, string> = match v561 with Ok x -> Ok x | Error x -> Error (v562 x)
                                                                                                                                                                            let _v563 = v570 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v571 : Result<std_path_PathBuf, string> = match v561 with Ok x -> Ok x | Error x -> Error (v562 x)
                                                                                                                                                                            let _v563 = v571 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v572 : Result<std_path_PathBuf, string> = match v561 with Ok x -> Ok x | Error x -> Error (v562 x)
                                                                                                                                                                            let _v563 = v572 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v573 : Result<std_path_PathBuf, string> = _v563 
                                                                                                                                                                            let v576 : US8 = match v573 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                                                                            let v899 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                match v576 with
                                                                                                                                                                                | US8_1(v591) -> (* Error *)
                                                                                                                                                                                    let v592 : string = method43(v556)
                                                                                                                                                                                    let v593 : string option = method32(v556)
                                                                                                                                                                                    let v594 : (string -> US1) = method5()
                                                                                                                                                                                    let v595 : US1 option = v593 |> Option.map v594 
                                                                                                                                                                                    let v606 : US1 = US1_1
                                                                                                                                                                                    let v607 : US1 = v595 |> Option.defaultValue v606 
                                                                                                                                                                                    match v607 with
                                                                                                                                                                                    | US1_0(v611) -> (* Some *)
                                                                                                                                                                                        let v612 : bool = v556 <> v61 
                                                                                                                                                                                        if v612 then
                                                                                                                                                                                            let v615 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                                                            let v616 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v611 v615 
                                                                                                                                                                                            let v617 : (std_io_Error -> string) = method41()
                                                                                                                                                                                            let v618 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v619 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v620 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v616, v617) v619 
                                                                                                                                                                                            let _v618 = v620 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v621 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v622 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v616, v617) v621 
                                                                                                                                                                                            let _v618 = v622 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v623 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v624 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v616, v617) v623 
                                                                                                                                                                                            let _v618 = v624 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v625 : Result<std_path_PathBuf, string> = match v616 with Ok x -> Ok x | Error x -> Error (v617 x)
                                                                                                                                                                                            let _v618 = v625 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v626 : Result<std_path_PathBuf, string> = match v616 with Ok x -> Ok x | Error x -> Error (v617 x)
                                                                                                                                                                                            let _v618 = v626 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v627 : Result<std_path_PathBuf, string> = match v616 with Ok x -> Ok x | Error x -> Error (v617 x)
                                                                                                                                                                                            let _v618 = v627 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v628 : Result<std_path_PathBuf, string> = _v618 
                                                                                                                                                                                            let v631 : US8 = match v628 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                                                                                            let v694 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                                match v631 with
                                                                                                                                                                                                | US8_1(v646) -> (* Error *)
                                                                                                                                                                                                    let v647 : string = method43(v611)
                                                                                                                                                                                                    let v648 : string option = method32(v611)
                                                                                                                                                                                                    let v649 : (string -> US1) = method5()
                                                                                                                                                                                                    let v650 : US1 option = v648 |> Option.map v649 
                                                                                                                                                                                                    let v661 : US1 = US1_1
                                                                                                                                                                                                    let v662 : US1 = v650 |> Option.defaultValue v661 
                                                                                                                                                                                                    let v666 : string = $"file_system.read_link / path: {v0} / n: {11uy} / path': {v611} / name: {v647}"
                                                                                                                                                                                                    let v667 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v668 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v669 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v666 v668 
                                                                                                                                                                                                    let _v667 = v669 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v670 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v671 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v666 v670 
                                                                                                                                                                                                    let _v667 = v671 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v672 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v673 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v666 v672 
                                                                                                                                                                                                    let _v667 = v673 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v674 : std_io_Error = v666 
                                                                                                                                                                                                    let _v667 = v674 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v675 : std_io_Error = v666 
                                                                                                                                                                                                    let _v667 = v675 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v676 : std_io_Error = v666 
                                                                                                                                                                                                    let _v667 = v676 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v677 : std_io_Error = _v667 
                                                                                                                                                                                                    let v680 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v681 : string = "Err($0)"
                                                                                                                                                                                                    let v682 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v677 v681 
                                                                                                                                                                                                    let _v680 = v682 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v683 : string = "Err($0)"
                                                                                                                                                                                                    let v684 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v677 v683 
                                                                                                                                                                                                    let _v680 = v684 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v685 : string = "Err($0)"
                                                                                                                                                                                                    let v686 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v677 v685 
                                                                                                                                                                                                    let _v680 = v686 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v687 : Result<std_path_PathBuf, std_io_Error> = v677 |> Error
                                                                                                                                                                                                    let _v680 = v687 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v688 : Result<std_path_PathBuf, std_io_Error> = v677 |> Error
                                                                                                                                                                                                    let _v680 = v688 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v689 : Result<std_path_PathBuf, std_io_Error> = v677 |> Error
                                                                                                                                                                                                    let _v680 = v689 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v690 : Result<std_path_PathBuf, std_io_Error> = _v680 
                                                                                                                                                                                                    v690
                                                                                                                                                                                                | US8_0(v632) -> (* Ok *)
                                                                                                                                                                                                    let v633 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v634 : string = "Ok($0)"
                                                                                                                                                                                                    let v635 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v632 v634 
                                                                                                                                                                                                    let _v633 = v635 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v636 : string = "Ok($0)"
                                                                                                                                                                                                    let v637 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v632 v636 
                                                                                                                                                                                                    let _v633 = v637 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v638 : string = "Ok($0)"
                                                                                                                                                                                                    let v639 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v632 v638 
                                                                                                                                                                                                    let _v633 = v639 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v640 : Result<std_path_PathBuf, std_io_Error> = v632 |> Ok
                                                                                                                                                                                                    let _v633 = v640 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v641 : Result<std_path_PathBuf, std_io_Error> = v632 |> Ok
                                                                                                                                                                                                    let _v633 = v641 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v642 : Result<std_path_PathBuf, std_io_Error> = v632 |> Ok
                                                                                                                                                                                                    let _v633 = v642 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v643 : Result<std_path_PathBuf, std_io_Error> = _v633 
                                                                                                                                                                                                    v643
                                                                                                                                                                                            let v695 : (std_io_Error -> string) = method41()
                                                                                                                                                                                            let v696 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v697 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v698 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v694, v695) v697 
                                                                                                                                                                                            let _v696 = v698 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v699 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v700 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v694, v695) v699 
                                                                                                                                                                                            let _v696 = v700 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v701 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v702 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v694, v695) v701 
                                                                                                                                                                                            let _v696 = v702 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v703 : Result<std_path_PathBuf, string> = match v694 with Ok x -> Ok x | Error x -> Error (v695 x)
                                                                                                                                                                                            let _v696 = v703 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v704 : Result<std_path_PathBuf, string> = match v694 with Ok x -> Ok x | Error x -> Error (v695 x)
                                                                                                                                                                                            let _v696 = v704 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v705 : Result<std_path_PathBuf, string> = match v694 with Ok x -> Ok x | Error x -> Error (v695 x)
                                                                                                                                                                                            let _v696 = v705 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v706 : Result<std_path_PathBuf, string> = _v696 
                                                                                                                                                                                            let v709 : US8 = match v706 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                                                                                            match v709 with
                                                                                                                                                                                            | US8_1(v812) -> (* Error *)
                                                                                                                                                                                                let v813 : string = $"file_system.read_link / error': {v812} / error: {v591} / name: {v592}"
                                                                                                                                                                                                let v814 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v815 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v816 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v813 v815 
                                                                                                                                                                                                let _v814 = v816 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v817 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v818 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v813 v817 
                                                                                                                                                                                                let _v814 = v818 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v819 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v820 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v813 v819 
                                                                                                                                                                                                let _v814 = v820 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v821 : std_io_Error = v813 
                                                                                                                                                                                                let _v814 = v821 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v822 : std_io_Error = v813 
                                                                                                                                                                                                let _v814 = v822 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v823 : std_io_Error = v813 
                                                                                                                                                                                                let _v814 = v823 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v824 : std_io_Error = _v814 
                                                                                                                                                                                                let v827 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v828 : string = "Err($0)"
                                                                                                                                                                                                let v829 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v824 v828 
                                                                                                                                                                                                let _v827 = v829 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v830 : string = "Err($0)"
                                                                                                                                                                                                let v831 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v824 v830 
                                                                                                                                                                                                let _v827 = v831 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v832 : string = "Err($0)"
                                                                                                                                                                                                let v833 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v824 v832 
                                                                                                                                                                                                let _v827 = v833 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v834 : Result<std_path_PathBuf, std_io_Error> = v824 |> Error
                                                                                                                                                                                                let _v827 = v834 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v835 : Result<std_path_PathBuf, std_io_Error> = v824 |> Error
                                                                                                                                                                                                let _v827 = v835 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v836 : Result<std_path_PathBuf, std_io_Error> = v824 |> Error
                                                                                                                                                                                                let _v827 = v836 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v837 : Result<std_path_PathBuf, std_io_Error> = _v827 
                                                                                                                                                                                                v837
                                                                                                                                                                                            | US8_0(v710) -> (* Ok *)
                                                                                                                                                                                                let v711 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v712 : string = "$0.display()"
                                                                                                                                                                                                let v713 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v710 v712 
                                                                                                                                                                                                let _v711 = v713 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v714 : string = "$0.display()"
                                                                                                                                                                                                let v715 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v710 v714 
                                                                                                                                                                                                let _v711 = v715 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v716 : string = "$0.display()"
                                                                                                                                                                                                let v717 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v710 v716 
                                                                                                                                                                                                let _v711 = v717 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v718 : std_path_Display = v710 |> unbox<std_path_Display>
                                                                                                                                                                                                let _v711 = v718 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v721 : std_path_Display = v710 |> unbox<std_path_Display>
                                                                                                                                                                                                let _v711 = v721 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v724 : std_path_Display = v710 |> unbox<std_path_Display>
                                                                                                                                                                                                let _v711 = v724 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v727 : std_path_Display = _v711 
                                                                                                                                                                                                let v732 : string = v727 |> string 
                                                                                                                                                                                                let v735 : string = method26(v732, v592)
                                                                                                                                                                                                let v736 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v737 : string = "&*$0"
                                                                                                                                                                                                let v738 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v735 v737 
                                                                                                                                                                                                let _v736 = v738 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v739 : string = "&*$0"
                                                                                                                                                                                                let v740 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v735 v739 
                                                                                                                                                                                                let _v736 = v740 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v741 : string = "&*$0"
                                                                                                                                                                                                let v742 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v735 v741 
                                                                                                                                                                                                let _v736 = v742 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v743 : Ref<Str> = v735 |> unbox<Ref<Str>>
                                                                                                                                                                                                let _v736 = v743 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v746 : Ref<Str> = v735 |> unbox<Ref<Str>>
                                                                                                                                                                                                let _v736 = v746 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v749 : Ref<Str> = v735 |> unbox<Ref<Str>>
                                                                                                                                                                                                let _v736 = v749 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v752 : Ref<Str> = _v736 
                                                                                                                                                                                                let v757 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v758 : string = "String::from($0)"
                                                                                                                                                                                                let v759 : std_string_String = Fable.Core.RustInterop.emitRustExpr v752 v758 
                                                                                                                                                                                                let _v757 = v759 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v760 : string = "String::from($0)"
                                                                                                                                                                                                let v761 : std_string_String = Fable.Core.RustInterop.emitRustExpr v752 v760 
                                                                                                                                                                                                let _v757 = v761 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v762 : string = "String::from($0)"
                                                                                                                                                                                                let v763 : std_string_String = Fable.Core.RustInterop.emitRustExpr v752 v762 
                                                                                                                                                                                                let _v757 = v763 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v764 : std_string_String = v752 |> unbox<std_string_String>
                                                                                                                                                                                                let _v757 = v764 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v767 : std_string_String = v752 |> unbox<std_string_String>
                                                                                                                                                                                                let _v757 = v767 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v770 : std_string_String = v752 |> unbox<std_string_String>
                                                                                                                                                                                                let _v757 = v770 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v773 : std_string_String = _v757 
                                                                                                                                                                                                let v778 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v779 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                let v780 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v773 v779 
                                                                                                                                                                                                let _v778 = v780 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v781 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                let v782 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v773 v781 
                                                                                                                                                                                                let _v778 = v782 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v783 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                let v784 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v773 v783 
                                                                                                                                                                                                let _v778 = v784 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v785 : std_path_PathBuf = v773 |> std_path_PathBuf 
                                                                                                                                                                                                let _v778 = v785 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v788 : std_path_PathBuf = v773 |> std_path_PathBuf 
                                                                                                                                                                                                let _v778 = v788 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v791 : std_path_PathBuf = v773 |> std_path_PathBuf 
                                                                                                                                                                                                let _v778 = v791 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v794 : std_path_PathBuf = _v778 
                                                                                                                                                                                                let v799 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v800 : string = "Ok($0)"
                                                                                                                                                                                                let v801 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v794 v800 
                                                                                                                                                                                                let _v799 = v801 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v802 : string = "Ok($0)"
                                                                                                                                                                                                let v803 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v794 v802 
                                                                                                                                                                                                let _v799 = v803 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v804 : string = "Ok($0)"
                                                                                                                                                                                                let v805 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v794 v804 
                                                                                                                                                                                                let _v799 = v805 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v806 : Result<std_path_PathBuf, std_io_Error> = v794 |> Ok
                                                                                                                                                                                                let _v799 = v806 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v807 : Result<std_path_PathBuf, std_io_Error> = v794 |> Ok
                                                                                                                                                                                                let _v799 = v807 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v808 : Result<std_path_PathBuf, std_io_Error> = v794 |> Ok
                                                                                                                                                                                                let _v799 = v808 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v809 : Result<std_path_PathBuf, std_io_Error> = _v799 
                                                                                                                                                                                                v809
                                                                                                                                                                                        else
                                                                                                                                                                                            let v842 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v591} / path': {v556} / name: {v592}"
                                                                                                                                                                                            let v843 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v844 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v845 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v842 v844 
                                                                                                                                                                                            let _v843 = v845 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v846 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v847 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v842 v846 
                                                                                                                                                                                            let _v843 = v847 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v848 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v849 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v842 v848 
                                                                                                                                                                                            let _v843 = v849 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v850 : std_io_Error = v842 
                                                                                                                                                                                            let _v843 = v850 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v851 : std_io_Error = v842 
                                                                                                                                                                                            let _v843 = v851 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v852 : std_io_Error = v842 
                                                                                                                                                                                            let _v843 = v852 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v853 : std_io_Error = _v843 
                                                                                                                                                                                            let v856 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v857 : string = "Err($0)"
                                                                                                                                                                                            let v858 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v853 v857 
                                                                                                                                                                                            let _v856 = v858 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v859 : string = "Err($0)"
                                                                                                                                                                                            let v860 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v853 v859 
                                                                                                                                                                                            let _v856 = v860 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v861 : string = "Err($0)"
                                                                                                                                                                                            let v862 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v853 v861 
                                                                                                                                                                                            let _v856 = v862 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v863 : Result<std_path_PathBuf, std_io_Error> = v853 |> Error
                                                                                                                                                                                            let _v856 = v863 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v864 : Result<std_path_PathBuf, std_io_Error> = v853 |> Error
                                                                                                                                                                                            let _v856 = v864 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v865 : Result<std_path_PathBuf, std_io_Error> = v853 |> Error
                                                                                                                                                                                            let _v856 = v865 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v866 : Result<std_path_PathBuf, std_io_Error> = _v856 
                                                                                                                                                                                            v866
                                                                                                                                                                                    | _ ->
                                                                                                                                                                                        let v870 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v591} / path': {v556} / name: {v592}"
                                                                                                                                                                                        let v871 : unit = ()
                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                        let v872 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                        let v873 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v870 v872 
                                                                                                                                                                                        let _v871 = v873 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                        let v874 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                        let v875 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v870 v874 
                                                                                                                                                                                        let _v871 = v875 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                        let v876 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                        let v877 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v870 v876 
                                                                                                                                                                                        let _v871 = v877 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                        let v878 : std_io_Error = v870 
                                                                                                                                                                                        let _v871 = v878 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                        let v879 : std_io_Error = v870 
                                                                                                                                                                                        let _v871 = v879 
                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                        let v880 : std_io_Error = v870 
                                                                                                                                                                                        let _v871 = v880 
                                                                                                                                                                                        #endif
                                                                                                                                                                                        let v881 : std_io_Error = _v871 
                                                                                                                                                                                        let v884 : unit = ()
                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                        let v885 : string = "Err($0)"
                                                                                                                                                                                        let v886 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v881 v885 
                                                                                                                                                                                        let _v884 = v886 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                        let v887 : string = "Err($0)"
                                                                                                                                                                                        let v888 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v881 v887 
                                                                                                                                                                                        let _v884 = v888 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                        let v889 : string = "Err($0)"
                                                                                                                                                                                        let v890 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v881 v889 
                                                                                                                                                                                        let _v884 = v890 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                        let v891 : Result<std_path_PathBuf, std_io_Error> = v881 |> Error
                                                                                                                                                                                        let _v884 = v891 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                        let v892 : Result<std_path_PathBuf, std_io_Error> = v881 |> Error
                                                                                                                                                                                        let _v884 = v892 
                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                        let v893 : Result<std_path_PathBuf, std_io_Error> = v881 |> Error
                                                                                                                                                                                        let _v884 = v893 
                                                                                                                                                                                        #endif
                                                                                                                                                                                        let v894 : Result<std_path_PathBuf, std_io_Error> = _v884 
                                                                                                                                                                                        v894
                                                                                                                                                                                | US8_0(v577) -> (* Ok *)
                                                                                                                                                                                    let v578 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v579 : string = "Ok($0)"
                                                                                                                                                                                    let v580 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v577 v579 
                                                                                                                                                                                    let _v578 = v580 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v581 : string = "Ok($0)"
                                                                                                                                                                                    let v582 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v577 v581 
                                                                                                                                                                                    let _v578 = v582 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v583 : string = "Ok($0)"
                                                                                                                                                                                    let v584 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v577 v583 
                                                                                                                                                                                    let _v578 = v584 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v585 : Result<std_path_PathBuf, std_io_Error> = v577 |> Ok
                                                                                                                                                                                    let _v578 = v585 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v586 : Result<std_path_PathBuf, std_io_Error> = v577 |> Ok
                                                                                                                                                                                    let _v578 = v586 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v587 : Result<std_path_PathBuf, std_io_Error> = v577 |> Ok
                                                                                                                                                                                    let _v578 = v587 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v588 : Result<std_path_PathBuf, std_io_Error> = _v578 
                                                                                                                                                                                    v588
                                                                                                                                                                            let v900 : (std_io_Error -> string) = method41()
                                                                                                                                                                            let v901 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v902 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v903 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v899, v900) v902 
                                                                                                                                                                            let _v901 = v903 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v904 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v905 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v899, v900) v904 
                                                                                                                                                                            let _v901 = v905 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v906 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v907 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v899, v900) v906 
                                                                                                                                                                            let _v901 = v907 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v908 : Result<std_path_PathBuf, string> = match v899 with Ok x -> Ok x | Error x -> Error (v900 x)
                                                                                                                                                                            let _v901 = v908 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v909 : Result<std_path_PathBuf, string> = match v899 with Ok x -> Ok x | Error x -> Error (v900 x)
                                                                                                                                                                            let _v901 = v909 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v910 : Result<std_path_PathBuf, string> = match v899 with Ok x -> Ok x | Error x -> Error (v900 x)
                                                                                                                                                                            let _v901 = v910 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v911 : Result<std_path_PathBuf, string> = _v901 
                                                                                                                                                                            let v914 : US8 = match v911 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                                                                            match v914 with
                                                                                                                                                                            | US8_1(v1017) -> (* Error *)
                                                                                                                                                                                let v1018 : string = $"file_system.read_link / error': {v1017} / error: {v536} / name: {v537}"
                                                                                                                                                                                let v1019 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v1020 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v1021 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1018 v1020 
                                                                                                                                                                                let _v1019 = v1021 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v1022 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v1023 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1018 v1022 
                                                                                                                                                                                let _v1019 = v1023 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v1024 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v1025 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1018 v1024 
                                                                                                                                                                                let _v1019 = v1025 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v1026 : std_io_Error = v1018 
                                                                                                                                                                                let _v1019 = v1026 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v1027 : std_io_Error = v1018 
                                                                                                                                                                                let _v1019 = v1027 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v1028 : std_io_Error = v1018 
                                                                                                                                                                                let _v1019 = v1028 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v1029 : std_io_Error = _v1019 
                                                                                                                                                                                let v1032 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v1033 : string = "Err($0)"
                                                                                                                                                                                let v1034 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1029 v1033 
                                                                                                                                                                                let _v1032 = v1034 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v1035 : string = "Err($0)"
                                                                                                                                                                                let v1036 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1029 v1035 
                                                                                                                                                                                let _v1032 = v1036 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v1037 : string = "Err($0)"
                                                                                                                                                                                let v1038 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1029 v1037 
                                                                                                                                                                                let _v1032 = v1038 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v1039 : Result<std_path_PathBuf, std_io_Error> = v1029 |> Error
                                                                                                                                                                                let _v1032 = v1039 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v1040 : Result<std_path_PathBuf, std_io_Error> = v1029 |> Error
                                                                                                                                                                                let _v1032 = v1040 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v1041 : Result<std_path_PathBuf, std_io_Error> = v1029 |> Error
                                                                                                                                                                                let _v1032 = v1041 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v1042 : Result<std_path_PathBuf, std_io_Error> = _v1032 
                                                                                                                                                                                v1042
                                                                                                                                                                            | US8_0(v915) -> (* Ok *)
                                                                                                                                                                                let v916 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v917 : string = "$0.display()"
                                                                                                                                                                                let v918 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v915 v917 
                                                                                                                                                                                let _v916 = v918 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v919 : string = "$0.display()"
                                                                                                                                                                                let v920 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v915 v919 
                                                                                                                                                                                let _v916 = v920 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v921 : string = "$0.display()"
                                                                                                                                                                                let v922 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v915 v921 
                                                                                                                                                                                let _v916 = v922 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v923 : std_path_Display = v915 |> unbox<std_path_Display>
                                                                                                                                                                                let _v916 = v923 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v926 : std_path_Display = v915 |> unbox<std_path_Display>
                                                                                                                                                                                let _v916 = v926 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v929 : std_path_Display = v915 |> unbox<std_path_Display>
                                                                                                                                                                                let _v916 = v929 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v932 : std_path_Display = _v916 
                                                                                                                                                                                let v937 : string = v932 |> string 
                                                                                                                                                                                let v940 : string = method26(v937, v537)
                                                                                                                                                                                let v941 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v942 : string = "&*$0"
                                                                                                                                                                                let v943 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v940 v942 
                                                                                                                                                                                let _v941 = v943 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v944 : string = "&*$0"
                                                                                                                                                                                let v945 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v940 v944 
                                                                                                                                                                                let _v941 = v945 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v946 : string = "&*$0"
                                                                                                                                                                                let v947 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v940 v946 
                                                                                                                                                                                let _v941 = v947 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v948 : Ref<Str> = v940 |> unbox<Ref<Str>>
                                                                                                                                                                                let _v941 = v948 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v951 : Ref<Str> = v940 |> unbox<Ref<Str>>
                                                                                                                                                                                let _v941 = v951 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v954 : Ref<Str> = v940 |> unbox<Ref<Str>>
                                                                                                                                                                                let _v941 = v954 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v957 : Ref<Str> = _v941 
                                                                                                                                                                                let v962 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v963 : string = "String::from($0)"
                                                                                                                                                                                let v964 : std_string_String = Fable.Core.RustInterop.emitRustExpr v957 v963 
                                                                                                                                                                                let _v962 = v964 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v965 : string = "String::from($0)"
                                                                                                                                                                                let v966 : std_string_String = Fable.Core.RustInterop.emitRustExpr v957 v965 
                                                                                                                                                                                let _v962 = v966 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v967 : string = "String::from($0)"
                                                                                                                                                                                let v968 : std_string_String = Fable.Core.RustInterop.emitRustExpr v957 v967 
                                                                                                                                                                                let _v962 = v968 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v969 : std_string_String = v957 |> unbox<std_string_String>
                                                                                                                                                                                let _v962 = v969 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v972 : std_string_String = v957 |> unbox<std_string_String>
                                                                                                                                                                                let _v962 = v972 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v975 : std_string_String = v957 |> unbox<std_string_String>
                                                                                                                                                                                let _v962 = v975 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v978 : std_string_String = _v962 
                                                                                                                                                                                let v983 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v984 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                let v985 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v978 v984 
                                                                                                                                                                                let _v983 = v985 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v986 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                let v987 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v978 v986 
                                                                                                                                                                                let _v983 = v987 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v988 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                let v989 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v978 v988 
                                                                                                                                                                                let _v983 = v989 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v990 : std_path_PathBuf = v978 |> std_path_PathBuf 
                                                                                                                                                                                let _v983 = v990 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v993 : std_path_PathBuf = v978 |> std_path_PathBuf 
                                                                                                                                                                                let _v983 = v993 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v996 : std_path_PathBuf = v978 |> std_path_PathBuf 
                                                                                                                                                                                let _v983 = v996 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v999 : std_path_PathBuf = _v983 
                                                                                                                                                                                let v1004 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v1005 : string = "Ok($0)"
                                                                                                                                                                                let v1006 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v999 v1005 
                                                                                                                                                                                let _v1004 = v1006 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v1007 : string = "Ok($0)"
                                                                                                                                                                                let v1008 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v999 v1007 
                                                                                                                                                                                let _v1004 = v1008 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v1009 : string = "Ok($0)"
                                                                                                                                                                                let v1010 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v999 v1009 
                                                                                                                                                                                let _v1004 = v1010 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v1011 : Result<std_path_PathBuf, std_io_Error> = v999 |> Ok
                                                                                                                                                                                let _v1004 = v1011 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v1012 : Result<std_path_PathBuf, std_io_Error> = v999 |> Ok
                                                                                                                                                                                let _v1004 = v1012 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v1013 : Result<std_path_PathBuf, std_io_Error> = v999 |> Ok
                                                                                                                                                                                let _v1004 = v1013 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v1014 : Result<std_path_PathBuf, std_io_Error> = _v1004 
                                                                                                                                                                                v1014
                                                                                                                                                                        else
                                                                                                                                                                            let v1047 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v536} / path': {v501} / name: {v537}"
                                                                                                                                                                            let v1048 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v1049 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v1050 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1047 v1049 
                                                                                                                                                                            let _v1048 = v1050 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v1051 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v1052 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1047 v1051 
                                                                                                                                                                            let _v1048 = v1052 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v1053 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v1054 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1047 v1053 
                                                                                                                                                                            let _v1048 = v1054 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v1055 : std_io_Error = v1047 
                                                                                                                                                                            let _v1048 = v1055 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v1056 : std_io_Error = v1047 
                                                                                                                                                                            let _v1048 = v1056 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v1057 : std_io_Error = v1047 
                                                                                                                                                                            let _v1048 = v1057 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v1058 : std_io_Error = _v1048 
                                                                                                                                                                            let v1061 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v1062 : string = "Err($0)"
                                                                                                                                                                            let v1063 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1058 v1062 
                                                                                                                                                                            let _v1061 = v1063 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v1064 : string = "Err($0)"
                                                                                                                                                                            let v1065 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1058 v1064 
                                                                                                                                                                            let _v1061 = v1065 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v1066 : string = "Err($0)"
                                                                                                                                                                            let v1067 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1058 v1066 
                                                                                                                                                                            let _v1061 = v1067 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v1068 : Result<std_path_PathBuf, std_io_Error> = v1058 |> Error
                                                                                                                                                                            let _v1061 = v1068 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v1069 : Result<std_path_PathBuf, std_io_Error> = v1058 |> Error
                                                                                                                                                                            let _v1061 = v1069 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v1070 : Result<std_path_PathBuf, std_io_Error> = v1058 |> Error
                                                                                                                                                                            let _v1061 = v1070 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v1071 : Result<std_path_PathBuf, std_io_Error> = _v1061 
                                                                                                                                                                            v1071
                                                                                                                                                                    | _ ->
                                                                                                                                                                        let v1075 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v536} / path': {v501} / name: {v537}"
                                                                                                                                                                        let v1076 : unit = ()
                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                        let v1077 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                        let v1078 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1075 v1077 
                                                                                                                                                                        let _v1076 = v1078 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                        let v1079 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                        let v1080 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1075 v1079 
                                                                                                                                                                        let _v1076 = v1080 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                        let v1081 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                        let v1082 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1075 v1081 
                                                                                                                                                                        let _v1076 = v1082 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                        let v1083 : std_io_Error = v1075 
                                                                                                                                                                        let _v1076 = v1083 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                        let v1084 : std_io_Error = v1075 
                                                                                                                                                                        let _v1076 = v1084 
                                                                                                                                                                        #endif
#else
                                                                                                                                                                        let v1085 : std_io_Error = v1075 
                                                                                                                                                                        let _v1076 = v1085 
                                                                                                                                                                        #endif
                                                                                                                                                                        let v1086 : std_io_Error = _v1076 
                                                                                                                                                                        let v1089 : unit = ()
                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                        let v1090 : string = "Err($0)"
                                                                                                                                                                        let v1091 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1086 v1090 
                                                                                                                                                                        let _v1089 = v1091 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                        let v1092 : string = "Err($0)"
                                                                                                                                                                        let v1093 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1086 v1092 
                                                                                                                                                                        let _v1089 = v1093 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                        let v1094 : string = "Err($0)"
                                                                                                                                                                        let v1095 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1086 v1094 
                                                                                                                                                                        let _v1089 = v1095 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                        let v1096 : Result<std_path_PathBuf, std_io_Error> = v1086 |> Error
                                                                                                                                                                        let _v1089 = v1096 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                        let v1097 : Result<std_path_PathBuf, std_io_Error> = v1086 |> Error
                                                                                                                                                                        let _v1089 = v1097 
                                                                                                                                                                        #endif
#else
                                                                                                                                                                        let v1098 : Result<std_path_PathBuf, std_io_Error> = v1086 |> Error
                                                                                                                                                                        let _v1089 = v1098 
                                                                                                                                                                        #endif
                                                                                                                                                                        let v1099 : Result<std_path_PathBuf, std_io_Error> = _v1089 
                                                                                                                                                                        v1099
                                                                                                                                                                | US8_0(v522) -> (* Ok *)
                                                                                                                                                                    let v523 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v524 : string = "Ok($0)"
                                                                                                                                                                    let v525 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v522 v524 
                                                                                                                                                                    let _v523 = v525 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v526 : string = "Ok($0)"
                                                                                                                                                                    let v527 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v522 v526 
                                                                                                                                                                    let _v523 = v527 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v528 : string = "Ok($0)"
                                                                                                                                                                    let v529 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v522 v528 
                                                                                                                                                                    let _v523 = v529 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v530 : Result<std_path_PathBuf, std_io_Error> = v522 |> Ok
                                                                                                                                                                    let _v523 = v530 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v531 : Result<std_path_PathBuf, std_io_Error> = v522 |> Ok
                                                                                                                                                                    let _v523 = v531 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v532 : Result<std_path_PathBuf, std_io_Error> = v522 |> Ok
                                                                                                                                                                    let _v523 = v532 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v533 : Result<std_path_PathBuf, std_io_Error> = _v523 
                                                                                                                                                                    v533
                                                                                                                                                            let v1105 : (std_io_Error -> string) = method41()
                                                                                                                                                            let v1106 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v1107 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v1108 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1104, v1105) v1107 
                                                                                                                                                            let _v1106 = v1108 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v1109 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v1110 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1104, v1105) v1109 
                                                                                                                                                            let _v1106 = v1110 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v1111 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v1112 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1104, v1105) v1111 
                                                                                                                                                            let _v1106 = v1112 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v1113 : Result<std_path_PathBuf, string> = match v1104 with Ok x -> Ok x | Error x -> Error (v1105 x)
                                                                                                                                                            let _v1106 = v1113 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v1114 : Result<std_path_PathBuf, string> = match v1104 with Ok x -> Ok x | Error x -> Error (v1105 x)
                                                                                                                                                            let _v1106 = v1114 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v1115 : Result<std_path_PathBuf, string> = match v1104 with Ok x -> Ok x | Error x -> Error (v1105 x)
                                                                                                                                                            let _v1106 = v1115 
                                                                                                                                                            #endif
                                                                                                                                                            let v1116 : Result<std_path_PathBuf, string> = _v1106 
                                                                                                                                                            let v1119 : US8 = match v1116 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                                                            match v1119 with
                                                                                                                                                            | US8_1(v1222) -> (* Error *)
                                                                                                                                                                let v1223 : string = $"file_system.read_link / error': {v1222} / error: {v481} / name: {v482}"
                                                                                                                                                                let v1224 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v1225 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v1226 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1223 v1225 
                                                                                                                                                                let _v1224 = v1226 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v1227 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v1228 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1223 v1227 
                                                                                                                                                                let _v1224 = v1228 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v1229 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v1230 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1223 v1229 
                                                                                                                                                                let _v1224 = v1230 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v1231 : std_io_Error = v1223 
                                                                                                                                                                let _v1224 = v1231 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v1232 : std_io_Error = v1223 
                                                                                                                                                                let _v1224 = v1232 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v1233 : std_io_Error = v1223 
                                                                                                                                                                let _v1224 = v1233 
                                                                                                                                                                #endif
                                                                                                                                                                let v1234 : std_io_Error = _v1224 
                                                                                                                                                                let v1237 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v1238 : string = "Err($0)"
                                                                                                                                                                let v1239 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1234 v1238 
                                                                                                                                                                let _v1237 = v1239 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v1240 : string = "Err($0)"
                                                                                                                                                                let v1241 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1234 v1240 
                                                                                                                                                                let _v1237 = v1241 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v1242 : string = "Err($0)"
                                                                                                                                                                let v1243 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1234 v1242 
                                                                                                                                                                let _v1237 = v1243 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v1244 : Result<std_path_PathBuf, std_io_Error> = v1234 |> Error
                                                                                                                                                                let _v1237 = v1244 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v1245 : Result<std_path_PathBuf, std_io_Error> = v1234 |> Error
                                                                                                                                                                let _v1237 = v1245 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v1246 : Result<std_path_PathBuf, std_io_Error> = v1234 |> Error
                                                                                                                                                                let _v1237 = v1246 
                                                                                                                                                                #endif
                                                                                                                                                                let v1247 : Result<std_path_PathBuf, std_io_Error> = _v1237 
                                                                                                                                                                v1247
                                                                                                                                                            | US8_0(v1120) -> (* Ok *)
                                                                                                                                                                let v1121 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v1122 : string = "$0.display()"
                                                                                                                                                                let v1123 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1120 v1122 
                                                                                                                                                                let _v1121 = v1123 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v1124 : string = "$0.display()"
                                                                                                                                                                let v1125 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1120 v1124 
                                                                                                                                                                let _v1121 = v1125 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v1126 : string = "$0.display()"
                                                                                                                                                                let v1127 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1120 v1126 
                                                                                                                                                                let _v1121 = v1127 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v1128 : std_path_Display = v1120 |> unbox<std_path_Display>
                                                                                                                                                                let _v1121 = v1128 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v1131 : std_path_Display = v1120 |> unbox<std_path_Display>
                                                                                                                                                                let _v1121 = v1131 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v1134 : std_path_Display = v1120 |> unbox<std_path_Display>
                                                                                                                                                                let _v1121 = v1134 
                                                                                                                                                                #endif
                                                                                                                                                                let v1137 : std_path_Display = _v1121 
                                                                                                                                                                let v1142 : string = v1137 |> string 
                                                                                                                                                                let v1145 : string = method26(v1142, v482)
                                                                                                                                                                let v1146 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v1147 : string = "&*$0"
                                                                                                                                                                let v1148 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1145 v1147 
                                                                                                                                                                let _v1146 = v1148 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v1149 : string = "&*$0"
                                                                                                                                                                let v1150 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1145 v1149 
                                                                                                                                                                let _v1146 = v1150 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v1151 : string = "&*$0"
                                                                                                                                                                let v1152 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1145 v1151 
                                                                                                                                                                let _v1146 = v1152 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v1153 : Ref<Str> = v1145 |> unbox<Ref<Str>>
                                                                                                                                                                let _v1146 = v1153 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v1156 : Ref<Str> = v1145 |> unbox<Ref<Str>>
                                                                                                                                                                let _v1146 = v1156 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v1159 : Ref<Str> = v1145 |> unbox<Ref<Str>>
                                                                                                                                                                let _v1146 = v1159 
                                                                                                                                                                #endif
                                                                                                                                                                let v1162 : Ref<Str> = _v1146 
                                                                                                                                                                let v1167 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v1168 : string = "String::from($0)"
                                                                                                                                                                let v1169 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1162 v1168 
                                                                                                                                                                let _v1167 = v1169 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v1170 : string = "String::from($0)"
                                                                                                                                                                let v1171 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1162 v1170 
                                                                                                                                                                let _v1167 = v1171 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v1172 : string = "String::from($0)"
                                                                                                                                                                let v1173 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1162 v1172 
                                                                                                                                                                let _v1167 = v1173 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v1174 : std_string_String = v1162 |> unbox<std_string_String>
                                                                                                                                                                let _v1167 = v1174 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v1177 : std_string_String = v1162 |> unbox<std_string_String>
                                                                                                                                                                let _v1167 = v1177 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v1180 : std_string_String = v1162 |> unbox<std_string_String>
                                                                                                                                                                let _v1167 = v1180 
                                                                                                                                                                #endif
                                                                                                                                                                let v1183 : std_string_String = _v1167 
                                                                                                                                                                let v1188 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v1189 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                let v1190 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1183 v1189 
                                                                                                                                                                let _v1188 = v1190 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v1191 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                let v1192 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1183 v1191 
                                                                                                                                                                let _v1188 = v1192 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v1193 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                let v1194 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1183 v1193 
                                                                                                                                                                let _v1188 = v1194 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v1195 : std_path_PathBuf = v1183 |> std_path_PathBuf 
                                                                                                                                                                let _v1188 = v1195 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v1198 : std_path_PathBuf = v1183 |> std_path_PathBuf 
                                                                                                                                                                let _v1188 = v1198 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v1201 : std_path_PathBuf = v1183 |> std_path_PathBuf 
                                                                                                                                                                let _v1188 = v1201 
                                                                                                                                                                #endif
                                                                                                                                                                let v1204 : std_path_PathBuf = _v1188 
                                                                                                                                                                let v1209 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v1210 : string = "Ok($0)"
                                                                                                                                                                let v1211 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1204 v1210 
                                                                                                                                                                let _v1209 = v1211 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v1212 : string = "Ok($0)"
                                                                                                                                                                let v1213 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1204 v1212 
                                                                                                                                                                let _v1209 = v1213 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v1214 : string = "Ok($0)"
                                                                                                                                                                let v1215 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1204 v1214 
                                                                                                                                                                let _v1209 = v1215 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v1216 : Result<std_path_PathBuf, std_io_Error> = v1204 |> Ok
                                                                                                                                                                let _v1209 = v1216 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v1217 : Result<std_path_PathBuf, std_io_Error> = v1204 |> Ok
                                                                                                                                                                let _v1209 = v1217 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v1218 : Result<std_path_PathBuf, std_io_Error> = v1204 |> Ok
                                                                                                                                                                let _v1209 = v1218 
                                                                                                                                                                #endif
                                                                                                                                                                let v1219 : Result<std_path_PathBuf, std_io_Error> = _v1209 
                                                                                                                                                                v1219
                                                                                                                                                        else
                                                                                                                                                            let v1252 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v481} / path': {v446} / name: {v482}"
                                                                                                                                                            let v1253 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v1254 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v1255 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1252 v1254 
                                                                                                                                                            let _v1253 = v1255 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v1256 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v1257 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1252 v1256 
                                                                                                                                                            let _v1253 = v1257 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v1258 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v1259 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1252 v1258 
                                                                                                                                                            let _v1253 = v1259 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v1260 : std_io_Error = v1252 
                                                                                                                                                            let _v1253 = v1260 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v1261 : std_io_Error = v1252 
                                                                                                                                                            let _v1253 = v1261 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v1262 : std_io_Error = v1252 
                                                                                                                                                            let _v1253 = v1262 
                                                                                                                                                            #endif
                                                                                                                                                            let v1263 : std_io_Error = _v1253 
                                                                                                                                                            let v1266 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v1267 : string = "Err($0)"
                                                                                                                                                            let v1268 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1263 v1267 
                                                                                                                                                            let _v1266 = v1268 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v1269 : string = "Err($0)"
                                                                                                                                                            let v1270 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1263 v1269 
                                                                                                                                                            let _v1266 = v1270 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v1271 : string = "Err($0)"
                                                                                                                                                            let v1272 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1263 v1271 
                                                                                                                                                            let _v1266 = v1272 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v1273 : Result<std_path_PathBuf, std_io_Error> = v1263 |> Error
                                                                                                                                                            let _v1266 = v1273 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v1274 : Result<std_path_PathBuf, std_io_Error> = v1263 |> Error
                                                                                                                                                            let _v1266 = v1274 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v1275 : Result<std_path_PathBuf, std_io_Error> = v1263 |> Error
                                                                                                                                                            let _v1266 = v1275 
                                                                                                                                                            #endif
                                                                                                                                                            let v1276 : Result<std_path_PathBuf, std_io_Error> = _v1266 
                                                                                                                                                            v1276
                                                                                                                                                    | _ ->
                                                                                                                                                        let v1280 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v481} / path': {v446} / name: {v482}"
                                                                                                                                                        let v1281 : unit = ()
                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                        let v1282 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                        let v1283 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1280 v1282 
                                                                                                                                                        let _v1281 = v1283 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                        let v1284 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                        let v1285 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1280 v1284 
                                                                                                                                                        let _v1281 = v1285 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                        let v1286 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                        let v1287 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1280 v1286 
                                                                                                                                                        let _v1281 = v1287 
                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                        let v1288 : std_io_Error = v1280 
                                                                                                                                                        let _v1281 = v1288 
                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                        let v1289 : std_io_Error = v1280 
                                                                                                                                                        let _v1281 = v1289 
                                                                                                                                                        #endif
#else
                                                                                                                                                        let v1290 : std_io_Error = v1280 
                                                                                                                                                        let _v1281 = v1290 
                                                                                                                                                        #endif
                                                                                                                                                        let v1291 : std_io_Error = _v1281 
                                                                                                                                                        let v1294 : unit = ()
                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                        let v1295 : string = "Err($0)"
                                                                                                                                                        let v1296 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1291 v1295 
                                                                                                                                                        let _v1294 = v1296 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                        let v1297 : string = "Err($0)"
                                                                                                                                                        let v1298 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1291 v1297 
                                                                                                                                                        let _v1294 = v1298 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                        let v1299 : string = "Err($0)"
                                                                                                                                                        let v1300 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1291 v1299 
                                                                                                                                                        let _v1294 = v1300 
                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                        let v1301 : Result<std_path_PathBuf, std_io_Error> = v1291 |> Error
                                                                                                                                                        let _v1294 = v1301 
                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                        let v1302 : Result<std_path_PathBuf, std_io_Error> = v1291 |> Error
                                                                                                                                                        let _v1294 = v1302 
                                                                                                                                                        #endif
#else
                                                                                                                                                        let v1303 : Result<std_path_PathBuf, std_io_Error> = v1291 |> Error
                                                                                                                                                        let _v1294 = v1303 
                                                                                                                                                        #endif
                                                                                                                                                        let v1304 : Result<std_path_PathBuf, std_io_Error> = _v1294 
                                                                                                                                                        v1304
                                                                                                                                                | US8_0(v467) -> (* Ok *)
                                                                                                                                                    let v468 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v469 : string = "Ok($0)"
                                                                                                                                                    let v470 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v467 v469 
                                                                                                                                                    let _v468 = v470 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v471 : string = "Ok($0)"
                                                                                                                                                    let v472 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v467 v471 
                                                                                                                                                    let _v468 = v472 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v473 : string = "Ok($0)"
                                                                                                                                                    let v474 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v467 v473 
                                                                                                                                                    let _v468 = v474 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v475 : Result<std_path_PathBuf, std_io_Error> = v467 |> Ok
                                                                                                                                                    let _v468 = v475 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v476 : Result<std_path_PathBuf, std_io_Error> = v467 |> Ok
                                                                                                                                                    let _v468 = v476 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v477 : Result<std_path_PathBuf, std_io_Error> = v467 |> Ok
                                                                                                                                                    let _v468 = v477 
                                                                                                                                                    #endif
                                                                                                                                                    let v478 : Result<std_path_PathBuf, std_io_Error> = _v468 
                                                                                                                                                    v478
                                                                                                                                            let v1310 : (std_io_Error -> string) = method41()
                                                                                                                                            let v1311 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v1312 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v1313 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1309, v1310) v1312 
                                                                                                                                            let _v1311 = v1313 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v1314 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v1315 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1309, v1310) v1314 
                                                                                                                                            let _v1311 = v1315 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v1316 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v1317 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1309, v1310) v1316 
                                                                                                                                            let _v1311 = v1317 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v1318 : Result<std_path_PathBuf, string> = match v1309 with Ok x -> Ok x | Error x -> Error (v1310 x)
                                                                                                                                            let _v1311 = v1318 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v1319 : Result<std_path_PathBuf, string> = match v1309 with Ok x -> Ok x | Error x -> Error (v1310 x)
                                                                                                                                            let _v1311 = v1319 
                                                                                                                                            #endif
#else
                                                                                                                                            let v1320 : Result<std_path_PathBuf, string> = match v1309 with Ok x -> Ok x | Error x -> Error (v1310 x)
                                                                                                                                            let _v1311 = v1320 
                                                                                                                                            #endif
                                                                                                                                            let v1321 : Result<std_path_PathBuf, string> = _v1311 
                                                                                                                                            let v1324 : US8 = match v1321 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                                            match v1324 with
                                                                                                                                            | US8_1(v1427) -> (* Error *)
                                                                                                                                                let v1428 : string = $"file_system.read_link / error': {v1427} / error: {v426} / name: {v427}"
                                                                                                                                                let v1429 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v1430 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v1431 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1428 v1430 
                                                                                                                                                let _v1429 = v1431 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v1432 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v1433 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1428 v1432 
                                                                                                                                                let _v1429 = v1433 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v1434 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v1435 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1428 v1434 
                                                                                                                                                let _v1429 = v1435 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v1436 : std_io_Error = v1428 
                                                                                                                                                let _v1429 = v1436 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v1437 : std_io_Error = v1428 
                                                                                                                                                let _v1429 = v1437 
                                                                                                                                                #endif
#else
                                                                                                                                                let v1438 : std_io_Error = v1428 
                                                                                                                                                let _v1429 = v1438 
                                                                                                                                                #endif
                                                                                                                                                let v1439 : std_io_Error = _v1429 
                                                                                                                                                let v1442 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v1443 : string = "Err($0)"
                                                                                                                                                let v1444 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1439 v1443 
                                                                                                                                                let _v1442 = v1444 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v1445 : string = "Err($0)"
                                                                                                                                                let v1446 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1439 v1445 
                                                                                                                                                let _v1442 = v1446 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v1447 : string = "Err($0)"
                                                                                                                                                let v1448 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1439 v1447 
                                                                                                                                                let _v1442 = v1448 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v1449 : Result<std_path_PathBuf, std_io_Error> = v1439 |> Error
                                                                                                                                                let _v1442 = v1449 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v1450 : Result<std_path_PathBuf, std_io_Error> = v1439 |> Error
                                                                                                                                                let _v1442 = v1450 
                                                                                                                                                #endif
#else
                                                                                                                                                let v1451 : Result<std_path_PathBuf, std_io_Error> = v1439 |> Error
                                                                                                                                                let _v1442 = v1451 
                                                                                                                                                #endif
                                                                                                                                                let v1452 : Result<std_path_PathBuf, std_io_Error> = _v1442 
                                                                                                                                                v1452
                                                                                                                                            | US8_0(v1325) -> (* Ok *)
                                                                                                                                                let v1326 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v1327 : string = "$0.display()"
                                                                                                                                                let v1328 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1325 v1327 
                                                                                                                                                let _v1326 = v1328 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v1329 : string = "$0.display()"
                                                                                                                                                let v1330 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1325 v1329 
                                                                                                                                                let _v1326 = v1330 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v1331 : string = "$0.display()"
                                                                                                                                                let v1332 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1325 v1331 
                                                                                                                                                let _v1326 = v1332 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v1333 : std_path_Display = v1325 |> unbox<std_path_Display>
                                                                                                                                                let _v1326 = v1333 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v1336 : std_path_Display = v1325 |> unbox<std_path_Display>
                                                                                                                                                let _v1326 = v1336 
                                                                                                                                                #endif
#else
                                                                                                                                                let v1339 : std_path_Display = v1325 |> unbox<std_path_Display>
                                                                                                                                                let _v1326 = v1339 
                                                                                                                                                #endif
                                                                                                                                                let v1342 : std_path_Display = _v1326 
                                                                                                                                                let v1347 : string = v1342 |> string 
                                                                                                                                                let v1350 : string = method26(v1347, v427)
                                                                                                                                                let v1351 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v1352 : string = "&*$0"
                                                                                                                                                let v1353 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1350 v1352 
                                                                                                                                                let _v1351 = v1353 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v1354 : string = "&*$0"
                                                                                                                                                let v1355 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1350 v1354 
                                                                                                                                                let _v1351 = v1355 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v1356 : string = "&*$0"
                                                                                                                                                let v1357 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1350 v1356 
                                                                                                                                                let _v1351 = v1357 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v1358 : Ref<Str> = v1350 |> unbox<Ref<Str>>
                                                                                                                                                let _v1351 = v1358 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v1361 : Ref<Str> = v1350 |> unbox<Ref<Str>>
                                                                                                                                                let _v1351 = v1361 
                                                                                                                                                #endif
#else
                                                                                                                                                let v1364 : Ref<Str> = v1350 |> unbox<Ref<Str>>
                                                                                                                                                let _v1351 = v1364 
                                                                                                                                                #endif
                                                                                                                                                let v1367 : Ref<Str> = _v1351 
                                                                                                                                                let v1372 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v1373 : string = "String::from($0)"
                                                                                                                                                let v1374 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1367 v1373 
                                                                                                                                                let _v1372 = v1374 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v1375 : string = "String::from($0)"
                                                                                                                                                let v1376 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1367 v1375 
                                                                                                                                                let _v1372 = v1376 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v1377 : string = "String::from($0)"
                                                                                                                                                let v1378 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1367 v1377 
                                                                                                                                                let _v1372 = v1378 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v1379 : std_string_String = v1367 |> unbox<std_string_String>
                                                                                                                                                let _v1372 = v1379 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v1382 : std_string_String = v1367 |> unbox<std_string_String>
                                                                                                                                                let _v1372 = v1382 
                                                                                                                                                #endif
#else
                                                                                                                                                let v1385 : std_string_String = v1367 |> unbox<std_string_String>
                                                                                                                                                let _v1372 = v1385 
                                                                                                                                                #endif
                                                                                                                                                let v1388 : std_string_String = _v1372 
                                                                                                                                                let v1393 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v1394 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                let v1395 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1388 v1394 
                                                                                                                                                let _v1393 = v1395 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v1396 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                let v1397 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1388 v1396 
                                                                                                                                                let _v1393 = v1397 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v1398 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                let v1399 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1388 v1398 
                                                                                                                                                let _v1393 = v1399 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v1400 : std_path_PathBuf = v1388 |> std_path_PathBuf 
                                                                                                                                                let _v1393 = v1400 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v1403 : std_path_PathBuf = v1388 |> std_path_PathBuf 
                                                                                                                                                let _v1393 = v1403 
                                                                                                                                                #endif
#else
                                                                                                                                                let v1406 : std_path_PathBuf = v1388 |> std_path_PathBuf 
                                                                                                                                                let _v1393 = v1406 
                                                                                                                                                #endif
                                                                                                                                                let v1409 : std_path_PathBuf = _v1393 
                                                                                                                                                let v1414 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v1415 : string = "Ok($0)"
                                                                                                                                                let v1416 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1409 v1415 
                                                                                                                                                let _v1414 = v1416 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v1417 : string = "Ok($0)"
                                                                                                                                                let v1418 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1409 v1417 
                                                                                                                                                let _v1414 = v1418 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v1419 : string = "Ok($0)"
                                                                                                                                                let v1420 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1409 v1419 
                                                                                                                                                let _v1414 = v1420 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v1421 : Result<std_path_PathBuf, std_io_Error> = v1409 |> Ok
                                                                                                                                                let _v1414 = v1421 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v1422 : Result<std_path_PathBuf, std_io_Error> = v1409 |> Ok
                                                                                                                                                let _v1414 = v1422 
                                                                                                                                                #endif
#else
                                                                                                                                                let v1423 : Result<std_path_PathBuf, std_io_Error> = v1409 |> Ok
                                                                                                                                                let _v1414 = v1423 
                                                                                                                                                #endif
                                                                                                                                                let v1424 : Result<std_path_PathBuf, std_io_Error> = _v1414 
                                                                                                                                                v1424
                                                                                                                                        else
                                                                                                                                            let v1457 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v426} / path': {v391} / name: {v427}"
                                                                                                                                            let v1458 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v1459 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v1460 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1457 v1459 
                                                                                                                                            let _v1458 = v1460 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v1461 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v1462 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1457 v1461 
                                                                                                                                            let _v1458 = v1462 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v1463 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v1464 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1457 v1463 
                                                                                                                                            let _v1458 = v1464 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v1465 : std_io_Error = v1457 
                                                                                                                                            let _v1458 = v1465 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v1466 : std_io_Error = v1457 
                                                                                                                                            let _v1458 = v1466 
                                                                                                                                            #endif
#else
                                                                                                                                            let v1467 : std_io_Error = v1457 
                                                                                                                                            let _v1458 = v1467 
                                                                                                                                            #endif
                                                                                                                                            let v1468 : std_io_Error = _v1458 
                                                                                                                                            let v1471 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v1472 : string = "Err($0)"
                                                                                                                                            let v1473 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1468 v1472 
                                                                                                                                            let _v1471 = v1473 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v1474 : string = "Err($0)"
                                                                                                                                            let v1475 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1468 v1474 
                                                                                                                                            let _v1471 = v1475 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v1476 : string = "Err($0)"
                                                                                                                                            let v1477 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1468 v1476 
                                                                                                                                            let _v1471 = v1477 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v1478 : Result<std_path_PathBuf, std_io_Error> = v1468 |> Error
                                                                                                                                            let _v1471 = v1478 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v1479 : Result<std_path_PathBuf, std_io_Error> = v1468 |> Error
                                                                                                                                            let _v1471 = v1479 
                                                                                                                                            #endif
#else
                                                                                                                                            let v1480 : Result<std_path_PathBuf, std_io_Error> = v1468 |> Error
                                                                                                                                            let _v1471 = v1480 
                                                                                                                                            #endif
                                                                                                                                            let v1481 : Result<std_path_PathBuf, std_io_Error> = _v1471 
                                                                                                                                            v1481
                                                                                                                                    | _ ->
                                                                                                                                        let v1485 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v426} / path': {v391} / name: {v427}"
                                                                                                                                        let v1486 : unit = ()
                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                        let v1487 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                        let v1488 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1485 v1487 
                                                                                                                                        let _v1486 = v1488 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                        let v1489 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                        let v1490 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1485 v1489 
                                                                                                                                        let _v1486 = v1490 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                        let v1491 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                        let v1492 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1485 v1491 
                                                                                                                                        let _v1486 = v1492 
                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                        let v1493 : std_io_Error = v1485 
                                                                                                                                        let _v1486 = v1493 
                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                        let v1494 : std_io_Error = v1485 
                                                                                                                                        let _v1486 = v1494 
                                                                                                                                        #endif
#else
                                                                                                                                        let v1495 : std_io_Error = v1485 
                                                                                                                                        let _v1486 = v1495 
                                                                                                                                        #endif
                                                                                                                                        let v1496 : std_io_Error = _v1486 
                                                                                                                                        let v1499 : unit = ()
                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                        let v1500 : string = "Err($0)"
                                                                                                                                        let v1501 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1496 v1500 
                                                                                                                                        let _v1499 = v1501 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                        let v1502 : string = "Err($0)"
                                                                                                                                        let v1503 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1496 v1502 
                                                                                                                                        let _v1499 = v1503 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                        let v1504 : string = "Err($0)"
                                                                                                                                        let v1505 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1496 v1504 
                                                                                                                                        let _v1499 = v1505 
                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                        let v1506 : Result<std_path_PathBuf, std_io_Error> = v1496 |> Error
                                                                                                                                        let _v1499 = v1506 
                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                        let v1507 : Result<std_path_PathBuf, std_io_Error> = v1496 |> Error
                                                                                                                                        let _v1499 = v1507 
                                                                                                                                        #endif
#else
                                                                                                                                        let v1508 : Result<std_path_PathBuf, std_io_Error> = v1496 |> Error
                                                                                                                                        let _v1499 = v1508 
                                                                                                                                        #endif
                                                                                                                                        let v1509 : Result<std_path_PathBuf, std_io_Error> = _v1499 
                                                                                                                                        v1509
                                                                                                                                | US8_0(v412) -> (* Ok *)
                                                                                                                                    let v413 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v414 : string = "Ok($0)"
                                                                                                                                    let v415 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v412 v414 
                                                                                                                                    let _v413 = v415 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v416 : string = "Ok($0)"
                                                                                                                                    let v417 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v412 v416 
                                                                                                                                    let _v413 = v417 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v418 : string = "Ok($0)"
                                                                                                                                    let v419 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v412 v418 
                                                                                                                                    let _v413 = v419 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v420 : Result<std_path_PathBuf, std_io_Error> = v412 |> Ok
                                                                                                                                    let _v413 = v420 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v421 : Result<std_path_PathBuf, std_io_Error> = v412 |> Ok
                                                                                                                                    let _v413 = v421 
                                                                                                                                    #endif
#else
                                                                                                                                    let v422 : Result<std_path_PathBuf, std_io_Error> = v412 |> Ok
                                                                                                                                    let _v413 = v422 
                                                                                                                                    #endif
                                                                                                                                    let v423 : Result<std_path_PathBuf, std_io_Error> = _v413 
                                                                                                                                    v423
                                                                                                                            let v1515 : (std_io_Error -> string) = method41()
                                                                                                                            let v1516 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v1517 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v1518 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1514, v1515) v1517 
                                                                                                                            let _v1516 = v1518 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v1519 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v1520 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1514, v1515) v1519 
                                                                                                                            let _v1516 = v1520 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v1521 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v1522 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1514, v1515) v1521 
                                                                                                                            let _v1516 = v1522 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v1523 : Result<std_path_PathBuf, string> = match v1514 with Ok x -> Ok x | Error x -> Error (v1515 x)
                                                                                                                            let _v1516 = v1523 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v1524 : Result<std_path_PathBuf, string> = match v1514 with Ok x -> Ok x | Error x -> Error (v1515 x)
                                                                                                                            let _v1516 = v1524 
                                                                                                                            #endif
#else
                                                                                                                            let v1525 : Result<std_path_PathBuf, string> = match v1514 with Ok x -> Ok x | Error x -> Error (v1515 x)
                                                                                                                            let _v1516 = v1525 
                                                                                                                            #endif
                                                                                                                            let v1526 : Result<std_path_PathBuf, string> = _v1516 
                                                                                                                            let v1529 : US8 = match v1526 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                            match v1529 with
                                                                                                                            | US8_1(v1632) -> (* Error *)
                                                                                                                                let v1633 : string = $"file_system.read_link / error': {v1632} / error: {v371} / name: {v372}"
                                                                                                                                let v1634 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v1635 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v1636 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1633 v1635 
                                                                                                                                let _v1634 = v1636 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v1637 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v1638 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1633 v1637 
                                                                                                                                let _v1634 = v1638 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v1639 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v1640 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1633 v1639 
                                                                                                                                let _v1634 = v1640 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v1641 : std_io_Error = v1633 
                                                                                                                                let _v1634 = v1641 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v1642 : std_io_Error = v1633 
                                                                                                                                let _v1634 = v1642 
                                                                                                                                #endif
#else
                                                                                                                                let v1643 : std_io_Error = v1633 
                                                                                                                                let _v1634 = v1643 
                                                                                                                                #endif
                                                                                                                                let v1644 : std_io_Error = _v1634 
                                                                                                                                let v1647 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v1648 : string = "Err($0)"
                                                                                                                                let v1649 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1644 v1648 
                                                                                                                                let _v1647 = v1649 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v1650 : string = "Err($0)"
                                                                                                                                let v1651 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1644 v1650 
                                                                                                                                let _v1647 = v1651 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v1652 : string = "Err($0)"
                                                                                                                                let v1653 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1644 v1652 
                                                                                                                                let _v1647 = v1653 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v1654 : Result<std_path_PathBuf, std_io_Error> = v1644 |> Error
                                                                                                                                let _v1647 = v1654 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v1655 : Result<std_path_PathBuf, std_io_Error> = v1644 |> Error
                                                                                                                                let _v1647 = v1655 
                                                                                                                                #endif
#else
                                                                                                                                let v1656 : Result<std_path_PathBuf, std_io_Error> = v1644 |> Error
                                                                                                                                let _v1647 = v1656 
                                                                                                                                #endif
                                                                                                                                let v1657 : Result<std_path_PathBuf, std_io_Error> = _v1647 
                                                                                                                                v1657
                                                                                                                            | US8_0(v1530) -> (* Ok *)
                                                                                                                                let v1531 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v1532 : string = "$0.display()"
                                                                                                                                let v1533 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1530 v1532 
                                                                                                                                let _v1531 = v1533 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v1534 : string = "$0.display()"
                                                                                                                                let v1535 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1530 v1534 
                                                                                                                                let _v1531 = v1535 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v1536 : string = "$0.display()"
                                                                                                                                let v1537 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1530 v1536 
                                                                                                                                let _v1531 = v1537 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v1538 : std_path_Display = v1530 |> unbox<std_path_Display>
                                                                                                                                let _v1531 = v1538 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v1541 : std_path_Display = v1530 |> unbox<std_path_Display>
                                                                                                                                let _v1531 = v1541 
                                                                                                                                #endif
#else
                                                                                                                                let v1544 : std_path_Display = v1530 |> unbox<std_path_Display>
                                                                                                                                let _v1531 = v1544 
                                                                                                                                #endif
                                                                                                                                let v1547 : std_path_Display = _v1531 
                                                                                                                                let v1552 : string = v1547 |> string 
                                                                                                                                let v1555 : string = method26(v1552, v372)
                                                                                                                                let v1556 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v1557 : string = "&*$0"
                                                                                                                                let v1558 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1555 v1557 
                                                                                                                                let _v1556 = v1558 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v1559 : string = "&*$0"
                                                                                                                                let v1560 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1555 v1559 
                                                                                                                                let _v1556 = v1560 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v1561 : string = "&*$0"
                                                                                                                                let v1562 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1555 v1561 
                                                                                                                                let _v1556 = v1562 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v1563 : Ref<Str> = v1555 |> unbox<Ref<Str>>
                                                                                                                                let _v1556 = v1563 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v1566 : Ref<Str> = v1555 |> unbox<Ref<Str>>
                                                                                                                                let _v1556 = v1566 
                                                                                                                                #endif
#else
                                                                                                                                let v1569 : Ref<Str> = v1555 |> unbox<Ref<Str>>
                                                                                                                                let _v1556 = v1569 
                                                                                                                                #endif
                                                                                                                                let v1572 : Ref<Str> = _v1556 
                                                                                                                                let v1577 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v1578 : string = "String::from($0)"
                                                                                                                                let v1579 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1572 v1578 
                                                                                                                                let _v1577 = v1579 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v1580 : string = "String::from($0)"
                                                                                                                                let v1581 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1572 v1580 
                                                                                                                                let _v1577 = v1581 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v1582 : string = "String::from($0)"
                                                                                                                                let v1583 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1572 v1582 
                                                                                                                                let _v1577 = v1583 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v1584 : std_string_String = v1572 |> unbox<std_string_String>
                                                                                                                                let _v1577 = v1584 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v1587 : std_string_String = v1572 |> unbox<std_string_String>
                                                                                                                                let _v1577 = v1587 
                                                                                                                                #endif
#else
                                                                                                                                let v1590 : std_string_String = v1572 |> unbox<std_string_String>
                                                                                                                                let _v1577 = v1590 
                                                                                                                                #endif
                                                                                                                                let v1593 : std_string_String = _v1577 
                                                                                                                                let v1598 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v1599 : string = "std::path::PathBuf::from($0)"
                                                                                                                                let v1600 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1593 v1599 
                                                                                                                                let _v1598 = v1600 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v1601 : string = "std::path::PathBuf::from($0)"
                                                                                                                                let v1602 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1593 v1601 
                                                                                                                                let _v1598 = v1602 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v1603 : string = "std::path::PathBuf::from($0)"
                                                                                                                                let v1604 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1593 v1603 
                                                                                                                                let _v1598 = v1604 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v1605 : std_path_PathBuf = v1593 |> std_path_PathBuf 
                                                                                                                                let _v1598 = v1605 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v1608 : std_path_PathBuf = v1593 |> std_path_PathBuf 
                                                                                                                                let _v1598 = v1608 
                                                                                                                                #endif
#else
                                                                                                                                let v1611 : std_path_PathBuf = v1593 |> std_path_PathBuf 
                                                                                                                                let _v1598 = v1611 
                                                                                                                                #endif
                                                                                                                                let v1614 : std_path_PathBuf = _v1598 
                                                                                                                                let v1619 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v1620 : string = "Ok($0)"
                                                                                                                                let v1621 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1614 v1620 
                                                                                                                                let _v1619 = v1621 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v1622 : string = "Ok($0)"
                                                                                                                                let v1623 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1614 v1622 
                                                                                                                                let _v1619 = v1623 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v1624 : string = "Ok($0)"
                                                                                                                                let v1625 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1614 v1624 
                                                                                                                                let _v1619 = v1625 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v1626 : Result<std_path_PathBuf, std_io_Error> = v1614 |> Ok
                                                                                                                                let _v1619 = v1626 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v1627 : Result<std_path_PathBuf, std_io_Error> = v1614 |> Ok
                                                                                                                                let _v1619 = v1627 
                                                                                                                                #endif
#else
                                                                                                                                let v1628 : Result<std_path_PathBuf, std_io_Error> = v1614 |> Ok
                                                                                                                                let _v1619 = v1628 
                                                                                                                                #endif
                                                                                                                                let v1629 : Result<std_path_PathBuf, std_io_Error> = _v1619 
                                                                                                                                v1629
                                                                                                                        else
                                                                                                                            let v1662 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v371} / path': {v336} / name: {v372}"
                                                                                                                            let v1663 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v1664 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v1665 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1662 v1664 
                                                                                                                            let _v1663 = v1665 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v1666 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v1667 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1662 v1666 
                                                                                                                            let _v1663 = v1667 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v1668 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v1669 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1662 v1668 
                                                                                                                            let _v1663 = v1669 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v1670 : std_io_Error = v1662 
                                                                                                                            let _v1663 = v1670 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v1671 : std_io_Error = v1662 
                                                                                                                            let _v1663 = v1671 
                                                                                                                            #endif
#else
                                                                                                                            let v1672 : std_io_Error = v1662 
                                                                                                                            let _v1663 = v1672 
                                                                                                                            #endif
                                                                                                                            let v1673 : std_io_Error = _v1663 
                                                                                                                            let v1676 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v1677 : string = "Err($0)"
                                                                                                                            let v1678 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1673 v1677 
                                                                                                                            let _v1676 = v1678 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v1679 : string = "Err($0)"
                                                                                                                            let v1680 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1673 v1679 
                                                                                                                            let _v1676 = v1680 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v1681 : string = "Err($0)"
                                                                                                                            let v1682 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1673 v1681 
                                                                                                                            let _v1676 = v1682 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v1683 : Result<std_path_PathBuf, std_io_Error> = v1673 |> Error
                                                                                                                            let _v1676 = v1683 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v1684 : Result<std_path_PathBuf, std_io_Error> = v1673 |> Error
                                                                                                                            let _v1676 = v1684 
                                                                                                                            #endif
#else
                                                                                                                            let v1685 : Result<std_path_PathBuf, std_io_Error> = v1673 |> Error
                                                                                                                            let _v1676 = v1685 
                                                                                                                            #endif
                                                                                                                            let v1686 : Result<std_path_PathBuf, std_io_Error> = _v1676 
                                                                                                                            v1686
                                                                                                                    | _ ->
                                                                                                                        let v1690 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v371} / path': {v336} / name: {v372}"
                                                                                                                        let v1691 : unit = ()
                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                        let v1692 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                        let v1693 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1690 v1692 
                                                                                                                        let _v1691 = v1693 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                        let v1694 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                        let v1695 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1690 v1694 
                                                                                                                        let _v1691 = v1695 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                        let v1696 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                        let v1697 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1690 v1696 
                                                                                                                        let _v1691 = v1697 
                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                        let v1698 : std_io_Error = v1690 
                                                                                                                        let _v1691 = v1698 
                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                        let v1699 : std_io_Error = v1690 
                                                                                                                        let _v1691 = v1699 
                                                                                                                        #endif
#else
                                                                                                                        let v1700 : std_io_Error = v1690 
                                                                                                                        let _v1691 = v1700 
                                                                                                                        #endif
                                                                                                                        let v1701 : std_io_Error = _v1691 
                                                                                                                        let v1704 : unit = ()
                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                        let v1705 : string = "Err($0)"
                                                                                                                        let v1706 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1701 v1705 
                                                                                                                        let _v1704 = v1706 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                        let v1707 : string = "Err($0)"
                                                                                                                        let v1708 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1701 v1707 
                                                                                                                        let _v1704 = v1708 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                        let v1709 : string = "Err($0)"
                                                                                                                        let v1710 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1701 v1709 
                                                                                                                        let _v1704 = v1710 
                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                        let v1711 : Result<std_path_PathBuf, std_io_Error> = v1701 |> Error
                                                                                                                        let _v1704 = v1711 
                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                        let v1712 : Result<std_path_PathBuf, std_io_Error> = v1701 |> Error
                                                                                                                        let _v1704 = v1712 
                                                                                                                        #endif
#else
                                                                                                                        let v1713 : Result<std_path_PathBuf, std_io_Error> = v1701 |> Error
                                                                                                                        let _v1704 = v1713 
                                                                                                                        #endif
                                                                                                                        let v1714 : Result<std_path_PathBuf, std_io_Error> = _v1704 
                                                                                                                        v1714
                                                                                                                | US8_0(v357) -> (* Ok *)
                                                                                                                    let v358 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v359 : string = "Ok($0)"
                                                                                                                    let v360 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v357 v359 
                                                                                                                    let _v358 = v360 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v361 : string = "Ok($0)"
                                                                                                                    let v362 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v357 v361 
                                                                                                                    let _v358 = v362 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v363 : string = "Ok($0)"
                                                                                                                    let v364 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v357 v363 
                                                                                                                    let _v358 = v364 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v365 : Result<std_path_PathBuf, std_io_Error> = v357 |> Ok
                                                                                                                    let _v358 = v365 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v366 : Result<std_path_PathBuf, std_io_Error> = v357 |> Ok
                                                                                                                    let _v358 = v366 
                                                                                                                    #endif
#else
                                                                                                                    let v367 : Result<std_path_PathBuf, std_io_Error> = v357 |> Ok
                                                                                                                    let _v358 = v367 
                                                                                                                    #endif
                                                                                                                    let v368 : Result<std_path_PathBuf, std_io_Error> = _v358 
                                                                                                                    v368
                                                                                                            let v1720 : (std_io_Error -> string) = method41()
                                                                                                            let v1721 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v1722 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v1723 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1719, v1720) v1722 
                                                                                                            let _v1721 = v1723 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v1724 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v1725 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1719, v1720) v1724 
                                                                                                            let _v1721 = v1725 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v1726 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v1727 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1719, v1720) v1726 
                                                                                                            let _v1721 = v1727 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v1728 : Result<std_path_PathBuf, string> = match v1719 with Ok x -> Ok x | Error x -> Error (v1720 x)
                                                                                                            let _v1721 = v1728 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v1729 : Result<std_path_PathBuf, string> = match v1719 with Ok x -> Ok x | Error x -> Error (v1720 x)
                                                                                                            let _v1721 = v1729 
                                                                                                            #endif
#else
                                                                                                            let v1730 : Result<std_path_PathBuf, string> = match v1719 with Ok x -> Ok x | Error x -> Error (v1720 x)
                                                                                                            let _v1721 = v1730 
                                                                                                            #endif
                                                                                                            let v1731 : Result<std_path_PathBuf, string> = _v1721 
                                                                                                            let v1734 : US8 = match v1731 with Ok x -> v23 x | Error x -> v24 x
                                                                                                            match v1734 with
                                                                                                            | US8_1(v1837) -> (* Error *)
                                                                                                                let v1838 : string = $"file_system.read_link / error': {v1837} / error: {v316} / name: {v317}"
                                                                                                                let v1839 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v1840 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v1841 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1838 v1840 
                                                                                                                let _v1839 = v1841 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v1842 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v1843 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1838 v1842 
                                                                                                                let _v1839 = v1843 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v1844 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v1845 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1838 v1844 
                                                                                                                let _v1839 = v1845 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v1846 : std_io_Error = v1838 
                                                                                                                let _v1839 = v1846 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v1847 : std_io_Error = v1838 
                                                                                                                let _v1839 = v1847 
                                                                                                                #endif
#else
                                                                                                                let v1848 : std_io_Error = v1838 
                                                                                                                let _v1839 = v1848 
                                                                                                                #endif
                                                                                                                let v1849 : std_io_Error = _v1839 
                                                                                                                let v1852 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v1853 : string = "Err($0)"
                                                                                                                let v1854 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1849 v1853 
                                                                                                                let _v1852 = v1854 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v1855 : string = "Err($0)"
                                                                                                                let v1856 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1849 v1855 
                                                                                                                let _v1852 = v1856 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v1857 : string = "Err($0)"
                                                                                                                let v1858 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1849 v1857 
                                                                                                                let _v1852 = v1858 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v1859 : Result<std_path_PathBuf, std_io_Error> = v1849 |> Error
                                                                                                                let _v1852 = v1859 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v1860 : Result<std_path_PathBuf, std_io_Error> = v1849 |> Error
                                                                                                                let _v1852 = v1860 
                                                                                                                #endif
#else
                                                                                                                let v1861 : Result<std_path_PathBuf, std_io_Error> = v1849 |> Error
                                                                                                                let _v1852 = v1861 
                                                                                                                #endif
                                                                                                                let v1862 : Result<std_path_PathBuf, std_io_Error> = _v1852 
                                                                                                                v1862
                                                                                                            | US8_0(v1735) -> (* Ok *)
                                                                                                                let v1736 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v1737 : string = "$0.display()"
                                                                                                                let v1738 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1735 v1737 
                                                                                                                let _v1736 = v1738 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v1739 : string = "$0.display()"
                                                                                                                let v1740 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1735 v1739 
                                                                                                                let _v1736 = v1740 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v1741 : string = "$0.display()"
                                                                                                                let v1742 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1735 v1741 
                                                                                                                let _v1736 = v1742 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v1743 : std_path_Display = v1735 |> unbox<std_path_Display>
                                                                                                                let _v1736 = v1743 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v1746 : std_path_Display = v1735 |> unbox<std_path_Display>
                                                                                                                let _v1736 = v1746 
                                                                                                                #endif
#else
                                                                                                                let v1749 : std_path_Display = v1735 |> unbox<std_path_Display>
                                                                                                                let _v1736 = v1749 
                                                                                                                #endif
                                                                                                                let v1752 : std_path_Display = _v1736 
                                                                                                                let v1757 : string = v1752 |> string 
                                                                                                                let v1760 : string = method26(v1757, v317)
                                                                                                                let v1761 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v1762 : string = "&*$0"
                                                                                                                let v1763 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1760 v1762 
                                                                                                                let _v1761 = v1763 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v1764 : string = "&*$0"
                                                                                                                let v1765 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1760 v1764 
                                                                                                                let _v1761 = v1765 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v1766 : string = "&*$0"
                                                                                                                let v1767 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1760 v1766 
                                                                                                                let _v1761 = v1767 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v1768 : Ref<Str> = v1760 |> unbox<Ref<Str>>
                                                                                                                let _v1761 = v1768 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v1771 : Ref<Str> = v1760 |> unbox<Ref<Str>>
                                                                                                                let _v1761 = v1771 
                                                                                                                #endif
#else
                                                                                                                let v1774 : Ref<Str> = v1760 |> unbox<Ref<Str>>
                                                                                                                let _v1761 = v1774 
                                                                                                                #endif
                                                                                                                let v1777 : Ref<Str> = _v1761 
                                                                                                                let v1782 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v1783 : string = "String::from($0)"
                                                                                                                let v1784 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1777 v1783 
                                                                                                                let _v1782 = v1784 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v1785 : string = "String::from($0)"
                                                                                                                let v1786 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1777 v1785 
                                                                                                                let _v1782 = v1786 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v1787 : string = "String::from($0)"
                                                                                                                let v1788 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1777 v1787 
                                                                                                                let _v1782 = v1788 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v1789 : std_string_String = v1777 |> unbox<std_string_String>
                                                                                                                let _v1782 = v1789 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v1792 : std_string_String = v1777 |> unbox<std_string_String>
                                                                                                                let _v1782 = v1792 
                                                                                                                #endif
#else
                                                                                                                let v1795 : std_string_String = v1777 |> unbox<std_string_String>
                                                                                                                let _v1782 = v1795 
                                                                                                                #endif
                                                                                                                let v1798 : std_string_String = _v1782 
                                                                                                                let v1803 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v1804 : string = "std::path::PathBuf::from($0)"
                                                                                                                let v1805 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1798 v1804 
                                                                                                                let _v1803 = v1805 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v1806 : string = "std::path::PathBuf::from($0)"
                                                                                                                let v1807 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1798 v1806 
                                                                                                                let _v1803 = v1807 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v1808 : string = "std::path::PathBuf::from($0)"
                                                                                                                let v1809 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1798 v1808 
                                                                                                                let _v1803 = v1809 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v1810 : std_path_PathBuf = v1798 |> std_path_PathBuf 
                                                                                                                let _v1803 = v1810 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v1813 : std_path_PathBuf = v1798 |> std_path_PathBuf 
                                                                                                                let _v1803 = v1813 
                                                                                                                #endif
#else
                                                                                                                let v1816 : std_path_PathBuf = v1798 |> std_path_PathBuf 
                                                                                                                let _v1803 = v1816 
                                                                                                                #endif
                                                                                                                let v1819 : std_path_PathBuf = _v1803 
                                                                                                                let v1824 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v1825 : string = "Ok($0)"
                                                                                                                let v1826 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1819 v1825 
                                                                                                                let _v1824 = v1826 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v1827 : string = "Ok($0)"
                                                                                                                let v1828 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1819 v1827 
                                                                                                                let _v1824 = v1828 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v1829 : string = "Ok($0)"
                                                                                                                let v1830 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1819 v1829 
                                                                                                                let _v1824 = v1830 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v1831 : Result<std_path_PathBuf, std_io_Error> = v1819 |> Ok
                                                                                                                let _v1824 = v1831 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v1832 : Result<std_path_PathBuf, std_io_Error> = v1819 |> Ok
                                                                                                                let _v1824 = v1832 
                                                                                                                #endif
#else
                                                                                                                let v1833 : Result<std_path_PathBuf, std_io_Error> = v1819 |> Ok
                                                                                                                let _v1824 = v1833 
                                                                                                                #endif
                                                                                                                let v1834 : Result<std_path_PathBuf, std_io_Error> = _v1824 
                                                                                                                v1834
                                                                                                        else
                                                                                                            let v1867 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v316} / path': {v281} / name: {v317}"
                                                                                                            let v1868 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v1869 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v1870 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1867 v1869 
                                                                                                            let _v1868 = v1870 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v1871 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v1872 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1867 v1871 
                                                                                                            let _v1868 = v1872 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v1873 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v1874 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1867 v1873 
                                                                                                            let _v1868 = v1874 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v1875 : std_io_Error = v1867 
                                                                                                            let _v1868 = v1875 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v1876 : std_io_Error = v1867 
                                                                                                            let _v1868 = v1876 
                                                                                                            #endif
#else
                                                                                                            let v1877 : std_io_Error = v1867 
                                                                                                            let _v1868 = v1877 
                                                                                                            #endif
                                                                                                            let v1878 : std_io_Error = _v1868 
                                                                                                            let v1881 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v1882 : string = "Err($0)"
                                                                                                            let v1883 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1878 v1882 
                                                                                                            let _v1881 = v1883 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v1884 : string = "Err($0)"
                                                                                                            let v1885 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1878 v1884 
                                                                                                            let _v1881 = v1885 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v1886 : string = "Err($0)"
                                                                                                            let v1887 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1878 v1886 
                                                                                                            let _v1881 = v1887 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v1888 : Result<std_path_PathBuf, std_io_Error> = v1878 |> Error
                                                                                                            let _v1881 = v1888 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v1889 : Result<std_path_PathBuf, std_io_Error> = v1878 |> Error
                                                                                                            let _v1881 = v1889 
                                                                                                            #endif
#else
                                                                                                            let v1890 : Result<std_path_PathBuf, std_io_Error> = v1878 |> Error
                                                                                                            let _v1881 = v1890 
                                                                                                            #endif
                                                                                                            let v1891 : Result<std_path_PathBuf, std_io_Error> = _v1881 
                                                                                                            v1891
                                                                                                    | _ ->
                                                                                                        let v1895 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v316} / path': {v281} / name: {v317}"
                                                                                                        let v1896 : unit = ()
                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                        let v1897 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                        let v1898 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1895 v1897 
                                                                                                        let _v1896 = v1898 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                        let v1899 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                        let v1900 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1895 v1899 
                                                                                                        let _v1896 = v1900 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                        let v1901 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                        let v1902 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1895 v1901 
                                                                                                        let _v1896 = v1902 
                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                        let v1903 : std_io_Error = v1895 
                                                                                                        let _v1896 = v1903 
                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                        let v1904 : std_io_Error = v1895 
                                                                                                        let _v1896 = v1904 
                                                                                                        #endif
#else
                                                                                                        let v1905 : std_io_Error = v1895 
                                                                                                        let _v1896 = v1905 
                                                                                                        #endif
                                                                                                        let v1906 : std_io_Error = _v1896 
                                                                                                        let v1909 : unit = ()
                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                        let v1910 : string = "Err($0)"
                                                                                                        let v1911 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1906 v1910 
                                                                                                        let _v1909 = v1911 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                        let v1912 : string = "Err($0)"
                                                                                                        let v1913 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1906 v1912 
                                                                                                        let _v1909 = v1913 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                        let v1914 : string = "Err($0)"
                                                                                                        let v1915 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1906 v1914 
                                                                                                        let _v1909 = v1915 
                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                        let v1916 : Result<std_path_PathBuf, std_io_Error> = v1906 |> Error
                                                                                                        let _v1909 = v1916 
                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                        let v1917 : Result<std_path_PathBuf, std_io_Error> = v1906 |> Error
                                                                                                        let _v1909 = v1917 
                                                                                                        #endif
#else
                                                                                                        let v1918 : Result<std_path_PathBuf, std_io_Error> = v1906 |> Error
                                                                                                        let _v1909 = v1918 
                                                                                                        #endif
                                                                                                        let v1919 : Result<std_path_PathBuf, std_io_Error> = _v1909 
                                                                                                        v1919
                                                                                                | US8_0(v302) -> (* Ok *)
                                                                                                    let v303 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v304 : string = "Ok($0)"
                                                                                                    let v305 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v302 v304 
                                                                                                    let _v303 = v305 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v306 : string = "Ok($0)"
                                                                                                    let v307 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v302 v306 
                                                                                                    let _v303 = v307 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v308 : string = "Ok($0)"
                                                                                                    let v309 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v302 v308 
                                                                                                    let _v303 = v309 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v310 : Result<std_path_PathBuf, std_io_Error> = v302 |> Ok
                                                                                                    let _v303 = v310 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v311 : Result<std_path_PathBuf, std_io_Error> = v302 |> Ok
                                                                                                    let _v303 = v311 
                                                                                                    #endif
#else
                                                                                                    let v312 : Result<std_path_PathBuf, std_io_Error> = v302 |> Ok
                                                                                                    let _v303 = v312 
                                                                                                    #endif
                                                                                                    let v313 : Result<std_path_PathBuf, std_io_Error> = _v303 
                                                                                                    v313
                                                                                            let v1925 : (std_io_Error -> string) = method41()
                                                                                            let v1926 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v1927 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v1928 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1924, v1925) v1927 
                                                                                            let _v1926 = v1928 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v1929 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v1930 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1924, v1925) v1929 
                                                                                            let _v1926 = v1930 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v1931 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v1932 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1924, v1925) v1931 
                                                                                            let _v1926 = v1932 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v1933 : Result<std_path_PathBuf, string> = match v1924 with Ok x -> Ok x | Error x -> Error (v1925 x)
                                                                                            let _v1926 = v1933 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v1934 : Result<std_path_PathBuf, string> = match v1924 with Ok x -> Ok x | Error x -> Error (v1925 x)
                                                                                            let _v1926 = v1934 
                                                                                            #endif
#else
                                                                                            let v1935 : Result<std_path_PathBuf, string> = match v1924 with Ok x -> Ok x | Error x -> Error (v1925 x)
                                                                                            let _v1926 = v1935 
                                                                                            #endif
                                                                                            let v1936 : Result<std_path_PathBuf, string> = _v1926 
                                                                                            let v1939 : US8 = match v1936 with Ok x -> v23 x | Error x -> v24 x
                                                                                            match v1939 with
                                                                                            | US8_1(v2042) -> (* Error *)
                                                                                                let v2043 : string = $"file_system.read_link / error': {v2042} / error: {v261} / name: {v262}"
                                                                                                let v2044 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v2045 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v2046 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2043 v2045 
                                                                                                let _v2044 = v2046 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v2047 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v2048 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2043 v2047 
                                                                                                let _v2044 = v2048 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v2049 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v2050 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2043 v2049 
                                                                                                let _v2044 = v2050 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v2051 : std_io_Error = v2043 
                                                                                                let _v2044 = v2051 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v2052 : std_io_Error = v2043 
                                                                                                let _v2044 = v2052 
                                                                                                #endif
#else
                                                                                                let v2053 : std_io_Error = v2043 
                                                                                                let _v2044 = v2053 
                                                                                                #endif
                                                                                                let v2054 : std_io_Error = _v2044 
                                                                                                let v2057 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v2058 : string = "Err($0)"
                                                                                                let v2059 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2054 v2058 
                                                                                                let _v2057 = v2059 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v2060 : string = "Err($0)"
                                                                                                let v2061 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2054 v2060 
                                                                                                let _v2057 = v2061 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v2062 : string = "Err($0)"
                                                                                                let v2063 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2054 v2062 
                                                                                                let _v2057 = v2063 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v2064 : Result<std_path_PathBuf, std_io_Error> = v2054 |> Error
                                                                                                let _v2057 = v2064 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v2065 : Result<std_path_PathBuf, std_io_Error> = v2054 |> Error
                                                                                                let _v2057 = v2065 
                                                                                                #endif
#else
                                                                                                let v2066 : Result<std_path_PathBuf, std_io_Error> = v2054 |> Error
                                                                                                let _v2057 = v2066 
                                                                                                #endif
                                                                                                let v2067 : Result<std_path_PathBuf, std_io_Error> = _v2057 
                                                                                                v2067
                                                                                            | US8_0(v1940) -> (* Ok *)
                                                                                                let v1941 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v1942 : string = "$0.display()"
                                                                                                let v1943 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1940 v1942 
                                                                                                let _v1941 = v1943 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v1944 : string = "$0.display()"
                                                                                                let v1945 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1940 v1944 
                                                                                                let _v1941 = v1945 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v1946 : string = "$0.display()"
                                                                                                let v1947 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1940 v1946 
                                                                                                let _v1941 = v1947 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v1948 : std_path_Display = v1940 |> unbox<std_path_Display>
                                                                                                let _v1941 = v1948 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v1951 : std_path_Display = v1940 |> unbox<std_path_Display>
                                                                                                let _v1941 = v1951 
                                                                                                #endif
#else
                                                                                                let v1954 : std_path_Display = v1940 |> unbox<std_path_Display>
                                                                                                let _v1941 = v1954 
                                                                                                #endif
                                                                                                let v1957 : std_path_Display = _v1941 
                                                                                                let v1962 : string = v1957 |> string 
                                                                                                let v1965 : string = method26(v1962, v262)
                                                                                                let v1966 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v1967 : string = "&*$0"
                                                                                                let v1968 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1965 v1967 
                                                                                                let _v1966 = v1968 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v1969 : string = "&*$0"
                                                                                                let v1970 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1965 v1969 
                                                                                                let _v1966 = v1970 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v1971 : string = "&*$0"
                                                                                                let v1972 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1965 v1971 
                                                                                                let _v1966 = v1972 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v1973 : Ref<Str> = v1965 |> unbox<Ref<Str>>
                                                                                                let _v1966 = v1973 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v1976 : Ref<Str> = v1965 |> unbox<Ref<Str>>
                                                                                                let _v1966 = v1976 
                                                                                                #endif
#else
                                                                                                let v1979 : Ref<Str> = v1965 |> unbox<Ref<Str>>
                                                                                                let _v1966 = v1979 
                                                                                                #endif
                                                                                                let v1982 : Ref<Str> = _v1966 
                                                                                                let v1987 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v1988 : string = "String::from($0)"
                                                                                                let v1989 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1982 v1988 
                                                                                                let _v1987 = v1989 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v1990 : string = "String::from($0)"
                                                                                                let v1991 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1982 v1990 
                                                                                                let _v1987 = v1991 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v1992 : string = "String::from($0)"
                                                                                                let v1993 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1982 v1992 
                                                                                                let _v1987 = v1993 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v1994 : std_string_String = v1982 |> unbox<std_string_String>
                                                                                                let _v1987 = v1994 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v1997 : std_string_String = v1982 |> unbox<std_string_String>
                                                                                                let _v1987 = v1997 
                                                                                                #endif
#else
                                                                                                let v2000 : std_string_String = v1982 |> unbox<std_string_String>
                                                                                                let _v1987 = v2000 
                                                                                                #endif
                                                                                                let v2003 : std_string_String = _v1987 
                                                                                                let v2008 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v2009 : string = "std::path::PathBuf::from($0)"
                                                                                                let v2010 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2003 v2009 
                                                                                                let _v2008 = v2010 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v2011 : string = "std::path::PathBuf::from($0)"
                                                                                                let v2012 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2003 v2011 
                                                                                                let _v2008 = v2012 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v2013 : string = "std::path::PathBuf::from($0)"
                                                                                                let v2014 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2003 v2013 
                                                                                                let _v2008 = v2014 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v2015 : std_path_PathBuf = v2003 |> std_path_PathBuf 
                                                                                                let _v2008 = v2015 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v2018 : std_path_PathBuf = v2003 |> std_path_PathBuf 
                                                                                                let _v2008 = v2018 
                                                                                                #endif
#else
                                                                                                let v2021 : std_path_PathBuf = v2003 |> std_path_PathBuf 
                                                                                                let _v2008 = v2021 
                                                                                                #endif
                                                                                                let v2024 : std_path_PathBuf = _v2008 
                                                                                                let v2029 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v2030 : string = "Ok($0)"
                                                                                                let v2031 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2024 v2030 
                                                                                                let _v2029 = v2031 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v2032 : string = "Ok($0)"
                                                                                                let v2033 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2024 v2032 
                                                                                                let _v2029 = v2033 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v2034 : string = "Ok($0)"
                                                                                                let v2035 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2024 v2034 
                                                                                                let _v2029 = v2035 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v2036 : Result<std_path_PathBuf, std_io_Error> = v2024 |> Ok
                                                                                                let _v2029 = v2036 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v2037 : Result<std_path_PathBuf, std_io_Error> = v2024 |> Ok
                                                                                                let _v2029 = v2037 
                                                                                                #endif
#else
                                                                                                let v2038 : Result<std_path_PathBuf, std_io_Error> = v2024 |> Ok
                                                                                                let _v2029 = v2038 
                                                                                                #endif
                                                                                                let v2039 : Result<std_path_PathBuf, std_io_Error> = _v2029 
                                                                                                v2039
                                                                                        else
                                                                                            let v2072 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v261} / path': {v226} / name: {v262}"
                                                                                            let v2073 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v2074 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v2075 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2072 v2074 
                                                                                            let _v2073 = v2075 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v2076 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v2077 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2072 v2076 
                                                                                            let _v2073 = v2077 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v2078 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v2079 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2072 v2078 
                                                                                            let _v2073 = v2079 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v2080 : std_io_Error = v2072 
                                                                                            let _v2073 = v2080 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v2081 : std_io_Error = v2072 
                                                                                            let _v2073 = v2081 
                                                                                            #endif
#else
                                                                                            let v2082 : std_io_Error = v2072 
                                                                                            let _v2073 = v2082 
                                                                                            #endif
                                                                                            let v2083 : std_io_Error = _v2073 
                                                                                            let v2086 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v2087 : string = "Err($0)"
                                                                                            let v2088 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2083 v2087 
                                                                                            let _v2086 = v2088 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v2089 : string = "Err($0)"
                                                                                            let v2090 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2083 v2089 
                                                                                            let _v2086 = v2090 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v2091 : string = "Err($0)"
                                                                                            let v2092 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2083 v2091 
                                                                                            let _v2086 = v2092 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v2093 : Result<std_path_PathBuf, std_io_Error> = v2083 |> Error
                                                                                            let _v2086 = v2093 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v2094 : Result<std_path_PathBuf, std_io_Error> = v2083 |> Error
                                                                                            let _v2086 = v2094 
                                                                                            #endif
#else
                                                                                            let v2095 : Result<std_path_PathBuf, std_io_Error> = v2083 |> Error
                                                                                            let _v2086 = v2095 
                                                                                            #endif
                                                                                            let v2096 : Result<std_path_PathBuf, std_io_Error> = _v2086 
                                                                                            v2096
                                                                                    | _ ->
                                                                                        let v2100 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v261} / path': {v226} / name: {v262}"
                                                                                        let v2101 : unit = ()
                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                        let v2102 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                        let v2103 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2100 v2102 
                                                                                        let _v2101 = v2103 
                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                        let v2104 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                        let v2105 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2100 v2104 
                                                                                        let _v2101 = v2105 
                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                        let v2106 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                        let v2107 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2100 v2106 
                                                                                        let _v2101 = v2107 
                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                        let v2108 : std_io_Error = v2100 
                                                                                        let _v2101 = v2108 
                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                        let v2109 : std_io_Error = v2100 
                                                                                        let _v2101 = v2109 
                                                                                        #endif
#else
                                                                                        let v2110 : std_io_Error = v2100 
                                                                                        let _v2101 = v2110 
                                                                                        #endif
                                                                                        let v2111 : std_io_Error = _v2101 
                                                                                        let v2114 : unit = ()
                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                        let v2115 : string = "Err($0)"
                                                                                        let v2116 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2111 v2115 
                                                                                        let _v2114 = v2116 
                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                        let v2117 : string = "Err($0)"
                                                                                        let v2118 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2111 v2117 
                                                                                        let _v2114 = v2118 
                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                        let v2119 : string = "Err($0)"
                                                                                        let v2120 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2111 v2119 
                                                                                        let _v2114 = v2120 
                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                        let v2121 : Result<std_path_PathBuf, std_io_Error> = v2111 |> Error
                                                                                        let _v2114 = v2121 
                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                        let v2122 : Result<std_path_PathBuf, std_io_Error> = v2111 |> Error
                                                                                        let _v2114 = v2122 
                                                                                        #endif
#else
                                                                                        let v2123 : Result<std_path_PathBuf, std_io_Error> = v2111 |> Error
                                                                                        let _v2114 = v2123 
                                                                                        #endif
                                                                                        let v2124 : Result<std_path_PathBuf, std_io_Error> = _v2114 
                                                                                        v2124
                                                                                | US8_0(v247) -> (* Ok *)
                                                                                    let v248 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v249 : string = "Ok($0)"
                                                                                    let v250 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v247 v249 
                                                                                    let _v248 = v250 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v251 : string = "Ok($0)"
                                                                                    let v252 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v247 v251 
                                                                                    let _v248 = v252 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v253 : string = "Ok($0)"
                                                                                    let v254 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v247 v253 
                                                                                    let _v248 = v254 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v255 : Result<std_path_PathBuf, std_io_Error> = v247 |> Ok
                                                                                    let _v248 = v255 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v256 : Result<std_path_PathBuf, std_io_Error> = v247 |> Ok
                                                                                    let _v248 = v256 
                                                                                    #endif
#else
                                                                                    let v257 : Result<std_path_PathBuf, std_io_Error> = v247 |> Ok
                                                                                    let _v248 = v257 
                                                                                    #endif
                                                                                    let v258 : Result<std_path_PathBuf, std_io_Error> = _v248 
                                                                                    v258
                                                                            let v2130 : (std_io_Error -> string) = method41()
                                                                            let v2131 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v2132 : string = "$0.map_err(|x| $1(x))"
                                                                            let v2133 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2129, v2130) v2132 
                                                                            let _v2131 = v2133 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v2134 : string = "$0.map_err(|x| $1(x))"
                                                                            let v2135 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2129, v2130) v2134 
                                                                            let _v2131 = v2135 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v2136 : string = "$0.map_err(|x| $1(x))"
                                                                            let v2137 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2129, v2130) v2136 
                                                                            let _v2131 = v2137 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v2138 : Result<std_path_PathBuf, string> = match v2129 with Ok x -> Ok x | Error x -> Error (v2130 x)
                                                                            let _v2131 = v2138 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v2139 : Result<std_path_PathBuf, string> = match v2129 with Ok x -> Ok x | Error x -> Error (v2130 x)
                                                                            let _v2131 = v2139 
                                                                            #endif
#else
                                                                            let v2140 : Result<std_path_PathBuf, string> = match v2129 with Ok x -> Ok x | Error x -> Error (v2130 x)
                                                                            let _v2131 = v2140 
                                                                            #endif
                                                                            let v2141 : Result<std_path_PathBuf, string> = _v2131 
                                                                            let v2144 : US8 = match v2141 with Ok x -> v23 x | Error x -> v24 x
                                                                            match v2144 with
                                                                            | US8_1(v2247) -> (* Error *)
                                                                                let v2248 : string = $"file_system.read_link / error': {v2247} / error: {v206} / name: {v207}"
                                                                                let v2249 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v2250 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v2251 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2248 v2250 
                                                                                let _v2249 = v2251 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v2252 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v2253 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2248 v2252 
                                                                                let _v2249 = v2253 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v2254 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v2255 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2248 v2254 
                                                                                let _v2249 = v2255 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v2256 : std_io_Error = v2248 
                                                                                let _v2249 = v2256 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v2257 : std_io_Error = v2248 
                                                                                let _v2249 = v2257 
                                                                                #endif
#else
                                                                                let v2258 : std_io_Error = v2248 
                                                                                let _v2249 = v2258 
                                                                                #endif
                                                                                let v2259 : std_io_Error = _v2249 
                                                                                let v2262 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v2263 : string = "Err($0)"
                                                                                let v2264 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2259 v2263 
                                                                                let _v2262 = v2264 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v2265 : string = "Err($0)"
                                                                                let v2266 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2259 v2265 
                                                                                let _v2262 = v2266 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v2267 : string = "Err($0)"
                                                                                let v2268 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2259 v2267 
                                                                                let _v2262 = v2268 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v2269 : Result<std_path_PathBuf, std_io_Error> = v2259 |> Error
                                                                                let _v2262 = v2269 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v2270 : Result<std_path_PathBuf, std_io_Error> = v2259 |> Error
                                                                                let _v2262 = v2270 
                                                                                #endif
#else
                                                                                let v2271 : Result<std_path_PathBuf, std_io_Error> = v2259 |> Error
                                                                                let _v2262 = v2271 
                                                                                #endif
                                                                                let v2272 : Result<std_path_PathBuf, std_io_Error> = _v2262 
                                                                                v2272
                                                                            | US8_0(v2145) -> (* Ok *)
                                                                                let v2146 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v2147 : string = "$0.display()"
                                                                                let v2148 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2145 v2147 
                                                                                let _v2146 = v2148 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v2149 : string = "$0.display()"
                                                                                let v2150 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2145 v2149 
                                                                                let _v2146 = v2150 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v2151 : string = "$0.display()"
                                                                                let v2152 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2145 v2151 
                                                                                let _v2146 = v2152 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v2153 : std_path_Display = v2145 |> unbox<std_path_Display>
                                                                                let _v2146 = v2153 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v2156 : std_path_Display = v2145 |> unbox<std_path_Display>
                                                                                let _v2146 = v2156 
                                                                                #endif
#else
                                                                                let v2159 : std_path_Display = v2145 |> unbox<std_path_Display>
                                                                                let _v2146 = v2159 
                                                                                #endif
                                                                                let v2162 : std_path_Display = _v2146 
                                                                                let v2167 : string = v2162 |> string 
                                                                                let v2170 : string = method26(v2167, v207)
                                                                                let v2171 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v2172 : string = "&*$0"
                                                                                let v2173 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2170 v2172 
                                                                                let _v2171 = v2173 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v2174 : string = "&*$0"
                                                                                let v2175 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2170 v2174 
                                                                                let _v2171 = v2175 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v2176 : string = "&*$0"
                                                                                let v2177 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2170 v2176 
                                                                                let _v2171 = v2177 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v2178 : Ref<Str> = v2170 |> unbox<Ref<Str>>
                                                                                let _v2171 = v2178 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v2181 : Ref<Str> = v2170 |> unbox<Ref<Str>>
                                                                                let _v2171 = v2181 
                                                                                #endif
#else
                                                                                let v2184 : Ref<Str> = v2170 |> unbox<Ref<Str>>
                                                                                let _v2171 = v2184 
                                                                                #endif
                                                                                let v2187 : Ref<Str> = _v2171 
                                                                                let v2192 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v2193 : string = "String::from($0)"
                                                                                let v2194 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2187 v2193 
                                                                                let _v2192 = v2194 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v2195 : string = "String::from($0)"
                                                                                let v2196 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2187 v2195 
                                                                                let _v2192 = v2196 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v2197 : string = "String::from($0)"
                                                                                let v2198 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2187 v2197 
                                                                                let _v2192 = v2198 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v2199 : std_string_String = v2187 |> unbox<std_string_String>
                                                                                let _v2192 = v2199 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v2202 : std_string_String = v2187 |> unbox<std_string_String>
                                                                                let _v2192 = v2202 
                                                                                #endif
#else
                                                                                let v2205 : std_string_String = v2187 |> unbox<std_string_String>
                                                                                let _v2192 = v2205 
                                                                                #endif
                                                                                let v2208 : std_string_String = _v2192 
                                                                                let v2213 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v2214 : string = "std::path::PathBuf::from($0)"
                                                                                let v2215 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2208 v2214 
                                                                                let _v2213 = v2215 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v2216 : string = "std::path::PathBuf::from($0)"
                                                                                let v2217 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2208 v2216 
                                                                                let _v2213 = v2217 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v2218 : string = "std::path::PathBuf::from($0)"
                                                                                let v2219 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2208 v2218 
                                                                                let _v2213 = v2219 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v2220 : std_path_PathBuf = v2208 |> std_path_PathBuf 
                                                                                let _v2213 = v2220 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v2223 : std_path_PathBuf = v2208 |> std_path_PathBuf 
                                                                                let _v2213 = v2223 
                                                                                #endif
#else
                                                                                let v2226 : std_path_PathBuf = v2208 |> std_path_PathBuf 
                                                                                let _v2213 = v2226 
                                                                                #endif
                                                                                let v2229 : std_path_PathBuf = _v2213 
                                                                                let v2234 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v2235 : string = "Ok($0)"
                                                                                let v2236 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2229 v2235 
                                                                                let _v2234 = v2236 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v2237 : string = "Ok($0)"
                                                                                let v2238 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2229 v2237 
                                                                                let _v2234 = v2238 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v2239 : string = "Ok($0)"
                                                                                let v2240 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2229 v2239 
                                                                                let _v2234 = v2240 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v2241 : Result<std_path_PathBuf, std_io_Error> = v2229 |> Ok
                                                                                let _v2234 = v2241 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v2242 : Result<std_path_PathBuf, std_io_Error> = v2229 |> Ok
                                                                                let _v2234 = v2242 
                                                                                #endif
#else
                                                                                let v2243 : Result<std_path_PathBuf, std_io_Error> = v2229 |> Ok
                                                                                let _v2234 = v2243 
                                                                                #endif
                                                                                let v2244 : Result<std_path_PathBuf, std_io_Error> = _v2234 
                                                                                v2244
                                                                        else
                                                                            let v2277 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v206} / path': {v171} / name: {v207}"
                                                                            let v2278 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v2279 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v2280 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2277 v2279 
                                                                            let _v2278 = v2280 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v2281 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v2282 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2277 v2281 
                                                                            let _v2278 = v2282 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v2283 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v2284 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2277 v2283 
                                                                            let _v2278 = v2284 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v2285 : std_io_Error = v2277 
                                                                            let _v2278 = v2285 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v2286 : std_io_Error = v2277 
                                                                            let _v2278 = v2286 
                                                                            #endif
#else
                                                                            let v2287 : std_io_Error = v2277 
                                                                            let _v2278 = v2287 
                                                                            #endif
                                                                            let v2288 : std_io_Error = _v2278 
                                                                            let v2291 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v2292 : string = "Err($0)"
                                                                            let v2293 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2288 v2292 
                                                                            let _v2291 = v2293 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v2294 : string = "Err($0)"
                                                                            let v2295 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2288 v2294 
                                                                            let _v2291 = v2295 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v2296 : string = "Err($0)"
                                                                            let v2297 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2288 v2296 
                                                                            let _v2291 = v2297 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v2298 : Result<std_path_PathBuf, std_io_Error> = v2288 |> Error
                                                                            let _v2291 = v2298 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v2299 : Result<std_path_PathBuf, std_io_Error> = v2288 |> Error
                                                                            let _v2291 = v2299 
                                                                            #endif
#else
                                                                            let v2300 : Result<std_path_PathBuf, std_io_Error> = v2288 |> Error
                                                                            let _v2291 = v2300 
                                                                            #endif
                                                                            let v2301 : Result<std_path_PathBuf, std_io_Error> = _v2291 
                                                                            v2301
                                                                    | _ ->
                                                                        let v2305 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v206} / path': {v171} / name: {v207}"
                                                                        let v2306 : unit = ()
                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                        let v2307 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                        let v2308 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2305 v2307 
                                                                        let _v2306 = v2308 
                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                        let v2309 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                        let v2310 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2305 v2309 
                                                                        let _v2306 = v2310 
                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                        let v2311 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                        let v2312 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2305 v2311 
                                                                        let _v2306 = v2312 
                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                        let v2313 : std_io_Error = v2305 
                                                                        let _v2306 = v2313 
                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                        let v2314 : std_io_Error = v2305 
                                                                        let _v2306 = v2314 
                                                                        #endif
#else
                                                                        let v2315 : std_io_Error = v2305 
                                                                        let _v2306 = v2315 
                                                                        #endif
                                                                        let v2316 : std_io_Error = _v2306 
                                                                        let v2319 : unit = ()
                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                        let v2320 : string = "Err($0)"
                                                                        let v2321 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2316 v2320 
                                                                        let _v2319 = v2321 
                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                        let v2322 : string = "Err($0)"
                                                                        let v2323 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2316 v2322 
                                                                        let _v2319 = v2323 
                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                        let v2324 : string = "Err($0)"
                                                                        let v2325 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2316 v2324 
                                                                        let _v2319 = v2325 
                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                        let v2326 : Result<std_path_PathBuf, std_io_Error> = v2316 |> Error
                                                                        let _v2319 = v2326 
                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                        let v2327 : Result<std_path_PathBuf, std_io_Error> = v2316 |> Error
                                                                        let _v2319 = v2327 
                                                                        #endif
#else
                                                                        let v2328 : Result<std_path_PathBuf, std_io_Error> = v2316 |> Error
                                                                        let _v2319 = v2328 
                                                                        #endif
                                                                        let v2329 : Result<std_path_PathBuf, std_io_Error> = _v2319 
                                                                        v2329
                                                                | US8_0(v192) -> (* Ok *)
                                                                    let v193 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v194 : string = "Ok($0)"
                                                                    let v195 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v192 v194 
                                                                    let _v193 = v195 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v196 : string = "Ok($0)"
                                                                    let v197 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v192 v196 
                                                                    let _v193 = v197 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v198 : string = "Ok($0)"
                                                                    let v199 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v192 v198 
                                                                    let _v193 = v199 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v200 : Result<std_path_PathBuf, std_io_Error> = v192 |> Ok
                                                                    let _v193 = v200 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v201 : Result<std_path_PathBuf, std_io_Error> = v192 |> Ok
                                                                    let _v193 = v201 
                                                                    #endif
#else
                                                                    let v202 : Result<std_path_PathBuf, std_io_Error> = v192 |> Ok
                                                                    let _v193 = v202 
                                                                    #endif
                                                                    let v203 : Result<std_path_PathBuf, std_io_Error> = _v193 
                                                                    v203
                                                            let v2335 : (std_io_Error -> string) = method41()
                                                            let v2336 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v2337 : string = "$0.map_err(|x| $1(x))"
                                                            let v2338 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2334, v2335) v2337 
                                                            let _v2336 = v2338 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v2339 : string = "$0.map_err(|x| $1(x))"
                                                            let v2340 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2334, v2335) v2339 
                                                            let _v2336 = v2340 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v2341 : string = "$0.map_err(|x| $1(x))"
                                                            let v2342 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2334, v2335) v2341 
                                                            let _v2336 = v2342 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v2343 : Result<std_path_PathBuf, string> = match v2334 with Ok x -> Ok x | Error x -> Error (v2335 x)
                                                            let _v2336 = v2343 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v2344 : Result<std_path_PathBuf, string> = match v2334 with Ok x -> Ok x | Error x -> Error (v2335 x)
                                                            let _v2336 = v2344 
                                                            #endif
#else
                                                            let v2345 : Result<std_path_PathBuf, string> = match v2334 with Ok x -> Ok x | Error x -> Error (v2335 x)
                                                            let _v2336 = v2345 
                                                            #endif
                                                            let v2346 : Result<std_path_PathBuf, string> = _v2336 
                                                            let v2349 : US8 = match v2346 with Ok x -> v23 x | Error x -> v24 x
                                                            match v2349 with
                                                            | US8_1(v2452) -> (* Error *)
                                                                let v2453 : string = $"file_system.read_link / error': {v2452} / error: {v151} / name: {v152}"
                                                                let v2454 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v2455 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v2456 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2453 v2455 
                                                                let _v2454 = v2456 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v2457 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v2458 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2453 v2457 
                                                                let _v2454 = v2458 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v2459 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v2460 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2453 v2459 
                                                                let _v2454 = v2460 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v2461 : std_io_Error = v2453 
                                                                let _v2454 = v2461 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v2462 : std_io_Error = v2453 
                                                                let _v2454 = v2462 
                                                                #endif
#else
                                                                let v2463 : std_io_Error = v2453 
                                                                let _v2454 = v2463 
                                                                #endif
                                                                let v2464 : std_io_Error = _v2454 
                                                                let v2467 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v2468 : string = "Err($0)"
                                                                let v2469 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2464 v2468 
                                                                let _v2467 = v2469 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v2470 : string = "Err($0)"
                                                                let v2471 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2464 v2470 
                                                                let _v2467 = v2471 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v2472 : string = "Err($0)"
                                                                let v2473 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2464 v2472 
                                                                let _v2467 = v2473 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v2474 : Result<std_path_PathBuf, std_io_Error> = v2464 |> Error
                                                                let _v2467 = v2474 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v2475 : Result<std_path_PathBuf, std_io_Error> = v2464 |> Error
                                                                let _v2467 = v2475 
                                                                #endif
#else
                                                                let v2476 : Result<std_path_PathBuf, std_io_Error> = v2464 |> Error
                                                                let _v2467 = v2476 
                                                                #endif
                                                                let v2477 : Result<std_path_PathBuf, std_io_Error> = _v2467 
                                                                v2477
                                                            | US8_0(v2350) -> (* Ok *)
                                                                let v2351 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v2352 : string = "$0.display()"
                                                                let v2353 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2350 v2352 
                                                                let _v2351 = v2353 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v2354 : string = "$0.display()"
                                                                let v2355 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2350 v2354 
                                                                let _v2351 = v2355 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v2356 : string = "$0.display()"
                                                                let v2357 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2350 v2356 
                                                                let _v2351 = v2357 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v2358 : std_path_Display = v2350 |> unbox<std_path_Display>
                                                                let _v2351 = v2358 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v2361 : std_path_Display = v2350 |> unbox<std_path_Display>
                                                                let _v2351 = v2361 
                                                                #endif
#else
                                                                let v2364 : std_path_Display = v2350 |> unbox<std_path_Display>
                                                                let _v2351 = v2364 
                                                                #endif
                                                                let v2367 : std_path_Display = _v2351 
                                                                let v2372 : string = v2367 |> string 
                                                                let v2375 : string = method26(v2372, v152)
                                                                let v2376 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v2377 : string = "&*$0"
                                                                let v2378 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2375 v2377 
                                                                let _v2376 = v2378 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v2379 : string = "&*$0"
                                                                let v2380 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2375 v2379 
                                                                let _v2376 = v2380 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v2381 : string = "&*$0"
                                                                let v2382 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2375 v2381 
                                                                let _v2376 = v2382 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v2383 : Ref<Str> = v2375 |> unbox<Ref<Str>>
                                                                let _v2376 = v2383 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v2386 : Ref<Str> = v2375 |> unbox<Ref<Str>>
                                                                let _v2376 = v2386 
                                                                #endif
#else
                                                                let v2389 : Ref<Str> = v2375 |> unbox<Ref<Str>>
                                                                let _v2376 = v2389 
                                                                #endif
                                                                let v2392 : Ref<Str> = _v2376 
                                                                let v2397 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v2398 : string = "String::from($0)"
                                                                let v2399 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2392 v2398 
                                                                let _v2397 = v2399 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v2400 : string = "String::from($0)"
                                                                let v2401 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2392 v2400 
                                                                let _v2397 = v2401 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v2402 : string = "String::from($0)"
                                                                let v2403 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2392 v2402 
                                                                let _v2397 = v2403 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v2404 : std_string_String = v2392 |> unbox<std_string_String>
                                                                let _v2397 = v2404 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v2407 : std_string_String = v2392 |> unbox<std_string_String>
                                                                let _v2397 = v2407 
                                                                #endif
#else
                                                                let v2410 : std_string_String = v2392 |> unbox<std_string_String>
                                                                let _v2397 = v2410 
                                                                #endif
                                                                let v2413 : std_string_String = _v2397 
                                                                let v2418 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v2419 : string = "std::path::PathBuf::from($0)"
                                                                let v2420 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2413 v2419 
                                                                let _v2418 = v2420 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v2421 : string = "std::path::PathBuf::from($0)"
                                                                let v2422 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2413 v2421 
                                                                let _v2418 = v2422 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v2423 : string = "std::path::PathBuf::from($0)"
                                                                let v2424 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2413 v2423 
                                                                let _v2418 = v2424 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v2425 : std_path_PathBuf = v2413 |> std_path_PathBuf 
                                                                let _v2418 = v2425 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v2428 : std_path_PathBuf = v2413 |> std_path_PathBuf 
                                                                let _v2418 = v2428 
                                                                #endif
#else
                                                                let v2431 : std_path_PathBuf = v2413 |> std_path_PathBuf 
                                                                let _v2418 = v2431 
                                                                #endif
                                                                let v2434 : std_path_PathBuf = _v2418 
                                                                let v2439 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v2440 : string = "Ok($0)"
                                                                let v2441 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2434 v2440 
                                                                let _v2439 = v2441 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v2442 : string = "Ok($0)"
                                                                let v2443 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2434 v2442 
                                                                let _v2439 = v2443 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v2444 : string = "Ok($0)"
                                                                let v2445 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2434 v2444 
                                                                let _v2439 = v2445 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v2446 : Result<std_path_PathBuf, std_io_Error> = v2434 |> Ok
                                                                let _v2439 = v2446 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v2447 : Result<std_path_PathBuf, std_io_Error> = v2434 |> Ok
                                                                let _v2439 = v2447 
                                                                #endif
#else
                                                                let v2448 : Result<std_path_PathBuf, std_io_Error> = v2434 |> Ok
                                                                let _v2439 = v2448 
                                                                #endif
                                                                let v2449 : Result<std_path_PathBuf, std_io_Error> = _v2439 
                                                                v2449
                                                        else
                                                            let v2482 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v151} / path': {v116} / name: {v152}"
                                                            let v2483 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v2484 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v2485 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2482 v2484 
                                                            let _v2483 = v2485 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v2486 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v2487 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2482 v2486 
                                                            let _v2483 = v2487 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v2488 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v2489 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2482 v2488 
                                                            let _v2483 = v2489 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v2490 : std_io_Error = v2482 
                                                            let _v2483 = v2490 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v2491 : std_io_Error = v2482 
                                                            let _v2483 = v2491 
                                                            #endif
#else
                                                            let v2492 : std_io_Error = v2482 
                                                            let _v2483 = v2492 
                                                            #endif
                                                            let v2493 : std_io_Error = _v2483 
                                                            let v2496 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v2497 : string = "Err($0)"
                                                            let v2498 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2493 v2497 
                                                            let _v2496 = v2498 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v2499 : string = "Err($0)"
                                                            let v2500 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2493 v2499 
                                                            let _v2496 = v2500 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v2501 : string = "Err($0)"
                                                            let v2502 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2493 v2501 
                                                            let _v2496 = v2502 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v2503 : Result<std_path_PathBuf, std_io_Error> = v2493 |> Error
                                                            let _v2496 = v2503 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v2504 : Result<std_path_PathBuf, std_io_Error> = v2493 |> Error
                                                            let _v2496 = v2504 
                                                            #endif
#else
                                                            let v2505 : Result<std_path_PathBuf, std_io_Error> = v2493 |> Error
                                                            let _v2496 = v2505 
                                                            #endif
                                                            let v2506 : Result<std_path_PathBuf, std_io_Error> = _v2496 
                                                            v2506
                                                    | _ ->
                                                        let v2510 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v151} / path': {v116} / name: {v152}"
                                                        let v2511 : unit = ()
                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                        let v2512 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                        let v2513 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2510 v2512 
                                                        let _v2511 = v2513 
                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                        let v2514 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                        let v2515 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2510 v2514 
                                                        let _v2511 = v2515 
                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                        let v2516 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                        let v2517 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2510 v2516 
                                                        let _v2511 = v2517 
                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                        let v2518 : std_io_Error = v2510 
                                                        let _v2511 = v2518 
                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                        let v2519 : std_io_Error = v2510 
                                                        let _v2511 = v2519 
                                                        #endif
#else
                                                        let v2520 : std_io_Error = v2510 
                                                        let _v2511 = v2520 
                                                        #endif
                                                        let v2521 : std_io_Error = _v2511 
                                                        let v2524 : unit = ()
                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                        let v2525 : string = "Err($0)"
                                                        let v2526 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2521 v2525 
                                                        let _v2524 = v2526 
                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                        let v2527 : string = "Err($0)"
                                                        let v2528 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2521 v2527 
                                                        let _v2524 = v2528 
                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                        let v2529 : string = "Err($0)"
                                                        let v2530 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2521 v2529 
                                                        let _v2524 = v2530 
                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                        let v2531 : Result<std_path_PathBuf, std_io_Error> = v2521 |> Error
                                                        let _v2524 = v2531 
                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                        let v2532 : Result<std_path_PathBuf, std_io_Error> = v2521 |> Error
                                                        let _v2524 = v2532 
                                                        #endif
#else
                                                        let v2533 : Result<std_path_PathBuf, std_io_Error> = v2521 |> Error
                                                        let _v2524 = v2533 
                                                        #endif
                                                        let v2534 : Result<std_path_PathBuf, std_io_Error> = _v2524 
                                                        v2534
                                                | US8_0(v137) -> (* Ok *)
                                                    let v138 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v139 : string = "Ok($0)"
                                                    let v140 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v137 v139 
                                                    let _v138 = v140 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v141 : string = "Ok($0)"
                                                    let v142 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v137 v141 
                                                    let _v138 = v142 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v143 : string = "Ok($0)"
                                                    let v144 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v137 v143 
                                                    let _v138 = v144 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v145 : Result<std_path_PathBuf, std_io_Error> = v137 |> Ok
                                                    let _v138 = v145 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v146 : Result<std_path_PathBuf, std_io_Error> = v137 |> Ok
                                                    let _v138 = v146 
                                                    #endif
#else
                                                    let v147 : Result<std_path_PathBuf, std_io_Error> = v137 |> Ok
                                                    let _v138 = v147 
                                                    #endif
                                                    let v148 : Result<std_path_PathBuf, std_io_Error> = _v138 
                                                    v148
                                            let v2540 : (std_io_Error -> string) = method41()
                                            let v2541 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v2542 : string = "$0.map_err(|x| $1(x))"
                                            let v2543 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2539, v2540) v2542 
                                            let _v2541 = v2543 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v2544 : string = "$0.map_err(|x| $1(x))"
                                            let v2545 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2539, v2540) v2544 
                                            let _v2541 = v2545 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v2546 : string = "$0.map_err(|x| $1(x))"
                                            let v2547 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2539, v2540) v2546 
                                            let _v2541 = v2547 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v2548 : Result<std_path_PathBuf, string> = match v2539 with Ok x -> Ok x | Error x -> Error (v2540 x)
                                            let _v2541 = v2548 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v2549 : Result<std_path_PathBuf, string> = match v2539 with Ok x -> Ok x | Error x -> Error (v2540 x)
                                            let _v2541 = v2549 
                                            #endif
#else
                                            let v2550 : Result<std_path_PathBuf, string> = match v2539 with Ok x -> Ok x | Error x -> Error (v2540 x)
                                            let _v2541 = v2550 
                                            #endif
                                            let v2551 : Result<std_path_PathBuf, string> = _v2541 
                                            let v2554 : US8 = match v2551 with Ok x -> v23 x | Error x -> v24 x
                                            match v2554 with
                                            | US8_1(v2657) -> (* Error *)
                                                let v2658 : string = $"file_system.read_link / error': {v2657} / error: {v96} / name: {v97}"
                                                let v2659 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v2660 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v2661 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2658 v2660 
                                                let _v2659 = v2661 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v2662 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v2663 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2658 v2662 
                                                let _v2659 = v2663 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v2664 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v2665 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2658 v2664 
                                                let _v2659 = v2665 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v2666 : std_io_Error = v2658 
                                                let _v2659 = v2666 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v2667 : std_io_Error = v2658 
                                                let _v2659 = v2667 
                                                #endif
#else
                                                let v2668 : std_io_Error = v2658 
                                                let _v2659 = v2668 
                                                #endif
                                                let v2669 : std_io_Error = _v2659 
                                                let v2672 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v2673 : string = "Err($0)"
                                                let v2674 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2669 v2673 
                                                let _v2672 = v2674 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v2675 : string = "Err($0)"
                                                let v2676 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2669 v2675 
                                                let _v2672 = v2676 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v2677 : string = "Err($0)"
                                                let v2678 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2669 v2677 
                                                let _v2672 = v2678 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v2679 : Result<std_path_PathBuf, std_io_Error> = v2669 |> Error
                                                let _v2672 = v2679 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v2680 : Result<std_path_PathBuf, std_io_Error> = v2669 |> Error
                                                let _v2672 = v2680 
                                                #endif
#else
                                                let v2681 : Result<std_path_PathBuf, std_io_Error> = v2669 |> Error
                                                let _v2672 = v2681 
                                                #endif
                                                let v2682 : Result<std_path_PathBuf, std_io_Error> = _v2672 
                                                v2682
                                            | US8_0(v2555) -> (* Ok *)
                                                let v2556 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v2557 : string = "$0.display()"
                                                let v2558 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2555 v2557 
                                                let _v2556 = v2558 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v2559 : string = "$0.display()"
                                                let v2560 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2555 v2559 
                                                let _v2556 = v2560 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v2561 : string = "$0.display()"
                                                let v2562 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2555 v2561 
                                                let _v2556 = v2562 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v2563 : std_path_Display = v2555 |> unbox<std_path_Display>
                                                let _v2556 = v2563 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v2566 : std_path_Display = v2555 |> unbox<std_path_Display>
                                                let _v2556 = v2566 
                                                #endif
#else
                                                let v2569 : std_path_Display = v2555 |> unbox<std_path_Display>
                                                let _v2556 = v2569 
                                                #endif
                                                let v2572 : std_path_Display = _v2556 
                                                let v2577 : string = v2572 |> string 
                                                let v2580 : string = method26(v2577, v97)
                                                let v2581 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v2582 : string = "&*$0"
                                                let v2583 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2580 v2582 
                                                let _v2581 = v2583 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v2584 : string = "&*$0"
                                                let v2585 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2580 v2584 
                                                let _v2581 = v2585 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v2586 : string = "&*$0"
                                                let v2587 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2580 v2586 
                                                let _v2581 = v2587 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v2588 : Ref<Str> = v2580 |> unbox<Ref<Str>>
                                                let _v2581 = v2588 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v2591 : Ref<Str> = v2580 |> unbox<Ref<Str>>
                                                let _v2581 = v2591 
                                                #endif
#else
                                                let v2594 : Ref<Str> = v2580 |> unbox<Ref<Str>>
                                                let _v2581 = v2594 
                                                #endif
                                                let v2597 : Ref<Str> = _v2581 
                                                let v2602 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v2603 : string = "String::from($0)"
                                                let v2604 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2597 v2603 
                                                let _v2602 = v2604 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v2605 : string = "String::from($0)"
                                                let v2606 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2597 v2605 
                                                let _v2602 = v2606 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v2607 : string = "String::from($0)"
                                                let v2608 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2597 v2607 
                                                let _v2602 = v2608 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v2609 : std_string_String = v2597 |> unbox<std_string_String>
                                                let _v2602 = v2609 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v2612 : std_string_String = v2597 |> unbox<std_string_String>
                                                let _v2602 = v2612 
                                                #endif
#else
                                                let v2615 : std_string_String = v2597 |> unbox<std_string_String>
                                                let _v2602 = v2615 
                                                #endif
                                                let v2618 : std_string_String = _v2602 
                                                let v2623 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v2624 : string = "std::path::PathBuf::from($0)"
                                                let v2625 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2618 v2624 
                                                let _v2623 = v2625 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v2626 : string = "std::path::PathBuf::from($0)"
                                                let v2627 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2618 v2626 
                                                let _v2623 = v2627 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v2628 : string = "std::path::PathBuf::from($0)"
                                                let v2629 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2618 v2628 
                                                let _v2623 = v2629 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v2630 : std_path_PathBuf = v2618 |> std_path_PathBuf 
                                                let _v2623 = v2630 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v2633 : std_path_PathBuf = v2618 |> std_path_PathBuf 
                                                let _v2623 = v2633 
                                                #endif
#else
                                                let v2636 : std_path_PathBuf = v2618 |> std_path_PathBuf 
                                                let _v2623 = v2636 
                                                #endif
                                                let v2639 : std_path_PathBuf = _v2623 
                                                let v2644 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v2645 : string = "Ok($0)"
                                                let v2646 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2639 v2645 
                                                let _v2644 = v2646 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v2647 : string = "Ok($0)"
                                                let v2648 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2639 v2647 
                                                let _v2644 = v2648 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v2649 : string = "Ok($0)"
                                                let v2650 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2639 v2649 
                                                let _v2644 = v2650 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v2651 : Result<std_path_PathBuf, std_io_Error> = v2639 |> Ok
                                                let _v2644 = v2651 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v2652 : Result<std_path_PathBuf, std_io_Error> = v2639 |> Ok
                                                let _v2644 = v2652 
                                                #endif
#else
                                                let v2653 : Result<std_path_PathBuf, std_io_Error> = v2639 |> Ok
                                                let _v2644 = v2653 
                                                #endif
                                                let v2654 : Result<std_path_PathBuf, std_io_Error> = _v2644 
                                                v2654
                                        else
                                            let v2687 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v96} / path': {v60} / name: {v97}"
                                            let v2688 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v2689 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v2690 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2687 v2689 
                                            let _v2688 = v2690 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v2691 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v2692 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2687 v2691 
                                            let _v2688 = v2692 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v2693 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v2694 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2687 v2693 
                                            let _v2688 = v2694 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v2695 : std_io_Error = v2687 
                                            let _v2688 = v2695 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v2696 : std_io_Error = v2687 
                                            let _v2688 = v2696 
                                            #endif
#else
                                            let v2697 : std_io_Error = v2687 
                                            let _v2688 = v2697 
                                            #endif
                                            let v2698 : std_io_Error = _v2688 
                                            let v2701 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v2702 : string = "Err($0)"
                                            let v2703 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2698 v2702 
                                            let _v2701 = v2703 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v2704 : string = "Err($0)"
                                            let v2705 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2698 v2704 
                                            let _v2701 = v2705 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v2706 : string = "Err($0)"
                                            let v2707 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2698 v2706 
                                            let _v2701 = v2707 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v2708 : Result<std_path_PathBuf, std_io_Error> = v2698 |> Error
                                            let _v2701 = v2708 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v2709 : Result<std_path_PathBuf, std_io_Error> = v2698 |> Error
                                            let _v2701 = v2709 
                                            #endif
#else
                                            let v2710 : Result<std_path_PathBuf, std_io_Error> = v2698 |> Error
                                            let _v2701 = v2710 
                                            #endif
                                            let v2711 : Result<std_path_PathBuf, std_io_Error> = _v2701 
                                            v2711
                                    | _ ->
                                        let v2715 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v96} / path': {v60} / name: {v97}"
                                        let v2716 : unit = ()
                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                        let v2717 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                        let v2718 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2715 v2717 
                                        let _v2716 = v2718 
                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                        let v2719 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                        let v2720 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2715 v2719 
                                        let _v2716 = v2720 
                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                        let v2721 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                        let v2722 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2715 v2721 
                                        let _v2716 = v2722 
                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                        let v2723 : std_io_Error = v2715 
                                        let _v2716 = v2723 
                                        #endif
#if FABLE_COMPILER_PYTHON
                                        let v2724 : std_io_Error = v2715 
                                        let _v2716 = v2724 
                                        #endif
#else
                                        let v2725 : std_io_Error = v2715 
                                        let _v2716 = v2725 
                                        #endif
                                        let v2726 : std_io_Error = _v2716 
                                        let v2729 : unit = ()
                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                        let v2730 : string = "Err($0)"
                                        let v2731 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2726 v2730 
                                        let _v2729 = v2731 
                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                        let v2732 : string = "Err($0)"
                                        let v2733 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2726 v2732 
                                        let _v2729 = v2733 
                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                        let v2734 : string = "Err($0)"
                                        let v2735 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2726 v2734 
                                        let _v2729 = v2735 
                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                        let v2736 : Result<std_path_PathBuf, std_io_Error> = v2726 |> Error
                                        let _v2729 = v2736 
                                        #endif
#if FABLE_COMPILER_PYTHON
                                        let v2737 : Result<std_path_PathBuf, std_io_Error> = v2726 |> Error
                                        let _v2729 = v2737 
                                        #endif
#else
                                        let v2738 : Result<std_path_PathBuf, std_io_Error> = v2726 |> Error
                                        let _v2729 = v2738 
                                        #endif
                                        let v2739 : Result<std_path_PathBuf, std_io_Error> = _v2729 
                                        v2739
                                | US8_0(v82) -> (* Ok *)
                                    let v83 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v84 : string = "Ok($0)"
                                    let v85 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v82 v84 
                                    let _v83 = v85 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v86 : string = "Ok($0)"
                                    let v87 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v82 v86 
                                    let _v83 = v87 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v88 : string = "Ok($0)"
                                    let v89 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v82 v88 
                                    let _v83 = v89 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v90 : Result<std_path_PathBuf, std_io_Error> = v82 |> Ok
                                    let _v83 = v90 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v91 : Result<std_path_PathBuf, std_io_Error> = v82 |> Ok
                                    let _v83 = v91 
                                    #endif
#else
                                    let v92 : Result<std_path_PathBuf, std_io_Error> = v82 |> Ok
                                    let _v83 = v92 
                                    #endif
                                    let v93 : Result<std_path_PathBuf, std_io_Error> = _v83 
                                    v93
                            let v2745 : (std_io_Error -> string) = method41()
                            let v2746 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v2747 : string = "$0.map_err(|x| $1(x))"
                            let v2748 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2744, v2745) v2747 
                            let _v2746 = v2748 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v2749 : string = "$0.map_err(|x| $1(x))"
                            let v2750 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2744, v2745) v2749 
                            let _v2746 = v2750 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v2751 : string = "$0.map_err(|x| $1(x))"
                            let v2752 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2744, v2745) v2751 
                            let _v2746 = v2752 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v2753 : Result<std_path_PathBuf, string> = match v2744 with Ok x -> Ok x | Error x -> Error (v2745 x)
                            let _v2746 = v2753 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v2754 : Result<std_path_PathBuf, string> = match v2744 with Ok x -> Ok x | Error x -> Error (v2745 x)
                            let _v2746 = v2754 
                            #endif
#else
                            let v2755 : Result<std_path_PathBuf, string> = match v2744 with Ok x -> Ok x | Error x -> Error (v2745 x)
                            let _v2746 = v2755 
                            #endif
                            let v2756 : Result<std_path_PathBuf, string> = _v2746 
                            let v2759 : US8 = match v2756 with Ok x -> v23 x | Error x -> v24 x
                            match v2759 with
                            | US8_1(v2862) -> (* Error *)
                                let v2863 : string = $"file_system.read_link / error': {v2862} / error: {v40} / name: {v41}"
                                let v2864 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v2865 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v2866 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2863 v2865 
                                let _v2864 = v2866 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v2867 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v2868 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2863 v2867 
                                let _v2864 = v2868 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v2869 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v2870 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2863 v2869 
                                let _v2864 = v2870 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v2871 : std_io_Error = v2863 
                                let _v2864 = v2871 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v2872 : std_io_Error = v2863 
                                let _v2864 = v2872 
                                #endif
#else
                                let v2873 : std_io_Error = v2863 
                                let _v2864 = v2873 
                                #endif
                                let v2874 : std_io_Error = _v2864 
                                let v2877 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v2878 : string = "Err($0)"
                                let v2879 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2874 v2878 
                                let _v2877 = v2879 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v2880 : string = "Err($0)"
                                let v2881 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2874 v2880 
                                let _v2877 = v2881 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v2882 : string = "Err($0)"
                                let v2883 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2874 v2882 
                                let _v2877 = v2883 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v2884 : Result<std_path_PathBuf, std_io_Error> = v2874 |> Error
                                let _v2877 = v2884 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v2885 : Result<std_path_PathBuf, std_io_Error> = v2874 |> Error
                                let _v2877 = v2885 
                                #endif
#else
                                let v2886 : Result<std_path_PathBuf, std_io_Error> = v2874 |> Error
                                let _v2877 = v2886 
                                #endif
                                let v2887 : Result<std_path_PathBuf, std_io_Error> = _v2877 
                                v2887
                            | US8_0(v2760) -> (* Ok *)
                                let v2761 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v2762 : string = "$0.display()"
                                let v2763 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2760 v2762 
                                let _v2761 = v2763 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v2764 : string = "$0.display()"
                                let v2765 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2760 v2764 
                                let _v2761 = v2765 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v2766 : string = "$0.display()"
                                let v2767 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2760 v2766 
                                let _v2761 = v2767 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v2768 : std_path_Display = v2760 |> unbox<std_path_Display>
                                let _v2761 = v2768 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v2771 : std_path_Display = v2760 |> unbox<std_path_Display>
                                let _v2761 = v2771 
                                #endif
#else
                                let v2774 : std_path_Display = v2760 |> unbox<std_path_Display>
                                let _v2761 = v2774 
                                #endif
                                let v2777 : std_path_Display = _v2761 
                                let v2782 : string = v2777 |> string 
                                let v2785 : string = method26(v2782, v41)
                                let v2786 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v2787 : string = "&*$0"
                                let v2788 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2785 v2787 
                                let _v2786 = v2788 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v2789 : string = "&*$0"
                                let v2790 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2785 v2789 
                                let _v2786 = v2790 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v2791 : string = "&*$0"
                                let v2792 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2785 v2791 
                                let _v2786 = v2792 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v2793 : Ref<Str> = v2785 |> unbox<Ref<Str>>
                                let _v2786 = v2793 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v2796 : Ref<Str> = v2785 |> unbox<Ref<Str>>
                                let _v2786 = v2796 
                                #endif
#else
                                let v2799 : Ref<Str> = v2785 |> unbox<Ref<Str>>
                                let _v2786 = v2799 
                                #endif
                                let v2802 : Ref<Str> = _v2786 
                                let v2807 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v2808 : string = "String::from($0)"
                                let v2809 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2802 v2808 
                                let _v2807 = v2809 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v2810 : string = "String::from($0)"
                                let v2811 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2802 v2810 
                                let _v2807 = v2811 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v2812 : string = "String::from($0)"
                                let v2813 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2802 v2812 
                                let _v2807 = v2813 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v2814 : std_string_String = v2802 |> unbox<std_string_String>
                                let _v2807 = v2814 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v2817 : std_string_String = v2802 |> unbox<std_string_String>
                                let _v2807 = v2817 
                                #endif
#else
                                let v2820 : std_string_String = v2802 |> unbox<std_string_String>
                                let _v2807 = v2820 
                                #endif
                                let v2823 : std_string_String = _v2807 
                                let v2828 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v2829 : string = "std::path::PathBuf::from($0)"
                                let v2830 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2823 v2829 
                                let _v2828 = v2830 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v2831 : string = "std::path::PathBuf::from($0)"
                                let v2832 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2823 v2831 
                                let _v2828 = v2832 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v2833 : string = "std::path::PathBuf::from($0)"
                                let v2834 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2823 v2833 
                                let _v2828 = v2834 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v2835 : std_path_PathBuf = v2823 |> std_path_PathBuf 
                                let _v2828 = v2835 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v2838 : std_path_PathBuf = v2823 |> std_path_PathBuf 
                                let _v2828 = v2838 
                                #endif
#else
                                let v2841 : std_path_PathBuf = v2823 |> std_path_PathBuf 
                                let _v2828 = v2841 
                                #endif
                                let v2844 : std_path_PathBuf = _v2828 
                                let v2849 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v2850 : string = "Ok($0)"
                                let v2851 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2844 v2850 
                                let _v2849 = v2851 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v2852 : string = "Ok($0)"
                                let v2853 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2844 v2852 
                                let _v2849 = v2853 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v2854 : string = "Ok($0)"
                                let v2855 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2844 v2854 
                                let _v2849 = v2855 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v2856 : Result<std_path_PathBuf, std_io_Error> = v2844 |> Ok
                                let _v2849 = v2856 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v2857 : Result<std_path_PathBuf, std_io_Error> = v2844 |> Ok
                                let _v2849 = v2857 
                                #endif
#else
                                let v2858 : Result<std_path_PathBuf, std_io_Error> = v2844 |> Ok
                                let _v2849 = v2858 
                                #endif
                                let v2859 : Result<std_path_PathBuf, std_io_Error> = _v2849 
                                v2859
                        else
                            let v2892 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v40} / path': {v0} / name: {v41}"
                            let v2893 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v2894 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v2895 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2892 v2894 
                            let _v2893 = v2895 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v2896 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v2897 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2892 v2896 
                            let _v2893 = v2897 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v2898 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v2899 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2892 v2898 
                            let _v2893 = v2899 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v2900 : std_io_Error = v2892 
                            let _v2893 = v2900 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v2901 : std_io_Error = v2892 
                            let _v2893 = v2901 
                            #endif
#else
                            let v2902 : std_io_Error = v2892 
                            let _v2893 = v2902 
                            #endif
                            let v2903 : std_io_Error = _v2893 
                            let v2906 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v2907 : string = "Err($0)"
                            let v2908 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2903 v2907 
                            let _v2906 = v2908 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v2909 : string = "Err($0)"
                            let v2910 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2903 v2909 
                            let _v2906 = v2910 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v2911 : string = "Err($0)"
                            let v2912 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2903 v2911 
                            let _v2906 = v2912 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v2913 : Result<std_path_PathBuf, std_io_Error> = v2903 |> Error
                            let _v2906 = v2913 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v2914 : Result<std_path_PathBuf, std_io_Error> = v2903 |> Error
                            let _v2906 = v2914 
                            #endif
#else
                            let v2915 : Result<std_path_PathBuf, std_io_Error> = v2903 |> Error
                            let _v2906 = v2915 
                            #endif
                            let v2916 : Result<std_path_PathBuf, std_io_Error> = _v2906 
                            v2916
                    | _ ->
                        let v2920 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v40} / path': {v0} / name: {v41}"
                        let v2921 : unit = ()
                        
#if FABLE_COMPILER || WASM || CONTRACT
                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                        let v2922 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                        let v2923 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2920 v2922 
                        let _v2921 = v2923 
                        #endif
#if FABLE_COMPILER_RUST && WASM
                        let v2924 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                        let v2925 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2920 v2924 
                        let _v2921 = v2925 
                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                        let v2926 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                        let v2927 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2920 v2926 
                        let _v2921 = v2927 
                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                        let v2928 : std_io_Error = v2920 
                        let _v2921 = v2928 
                        #endif
#if FABLE_COMPILER_PYTHON
                        let v2929 : std_io_Error = v2920 
                        let _v2921 = v2929 
                        #endif
#else
                        let v2930 : std_io_Error = v2920 
                        let _v2921 = v2930 
                        #endif
                        let v2931 : std_io_Error = _v2921 
                        let v2934 : unit = ()
                        
#if FABLE_COMPILER || WASM || CONTRACT
                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                        let v2935 : string = "Err($0)"
                        let v2936 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2931 v2935 
                        let _v2934 = v2936 
                        #endif
#if FABLE_COMPILER_RUST && WASM
                        let v2937 : string = "Err($0)"
                        let v2938 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2931 v2937 
                        let _v2934 = v2938 
                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                        let v2939 : string = "Err($0)"
                        let v2940 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2931 v2939 
                        let _v2934 = v2940 
                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                        let v2941 : Result<std_path_PathBuf, std_io_Error> = v2931 |> Error
                        let _v2934 = v2941 
                        #endif
#if FABLE_COMPILER_PYTHON
                        let v2942 : Result<std_path_PathBuf, std_io_Error> = v2931 |> Error
                        let _v2934 = v2942 
                        #endif
#else
                        let v2943 : Result<std_path_PathBuf, std_io_Error> = v2931 |> Error
                        let _v2934 = v2943 
                        #endif
                        let v2944 : Result<std_path_PathBuf, std_io_Error> = _v2934 
                        v2944
                | US8_0(v26) -> (* Ok *)
                    let v27 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v28 : string = "Ok($0)"
                    let v29 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v26 v28 
                    let _v27 = v29 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v30 : string = "Ok($0)"
                    let v31 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v26 v30 
                    let _v27 = v31 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v32 : string = "Ok($0)"
                    let v33 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v26 v32 
                    let _v27 = v33 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v34 : Result<std_path_PathBuf, std_io_Error> = v26 |> Ok
                    let _v27 = v34 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v35 : Result<std_path_PathBuf, std_io_Error> = v26 |> Ok
                    let _v27 = v35 
                    #endif
#else
                    let v36 : Result<std_path_PathBuf, std_io_Error> = v26 |> Ok
                    let _v27 = v36 
                    #endif
                    let v37 : Result<std_path_PathBuf, std_io_Error> = _v27 
                    v37
        let _v3 = v2950 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v2951 : bool = method30(v0)
        let v5897 : Result<std_path_PathBuf, std_io_Error> =
            if v2951 then
                let v2952 : string = "std::fs::read_link(&*$0)"
                let v2953 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v0 v2952 
                v2953
            else
                let v2954 : string = "std::fs::read_link(&*$0)"
                let v2955 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v0 v2954 
                let v2956 : (std_io_Error -> string) = method41()
                let v2957 : unit = ()
                
#if FABLE_COMPILER || WASM || CONTRACT
                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                let v2958 : string = "$0.map_err(|x| $1(x))"
                let v2959 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2955, v2956) v2958 
                let _v2957 = v2959 
                #endif
#if FABLE_COMPILER_RUST && WASM
                let v2960 : string = "$0.map_err(|x| $1(x))"
                let v2961 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2955, v2956) v2960 
                let _v2957 = v2961 
                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                let v2962 : string = "$0.map_err(|x| $1(x))"
                let v2963 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2955, v2956) v2962 
                let _v2957 = v2963 
                #endif
#if FABLE_COMPILER_TYPESCRIPT
                let v2964 : Result<std_path_PathBuf, string> = match v2955 with Ok x -> Ok x | Error x -> Error (v2956 x)
                let _v2957 = v2964 
                #endif
#if FABLE_COMPILER_PYTHON
                let v2965 : Result<std_path_PathBuf, string> = match v2955 with Ok x -> Ok x | Error x -> Error (v2956 x)
                let _v2957 = v2965 
                #endif
#else
                let v2966 : Result<std_path_PathBuf, string> = match v2955 with Ok x -> Ok x | Error x -> Error (v2956 x)
                let _v2957 = v2966 
                #endif
                let v2967 : Result<std_path_PathBuf, string> = _v2957 
                let v2970 : (std_path_PathBuf -> US8) = closure16()
                let v2971 : (string -> US8) = closure17()
                let v2972 : US8 = match v2967 with Ok x -> v2970 x | Error x -> v2971 x
                match v2972 with
                | US8_1(v2987) -> (* Error *)
                    let v2988 : string = method43(v0)
                    let v2989 : string option = method32(v0)
                    let v2990 : (string -> US1) = method5()
                    let v2991 : US1 option = v2989 |> Option.map v2990 
                    let v3002 : US1 = US1_1
                    let v3003 : US1 = v2991 |> Option.defaultValue v3002 
                    match v3003 with
                    | US1_0(v3007) -> (* Some *)
                        let v3008 : string = ""
                        let v3009 : bool = v0 <> v3008 
                        if v3009 then
                            let v3012 : string = "std::fs::read_link(&*$0)"
                            let v3013 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3007 v3012 
                            let v3014 : (std_io_Error -> string) = method41()
                            let v3015 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v3016 : string = "$0.map_err(|x| $1(x))"
                            let v3017 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3013, v3014) v3016 
                            let _v3015 = v3017 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v3018 : string = "$0.map_err(|x| $1(x))"
                            let v3019 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3013, v3014) v3018 
                            let _v3015 = v3019 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v3020 : string = "$0.map_err(|x| $1(x))"
                            let v3021 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3013, v3014) v3020 
                            let _v3015 = v3021 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v3022 : Result<std_path_PathBuf, string> = match v3013 with Ok x -> Ok x | Error x -> Error (v3014 x)
                            let _v3015 = v3022 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v3023 : Result<std_path_PathBuf, string> = match v3013 with Ok x -> Ok x | Error x -> Error (v3014 x)
                            let _v3015 = v3023 
                            #endif
#else
                            let v3024 : Result<std_path_PathBuf, string> = match v3013 with Ok x -> Ok x | Error x -> Error (v3014 x)
                            let _v3015 = v3024 
                            #endif
                            let v3025 : Result<std_path_PathBuf, string> = _v3015 
                            let v3028 : US8 = match v3025 with Ok x -> v2970 x | Error x -> v2971 x
                            let v5691 : Result<std_path_PathBuf, std_io_Error> =
                                match v3028 with
                                | US8_1(v3043) -> (* Error *)
                                    let v3044 : string = method43(v3007)
                                    let v3045 : string option = method32(v3007)
                                    let v3046 : (string -> US1) = method5()
                                    let v3047 : US1 option = v3045 |> Option.map v3046 
                                    let v3058 : US1 = US1_1
                                    let v3059 : US1 = v3047 |> Option.defaultValue v3058 
                                    match v3059 with
                                    | US1_0(v3063) -> (* Some *)
                                        let v3064 : bool = v3007 <> v3008 
                                        if v3064 then
                                            let v3067 : string = "std::fs::read_link(&*$0)"
                                            let v3068 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3063 v3067 
                                            let v3069 : (std_io_Error -> string) = method41()
                                            let v3070 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v3071 : string = "$0.map_err(|x| $1(x))"
                                            let v3072 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3068, v3069) v3071 
                                            let _v3070 = v3072 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v3073 : string = "$0.map_err(|x| $1(x))"
                                            let v3074 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3068, v3069) v3073 
                                            let _v3070 = v3074 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v3075 : string = "$0.map_err(|x| $1(x))"
                                            let v3076 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3068, v3069) v3075 
                                            let _v3070 = v3076 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v3077 : Result<std_path_PathBuf, string> = match v3068 with Ok x -> Ok x | Error x -> Error (v3069 x)
                                            let _v3070 = v3077 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v3078 : Result<std_path_PathBuf, string> = match v3068 with Ok x -> Ok x | Error x -> Error (v3069 x)
                                            let _v3070 = v3078 
                                            #endif
#else
                                            let v3079 : Result<std_path_PathBuf, string> = match v3068 with Ok x -> Ok x | Error x -> Error (v3069 x)
                                            let _v3070 = v3079 
                                            #endif
                                            let v3080 : Result<std_path_PathBuf, string> = _v3070 
                                            let v3083 : US8 = match v3080 with Ok x -> v2970 x | Error x -> v2971 x
                                            let v5486 : Result<std_path_PathBuf, std_io_Error> =
                                                match v3083 with
                                                | US8_1(v3098) -> (* Error *)
                                                    let v3099 : string = method43(v3063)
                                                    let v3100 : string option = method32(v3063)
                                                    let v3101 : (string -> US1) = method5()
                                                    let v3102 : US1 option = v3100 |> Option.map v3101 
                                                    let v3113 : US1 = US1_1
                                                    let v3114 : US1 = v3102 |> Option.defaultValue v3113 
                                                    match v3114 with
                                                    | US1_0(v3118) -> (* Some *)
                                                        let v3119 : bool = v3063 <> v3008 
                                                        if v3119 then
                                                            let v3122 : string = "std::fs::read_link(&*$0)"
                                                            let v3123 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3118 v3122 
                                                            let v3124 : (std_io_Error -> string) = method41()
                                                            let v3125 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v3126 : string = "$0.map_err(|x| $1(x))"
                                                            let v3127 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3123, v3124) v3126 
                                                            let _v3125 = v3127 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v3128 : string = "$0.map_err(|x| $1(x))"
                                                            let v3129 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3123, v3124) v3128 
                                                            let _v3125 = v3129 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v3130 : string = "$0.map_err(|x| $1(x))"
                                                            let v3131 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3123, v3124) v3130 
                                                            let _v3125 = v3131 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v3132 : Result<std_path_PathBuf, string> = match v3123 with Ok x -> Ok x | Error x -> Error (v3124 x)
                                                            let _v3125 = v3132 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v3133 : Result<std_path_PathBuf, string> = match v3123 with Ok x -> Ok x | Error x -> Error (v3124 x)
                                                            let _v3125 = v3133 
                                                            #endif
#else
                                                            let v3134 : Result<std_path_PathBuf, string> = match v3123 with Ok x -> Ok x | Error x -> Error (v3124 x)
                                                            let _v3125 = v3134 
                                                            #endif
                                                            let v3135 : Result<std_path_PathBuf, string> = _v3125 
                                                            let v3138 : US8 = match v3135 with Ok x -> v2970 x | Error x -> v2971 x
                                                            let v5281 : Result<std_path_PathBuf, std_io_Error> =
                                                                match v3138 with
                                                                | US8_1(v3153) -> (* Error *)
                                                                    let v3154 : string = method43(v3118)
                                                                    let v3155 : string option = method32(v3118)
                                                                    let v3156 : (string -> US1) = method5()
                                                                    let v3157 : US1 option = v3155 |> Option.map v3156 
                                                                    let v3168 : US1 = US1_1
                                                                    let v3169 : US1 = v3157 |> Option.defaultValue v3168 
                                                                    match v3169 with
                                                                    | US1_0(v3173) -> (* Some *)
                                                                        let v3174 : bool = v3118 <> v3008 
                                                                        if v3174 then
                                                                            let v3177 : string = "std::fs::read_link(&*$0)"
                                                                            let v3178 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3173 v3177 
                                                                            let v3179 : (std_io_Error -> string) = method41()
                                                                            let v3180 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v3181 : string = "$0.map_err(|x| $1(x))"
                                                                            let v3182 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3178, v3179) v3181 
                                                                            let _v3180 = v3182 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v3183 : string = "$0.map_err(|x| $1(x))"
                                                                            let v3184 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3178, v3179) v3183 
                                                                            let _v3180 = v3184 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v3185 : string = "$0.map_err(|x| $1(x))"
                                                                            let v3186 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3178, v3179) v3185 
                                                                            let _v3180 = v3186 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v3187 : Result<std_path_PathBuf, string> = match v3178 with Ok x -> Ok x | Error x -> Error (v3179 x)
                                                                            let _v3180 = v3187 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v3188 : Result<std_path_PathBuf, string> = match v3178 with Ok x -> Ok x | Error x -> Error (v3179 x)
                                                                            let _v3180 = v3188 
                                                                            #endif
#else
                                                                            let v3189 : Result<std_path_PathBuf, string> = match v3178 with Ok x -> Ok x | Error x -> Error (v3179 x)
                                                                            let _v3180 = v3189 
                                                                            #endif
                                                                            let v3190 : Result<std_path_PathBuf, string> = _v3180 
                                                                            let v3193 : US8 = match v3190 with Ok x -> v2970 x | Error x -> v2971 x
                                                                            let v5076 : Result<std_path_PathBuf, std_io_Error> =
                                                                                match v3193 with
                                                                                | US8_1(v3208) -> (* Error *)
                                                                                    let v3209 : string = method43(v3173)
                                                                                    let v3210 : string option = method32(v3173)
                                                                                    let v3211 : (string -> US1) = method5()
                                                                                    let v3212 : US1 option = v3210 |> Option.map v3211 
                                                                                    let v3223 : US1 = US1_1
                                                                                    let v3224 : US1 = v3212 |> Option.defaultValue v3223 
                                                                                    match v3224 with
                                                                                    | US1_0(v3228) -> (* Some *)
                                                                                        let v3229 : bool = v3173 <> v3008 
                                                                                        if v3229 then
                                                                                            let v3232 : string = "std::fs::read_link(&*$0)"
                                                                                            let v3233 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3228 v3232 
                                                                                            let v3234 : (std_io_Error -> string) = method41()
                                                                                            let v3235 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v3236 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v3237 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3233, v3234) v3236 
                                                                                            let _v3235 = v3237 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v3238 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v3239 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3233, v3234) v3238 
                                                                                            let _v3235 = v3239 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v3240 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v3241 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3233, v3234) v3240 
                                                                                            let _v3235 = v3241 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v3242 : Result<std_path_PathBuf, string> = match v3233 with Ok x -> Ok x | Error x -> Error (v3234 x)
                                                                                            let _v3235 = v3242 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v3243 : Result<std_path_PathBuf, string> = match v3233 with Ok x -> Ok x | Error x -> Error (v3234 x)
                                                                                            let _v3235 = v3243 
                                                                                            #endif
#else
                                                                                            let v3244 : Result<std_path_PathBuf, string> = match v3233 with Ok x -> Ok x | Error x -> Error (v3234 x)
                                                                                            let _v3235 = v3244 
                                                                                            #endif
                                                                                            let v3245 : Result<std_path_PathBuf, string> = _v3235 
                                                                                            let v3248 : US8 = match v3245 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                            let v4871 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                match v3248 with
                                                                                                | US8_1(v3263) -> (* Error *)
                                                                                                    let v3264 : string = method43(v3228)
                                                                                                    let v3265 : string option = method32(v3228)
                                                                                                    let v3266 : (string -> US1) = method5()
                                                                                                    let v3267 : US1 option = v3265 |> Option.map v3266 
                                                                                                    let v3278 : US1 = US1_1
                                                                                                    let v3279 : US1 = v3267 |> Option.defaultValue v3278 
                                                                                                    match v3279 with
                                                                                                    | US1_0(v3283) -> (* Some *)
                                                                                                        let v3284 : bool = v3228 <> v3008 
                                                                                                        if v3284 then
                                                                                                            let v3287 : string = "std::fs::read_link(&*$0)"
                                                                                                            let v3288 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3283 v3287 
                                                                                                            let v3289 : (std_io_Error -> string) = method41()
                                                                                                            let v3290 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v3291 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v3292 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3288, v3289) v3291 
                                                                                                            let _v3290 = v3292 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v3293 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v3294 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3288, v3289) v3293 
                                                                                                            let _v3290 = v3294 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v3295 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v3296 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3288, v3289) v3295 
                                                                                                            let _v3290 = v3296 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v3297 : Result<std_path_PathBuf, string> = match v3288 with Ok x -> Ok x | Error x -> Error (v3289 x)
                                                                                                            let _v3290 = v3297 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v3298 : Result<std_path_PathBuf, string> = match v3288 with Ok x -> Ok x | Error x -> Error (v3289 x)
                                                                                                            let _v3290 = v3298 
                                                                                                            #endif
#else
                                                                                                            let v3299 : Result<std_path_PathBuf, string> = match v3288 with Ok x -> Ok x | Error x -> Error (v3289 x)
                                                                                                            let _v3290 = v3299 
                                                                                                            #endif
                                                                                                            let v3300 : Result<std_path_PathBuf, string> = _v3290 
                                                                                                            let v3303 : US8 = match v3300 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                            let v4666 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                match v3303 with
                                                                                                                | US8_1(v3318) -> (* Error *)
                                                                                                                    let v3319 : string = method43(v3283)
                                                                                                                    let v3320 : string option = method32(v3283)
                                                                                                                    let v3321 : (string -> US1) = method5()
                                                                                                                    let v3322 : US1 option = v3320 |> Option.map v3321 
                                                                                                                    let v3333 : US1 = US1_1
                                                                                                                    let v3334 : US1 = v3322 |> Option.defaultValue v3333 
                                                                                                                    match v3334 with
                                                                                                                    | US1_0(v3338) -> (* Some *)
                                                                                                                        let v3339 : bool = v3283 <> v3008 
                                                                                                                        if v3339 then
                                                                                                                            let v3342 : string = "std::fs::read_link(&*$0)"
                                                                                                                            let v3343 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3338 v3342 
                                                                                                                            let v3344 : (std_io_Error -> string) = method41()
                                                                                                                            let v3345 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v3346 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v3347 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3343, v3344) v3346 
                                                                                                                            let _v3345 = v3347 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v3348 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v3349 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3343, v3344) v3348 
                                                                                                                            let _v3345 = v3349 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v3350 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v3351 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3343, v3344) v3350 
                                                                                                                            let _v3345 = v3351 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v3352 : Result<std_path_PathBuf, string> = match v3343 with Ok x -> Ok x | Error x -> Error (v3344 x)
                                                                                                                            let _v3345 = v3352 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v3353 : Result<std_path_PathBuf, string> = match v3343 with Ok x -> Ok x | Error x -> Error (v3344 x)
                                                                                                                            let _v3345 = v3353 
                                                                                                                            #endif
#else
                                                                                                                            let v3354 : Result<std_path_PathBuf, string> = match v3343 with Ok x -> Ok x | Error x -> Error (v3344 x)
                                                                                                                            let _v3345 = v3354 
                                                                                                                            #endif
                                                                                                                            let v3355 : Result<std_path_PathBuf, string> = _v3345 
                                                                                                                            let v3358 : US8 = match v3355 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                            let v4461 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                match v3358 with
                                                                                                                                | US8_1(v3373) -> (* Error *)
                                                                                                                                    let v3374 : string = method43(v3338)
                                                                                                                                    let v3375 : string option = method32(v3338)
                                                                                                                                    let v3376 : (string -> US1) = method5()
                                                                                                                                    let v3377 : US1 option = v3375 |> Option.map v3376 
                                                                                                                                    let v3388 : US1 = US1_1
                                                                                                                                    let v3389 : US1 = v3377 |> Option.defaultValue v3388 
                                                                                                                                    match v3389 with
                                                                                                                                    | US1_0(v3393) -> (* Some *)
                                                                                                                                        let v3394 : bool = v3338 <> v3008 
                                                                                                                                        if v3394 then
                                                                                                                                            let v3397 : string = "std::fs::read_link(&*$0)"
                                                                                                                                            let v3398 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3393 v3397 
                                                                                                                                            let v3399 : (std_io_Error -> string) = method41()
                                                                                                                                            let v3400 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v3401 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v3402 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3398, v3399) v3401 
                                                                                                                                            let _v3400 = v3402 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v3403 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v3404 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3398, v3399) v3403 
                                                                                                                                            let _v3400 = v3404 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v3405 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v3406 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3398, v3399) v3405 
                                                                                                                                            let _v3400 = v3406 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v3407 : Result<std_path_PathBuf, string> = match v3398 with Ok x -> Ok x | Error x -> Error (v3399 x)
                                                                                                                                            let _v3400 = v3407 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v3408 : Result<std_path_PathBuf, string> = match v3398 with Ok x -> Ok x | Error x -> Error (v3399 x)
                                                                                                                                            let _v3400 = v3408 
                                                                                                                                            #endif
#else
                                                                                                                                            let v3409 : Result<std_path_PathBuf, string> = match v3398 with Ok x -> Ok x | Error x -> Error (v3399 x)
                                                                                                                                            let _v3400 = v3409 
                                                                                                                                            #endif
                                                                                                                                            let v3410 : Result<std_path_PathBuf, string> = _v3400 
                                                                                                                                            let v3413 : US8 = match v3410 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                                            let v4256 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                match v3413 with
                                                                                                                                                | US8_1(v3428) -> (* Error *)
                                                                                                                                                    let v3429 : string = method43(v3393)
                                                                                                                                                    let v3430 : string option = method32(v3393)
                                                                                                                                                    let v3431 : (string -> US1) = method5()
                                                                                                                                                    let v3432 : US1 option = v3430 |> Option.map v3431 
                                                                                                                                                    let v3443 : US1 = US1_1
                                                                                                                                                    let v3444 : US1 = v3432 |> Option.defaultValue v3443 
                                                                                                                                                    match v3444 with
                                                                                                                                                    | US1_0(v3448) -> (* Some *)
                                                                                                                                                        let v3449 : bool = v3393 <> v3008 
                                                                                                                                                        if v3449 then
                                                                                                                                                            let v3452 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                            let v3453 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3448 v3452 
                                                                                                                                                            let v3454 : (std_io_Error -> string) = method41()
                                                                                                                                                            let v3455 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v3456 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v3457 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3453, v3454) v3456 
                                                                                                                                                            let _v3455 = v3457 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v3458 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v3459 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3453, v3454) v3458 
                                                                                                                                                            let _v3455 = v3459 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v3460 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v3461 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3453, v3454) v3460 
                                                                                                                                                            let _v3455 = v3461 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v3462 : Result<std_path_PathBuf, string> = match v3453 with Ok x -> Ok x | Error x -> Error (v3454 x)
                                                                                                                                                            let _v3455 = v3462 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v3463 : Result<std_path_PathBuf, string> = match v3453 with Ok x -> Ok x | Error x -> Error (v3454 x)
                                                                                                                                                            let _v3455 = v3463 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v3464 : Result<std_path_PathBuf, string> = match v3453 with Ok x -> Ok x | Error x -> Error (v3454 x)
                                                                                                                                                            let _v3455 = v3464 
                                                                                                                                                            #endif
                                                                                                                                                            let v3465 : Result<std_path_PathBuf, string> = _v3455 
                                                                                                                                                            let v3468 : US8 = match v3465 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                                                            let v4051 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                match v3468 with
                                                                                                                                                                | US8_1(v3483) -> (* Error *)
                                                                                                                                                                    let v3484 : string = method43(v3448)
                                                                                                                                                                    let v3485 : string option = method32(v3448)
                                                                                                                                                                    let v3486 : (string -> US1) = method5()
                                                                                                                                                                    let v3487 : US1 option = v3485 |> Option.map v3486 
                                                                                                                                                                    let v3498 : US1 = US1_1
                                                                                                                                                                    let v3499 : US1 = v3487 |> Option.defaultValue v3498 
                                                                                                                                                                    match v3499 with
                                                                                                                                                                    | US1_0(v3503) -> (* Some *)
                                                                                                                                                                        let v3504 : bool = v3448 <> v3008 
                                                                                                                                                                        if v3504 then
                                                                                                                                                                            let v3507 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                                            let v3508 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3503 v3507 
                                                                                                                                                                            let v3509 : (std_io_Error -> string) = method41()
                                                                                                                                                                            let v3510 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v3511 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v3512 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3508, v3509) v3511 
                                                                                                                                                                            let _v3510 = v3512 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v3513 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v3514 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3508, v3509) v3513 
                                                                                                                                                                            let _v3510 = v3514 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v3515 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v3516 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3508, v3509) v3515 
                                                                                                                                                                            let _v3510 = v3516 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v3517 : Result<std_path_PathBuf, string> = match v3508 with Ok x -> Ok x | Error x -> Error (v3509 x)
                                                                                                                                                                            let _v3510 = v3517 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v3518 : Result<std_path_PathBuf, string> = match v3508 with Ok x -> Ok x | Error x -> Error (v3509 x)
                                                                                                                                                                            let _v3510 = v3518 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v3519 : Result<std_path_PathBuf, string> = match v3508 with Ok x -> Ok x | Error x -> Error (v3509 x)
                                                                                                                                                                            let _v3510 = v3519 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v3520 : Result<std_path_PathBuf, string> = _v3510 
                                                                                                                                                                            let v3523 : US8 = match v3520 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                                                                            let v3846 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                match v3523 with
                                                                                                                                                                                | US8_1(v3538) -> (* Error *)
                                                                                                                                                                                    let v3539 : string = method43(v3503)
                                                                                                                                                                                    let v3540 : string option = method32(v3503)
                                                                                                                                                                                    let v3541 : (string -> US1) = method5()
                                                                                                                                                                                    let v3542 : US1 option = v3540 |> Option.map v3541 
                                                                                                                                                                                    let v3553 : US1 = US1_1
                                                                                                                                                                                    let v3554 : US1 = v3542 |> Option.defaultValue v3553 
                                                                                                                                                                                    match v3554 with
                                                                                                                                                                                    | US1_0(v3558) -> (* Some *)
                                                                                                                                                                                        let v3559 : bool = v3503 <> v3008 
                                                                                                                                                                                        if v3559 then
                                                                                                                                                                                            let v3562 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                                                            let v3563 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3558 v3562 
                                                                                                                                                                                            let v3564 : (std_io_Error -> string) = method41()
                                                                                                                                                                                            let v3565 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v3566 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v3567 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3563, v3564) v3566 
                                                                                                                                                                                            let _v3565 = v3567 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v3568 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v3569 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3563, v3564) v3568 
                                                                                                                                                                                            let _v3565 = v3569 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v3570 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v3571 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3563, v3564) v3570 
                                                                                                                                                                                            let _v3565 = v3571 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v3572 : Result<std_path_PathBuf, string> = match v3563 with Ok x -> Ok x | Error x -> Error (v3564 x)
                                                                                                                                                                                            let _v3565 = v3572 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v3573 : Result<std_path_PathBuf, string> = match v3563 with Ok x -> Ok x | Error x -> Error (v3564 x)
                                                                                                                                                                                            let _v3565 = v3573 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v3574 : Result<std_path_PathBuf, string> = match v3563 with Ok x -> Ok x | Error x -> Error (v3564 x)
                                                                                                                                                                                            let _v3565 = v3574 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v3575 : Result<std_path_PathBuf, string> = _v3565 
                                                                                                                                                                                            let v3578 : US8 = match v3575 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                                                                                            let v3641 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                                match v3578 with
                                                                                                                                                                                                | US8_1(v3593) -> (* Error *)
                                                                                                                                                                                                    let v3594 : string = method43(v3558)
                                                                                                                                                                                                    let v3595 : string option = method32(v3558)
                                                                                                                                                                                                    let v3596 : (string -> US1) = method5()
                                                                                                                                                                                                    let v3597 : US1 option = v3595 |> Option.map v3596 
                                                                                                                                                                                                    let v3608 : US1 = US1_1
                                                                                                                                                                                                    let v3609 : US1 = v3597 |> Option.defaultValue v3608 
                                                                                                                                                                                                    let v3613 : string = $"file_system.read_link / path: {v0} / n: {11uy} / path': {v3558} / name: {v3594}"
                                                                                                                                                                                                    let v3614 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v3615 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v3616 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3613 v3615 
                                                                                                                                                                                                    let _v3614 = v3616 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v3617 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v3618 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3613 v3617 
                                                                                                                                                                                                    let _v3614 = v3618 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v3619 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v3620 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3613 v3619 
                                                                                                                                                                                                    let _v3614 = v3620 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v3621 : std_io_Error = v3613 
                                                                                                                                                                                                    let _v3614 = v3621 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v3622 : std_io_Error = v3613 
                                                                                                                                                                                                    let _v3614 = v3622 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v3623 : std_io_Error = v3613 
                                                                                                                                                                                                    let _v3614 = v3623 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v3624 : std_io_Error = _v3614 
                                                                                                                                                                                                    let v3627 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v3628 : string = "Err($0)"
                                                                                                                                                                                                    let v3629 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3624 v3628 
                                                                                                                                                                                                    let _v3627 = v3629 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v3630 : string = "Err($0)"
                                                                                                                                                                                                    let v3631 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3624 v3630 
                                                                                                                                                                                                    let _v3627 = v3631 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v3632 : string = "Err($0)"
                                                                                                                                                                                                    let v3633 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3624 v3632 
                                                                                                                                                                                                    let _v3627 = v3633 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v3634 : Result<std_path_PathBuf, std_io_Error> = v3624 |> Error
                                                                                                                                                                                                    let _v3627 = v3634 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v3635 : Result<std_path_PathBuf, std_io_Error> = v3624 |> Error
                                                                                                                                                                                                    let _v3627 = v3635 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v3636 : Result<std_path_PathBuf, std_io_Error> = v3624 |> Error
                                                                                                                                                                                                    let _v3627 = v3636 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v3637 : Result<std_path_PathBuf, std_io_Error> = _v3627 
                                                                                                                                                                                                    v3637
                                                                                                                                                                                                | US8_0(v3579) -> (* Ok *)
                                                                                                                                                                                                    let v3580 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v3581 : string = "Ok($0)"
                                                                                                                                                                                                    let v3582 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3579 v3581 
                                                                                                                                                                                                    let _v3580 = v3582 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v3583 : string = "Ok($0)"
                                                                                                                                                                                                    let v3584 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3579 v3583 
                                                                                                                                                                                                    let _v3580 = v3584 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v3585 : string = "Ok($0)"
                                                                                                                                                                                                    let v3586 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3579 v3585 
                                                                                                                                                                                                    let _v3580 = v3586 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v3587 : Result<std_path_PathBuf, std_io_Error> = v3579 |> Ok
                                                                                                                                                                                                    let _v3580 = v3587 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v3588 : Result<std_path_PathBuf, std_io_Error> = v3579 |> Ok
                                                                                                                                                                                                    let _v3580 = v3588 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v3589 : Result<std_path_PathBuf, std_io_Error> = v3579 |> Ok
                                                                                                                                                                                                    let _v3580 = v3589 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v3590 : Result<std_path_PathBuf, std_io_Error> = _v3580 
                                                                                                                                                                                                    v3590
                                                                                                                                                                                            let v3642 : (std_io_Error -> string) = method41()
                                                                                                                                                                                            let v3643 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v3644 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v3645 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3641, v3642) v3644 
                                                                                                                                                                                            let _v3643 = v3645 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v3646 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v3647 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3641, v3642) v3646 
                                                                                                                                                                                            let _v3643 = v3647 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v3648 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v3649 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3641, v3642) v3648 
                                                                                                                                                                                            let _v3643 = v3649 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v3650 : Result<std_path_PathBuf, string> = match v3641 with Ok x -> Ok x | Error x -> Error (v3642 x)
                                                                                                                                                                                            let _v3643 = v3650 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v3651 : Result<std_path_PathBuf, string> = match v3641 with Ok x -> Ok x | Error x -> Error (v3642 x)
                                                                                                                                                                                            let _v3643 = v3651 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v3652 : Result<std_path_PathBuf, string> = match v3641 with Ok x -> Ok x | Error x -> Error (v3642 x)
                                                                                                                                                                                            let _v3643 = v3652 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v3653 : Result<std_path_PathBuf, string> = _v3643 
                                                                                                                                                                                            let v3656 : US8 = match v3653 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                                                                                            match v3656 with
                                                                                                                                                                                            | US8_1(v3759) -> (* Error *)
                                                                                                                                                                                                let v3760 : string = $"file_system.read_link / error': {v3759} / error: {v3538} / name: {v3539}"
                                                                                                                                                                                                let v3761 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v3762 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v3763 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3760 v3762 
                                                                                                                                                                                                let _v3761 = v3763 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v3764 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v3765 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3760 v3764 
                                                                                                                                                                                                let _v3761 = v3765 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v3766 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v3767 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3760 v3766 
                                                                                                                                                                                                let _v3761 = v3767 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v3768 : std_io_Error = v3760 
                                                                                                                                                                                                let _v3761 = v3768 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v3769 : std_io_Error = v3760 
                                                                                                                                                                                                let _v3761 = v3769 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v3770 : std_io_Error = v3760 
                                                                                                                                                                                                let _v3761 = v3770 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v3771 : std_io_Error = _v3761 
                                                                                                                                                                                                let v3774 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v3775 : string = "Err($0)"
                                                                                                                                                                                                let v3776 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3771 v3775 
                                                                                                                                                                                                let _v3774 = v3776 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v3777 : string = "Err($0)"
                                                                                                                                                                                                let v3778 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3771 v3777 
                                                                                                                                                                                                let _v3774 = v3778 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v3779 : string = "Err($0)"
                                                                                                                                                                                                let v3780 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3771 v3779 
                                                                                                                                                                                                let _v3774 = v3780 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v3781 : Result<std_path_PathBuf, std_io_Error> = v3771 |> Error
                                                                                                                                                                                                let _v3774 = v3781 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v3782 : Result<std_path_PathBuf, std_io_Error> = v3771 |> Error
                                                                                                                                                                                                let _v3774 = v3782 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v3783 : Result<std_path_PathBuf, std_io_Error> = v3771 |> Error
                                                                                                                                                                                                let _v3774 = v3783 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v3784 : Result<std_path_PathBuf, std_io_Error> = _v3774 
                                                                                                                                                                                                v3784
                                                                                                                                                                                            | US8_0(v3657) -> (* Ok *)
                                                                                                                                                                                                let v3658 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v3659 : string = "$0.display()"
                                                                                                                                                                                                let v3660 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v3657 v3659 
                                                                                                                                                                                                let _v3658 = v3660 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v3661 : string = "$0.display()"
                                                                                                                                                                                                let v3662 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v3657 v3661 
                                                                                                                                                                                                let _v3658 = v3662 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v3663 : string = "$0.display()"
                                                                                                                                                                                                let v3664 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v3657 v3663 
                                                                                                                                                                                                let _v3658 = v3664 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v3665 : std_path_Display = v3657 |> unbox<std_path_Display>
                                                                                                                                                                                                let _v3658 = v3665 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v3668 : std_path_Display = v3657 |> unbox<std_path_Display>
                                                                                                                                                                                                let _v3658 = v3668 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v3671 : std_path_Display = v3657 |> unbox<std_path_Display>
                                                                                                                                                                                                let _v3658 = v3671 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v3674 : std_path_Display = _v3658 
                                                                                                                                                                                                let v3679 : string = v3674 |> string 
                                                                                                                                                                                                let v3682 : string = method26(v3679, v3539)
                                                                                                                                                                                                let v3683 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v3684 : string = "&*$0"
                                                                                                                                                                                                let v3685 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v3682 v3684 
                                                                                                                                                                                                let _v3683 = v3685 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v3686 : string = "&*$0"
                                                                                                                                                                                                let v3687 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v3682 v3686 
                                                                                                                                                                                                let _v3683 = v3687 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v3688 : string = "&*$0"
                                                                                                                                                                                                let v3689 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v3682 v3688 
                                                                                                                                                                                                let _v3683 = v3689 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v3690 : Ref<Str> = v3682 |> unbox<Ref<Str>>
                                                                                                                                                                                                let _v3683 = v3690 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v3693 : Ref<Str> = v3682 |> unbox<Ref<Str>>
                                                                                                                                                                                                let _v3683 = v3693 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v3696 : Ref<Str> = v3682 |> unbox<Ref<Str>>
                                                                                                                                                                                                let _v3683 = v3696 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v3699 : Ref<Str> = _v3683 
                                                                                                                                                                                                let v3704 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v3705 : string = "String::from($0)"
                                                                                                                                                                                                let v3706 : std_string_String = Fable.Core.RustInterop.emitRustExpr v3699 v3705 
                                                                                                                                                                                                let _v3704 = v3706 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v3707 : string = "String::from($0)"
                                                                                                                                                                                                let v3708 : std_string_String = Fable.Core.RustInterop.emitRustExpr v3699 v3707 
                                                                                                                                                                                                let _v3704 = v3708 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v3709 : string = "String::from($0)"
                                                                                                                                                                                                let v3710 : std_string_String = Fable.Core.RustInterop.emitRustExpr v3699 v3709 
                                                                                                                                                                                                let _v3704 = v3710 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v3711 : std_string_String = v3699 |> unbox<std_string_String>
                                                                                                                                                                                                let _v3704 = v3711 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v3714 : std_string_String = v3699 |> unbox<std_string_String>
                                                                                                                                                                                                let _v3704 = v3714 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v3717 : std_string_String = v3699 |> unbox<std_string_String>
                                                                                                                                                                                                let _v3704 = v3717 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v3720 : std_string_String = _v3704 
                                                                                                                                                                                                let v3725 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v3726 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                let v3727 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v3720 v3726 
                                                                                                                                                                                                let _v3725 = v3727 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v3728 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                let v3729 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v3720 v3728 
                                                                                                                                                                                                let _v3725 = v3729 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v3730 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                let v3731 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v3720 v3730 
                                                                                                                                                                                                let _v3725 = v3731 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v3732 : std_path_PathBuf = v3720 |> std_path_PathBuf 
                                                                                                                                                                                                let _v3725 = v3732 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v3735 : std_path_PathBuf = v3720 |> std_path_PathBuf 
                                                                                                                                                                                                let _v3725 = v3735 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v3738 : std_path_PathBuf = v3720 |> std_path_PathBuf 
                                                                                                                                                                                                let _v3725 = v3738 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v3741 : std_path_PathBuf = _v3725 
                                                                                                                                                                                                let v3746 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v3747 : string = "Ok($0)"
                                                                                                                                                                                                let v3748 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3741 v3747 
                                                                                                                                                                                                let _v3746 = v3748 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v3749 : string = "Ok($0)"
                                                                                                                                                                                                let v3750 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3741 v3749 
                                                                                                                                                                                                let _v3746 = v3750 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v3751 : string = "Ok($0)"
                                                                                                                                                                                                let v3752 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3741 v3751 
                                                                                                                                                                                                let _v3746 = v3752 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v3753 : Result<std_path_PathBuf, std_io_Error> = v3741 |> Ok
                                                                                                                                                                                                let _v3746 = v3753 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v3754 : Result<std_path_PathBuf, std_io_Error> = v3741 |> Ok
                                                                                                                                                                                                let _v3746 = v3754 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v3755 : Result<std_path_PathBuf, std_io_Error> = v3741 |> Ok
                                                                                                                                                                                                let _v3746 = v3755 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v3756 : Result<std_path_PathBuf, std_io_Error> = _v3746 
                                                                                                                                                                                                v3756
                                                                                                                                                                                        else
                                                                                                                                                                                            let v3789 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3538} / path': {v3503} / name: {v3539}"
                                                                                                                                                                                            let v3790 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v3791 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v3792 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3789 v3791 
                                                                                                                                                                                            let _v3790 = v3792 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v3793 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v3794 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3789 v3793 
                                                                                                                                                                                            let _v3790 = v3794 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v3795 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v3796 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3789 v3795 
                                                                                                                                                                                            let _v3790 = v3796 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v3797 : std_io_Error = v3789 
                                                                                                                                                                                            let _v3790 = v3797 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v3798 : std_io_Error = v3789 
                                                                                                                                                                                            let _v3790 = v3798 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v3799 : std_io_Error = v3789 
                                                                                                                                                                                            let _v3790 = v3799 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v3800 : std_io_Error = _v3790 
                                                                                                                                                                                            let v3803 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v3804 : string = "Err($0)"
                                                                                                                                                                                            let v3805 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3800 v3804 
                                                                                                                                                                                            let _v3803 = v3805 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v3806 : string = "Err($0)"
                                                                                                                                                                                            let v3807 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3800 v3806 
                                                                                                                                                                                            let _v3803 = v3807 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v3808 : string = "Err($0)"
                                                                                                                                                                                            let v3809 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3800 v3808 
                                                                                                                                                                                            let _v3803 = v3809 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v3810 : Result<std_path_PathBuf, std_io_Error> = v3800 |> Error
                                                                                                                                                                                            let _v3803 = v3810 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v3811 : Result<std_path_PathBuf, std_io_Error> = v3800 |> Error
                                                                                                                                                                                            let _v3803 = v3811 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v3812 : Result<std_path_PathBuf, std_io_Error> = v3800 |> Error
                                                                                                                                                                                            let _v3803 = v3812 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v3813 : Result<std_path_PathBuf, std_io_Error> = _v3803 
                                                                                                                                                                                            v3813
                                                                                                                                                                                    | _ ->
                                                                                                                                                                                        let v3817 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3538} / path': {v3503} / name: {v3539}"
                                                                                                                                                                                        let v3818 : unit = ()
                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                        let v3819 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                        let v3820 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3817 v3819 
                                                                                                                                                                                        let _v3818 = v3820 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                        let v3821 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                        let v3822 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3817 v3821 
                                                                                                                                                                                        let _v3818 = v3822 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                        let v3823 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                        let v3824 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3817 v3823 
                                                                                                                                                                                        let _v3818 = v3824 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                        let v3825 : std_io_Error = v3817 
                                                                                                                                                                                        let _v3818 = v3825 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                        let v3826 : std_io_Error = v3817 
                                                                                                                                                                                        let _v3818 = v3826 
                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                        let v3827 : std_io_Error = v3817 
                                                                                                                                                                                        let _v3818 = v3827 
                                                                                                                                                                                        #endif
                                                                                                                                                                                        let v3828 : std_io_Error = _v3818 
                                                                                                                                                                                        let v3831 : unit = ()
                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                        let v3832 : string = "Err($0)"
                                                                                                                                                                                        let v3833 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3828 v3832 
                                                                                                                                                                                        let _v3831 = v3833 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                        let v3834 : string = "Err($0)"
                                                                                                                                                                                        let v3835 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3828 v3834 
                                                                                                                                                                                        let _v3831 = v3835 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                        let v3836 : string = "Err($0)"
                                                                                                                                                                                        let v3837 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3828 v3836 
                                                                                                                                                                                        let _v3831 = v3837 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                        let v3838 : Result<std_path_PathBuf, std_io_Error> = v3828 |> Error
                                                                                                                                                                                        let _v3831 = v3838 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                        let v3839 : Result<std_path_PathBuf, std_io_Error> = v3828 |> Error
                                                                                                                                                                                        let _v3831 = v3839 
                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                        let v3840 : Result<std_path_PathBuf, std_io_Error> = v3828 |> Error
                                                                                                                                                                                        let _v3831 = v3840 
                                                                                                                                                                                        #endif
                                                                                                                                                                                        let v3841 : Result<std_path_PathBuf, std_io_Error> = _v3831 
                                                                                                                                                                                        v3841
                                                                                                                                                                                | US8_0(v3524) -> (* Ok *)
                                                                                                                                                                                    let v3525 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v3526 : string = "Ok($0)"
                                                                                                                                                                                    let v3527 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3524 v3526 
                                                                                                                                                                                    let _v3525 = v3527 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v3528 : string = "Ok($0)"
                                                                                                                                                                                    let v3529 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3524 v3528 
                                                                                                                                                                                    let _v3525 = v3529 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v3530 : string = "Ok($0)"
                                                                                                                                                                                    let v3531 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3524 v3530 
                                                                                                                                                                                    let _v3525 = v3531 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v3532 : Result<std_path_PathBuf, std_io_Error> = v3524 |> Ok
                                                                                                                                                                                    let _v3525 = v3532 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v3533 : Result<std_path_PathBuf, std_io_Error> = v3524 |> Ok
                                                                                                                                                                                    let _v3525 = v3533 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v3534 : Result<std_path_PathBuf, std_io_Error> = v3524 |> Ok
                                                                                                                                                                                    let _v3525 = v3534 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v3535 : Result<std_path_PathBuf, std_io_Error> = _v3525 
                                                                                                                                                                                    v3535
                                                                                                                                                                            let v3847 : (std_io_Error -> string) = method41()
                                                                                                                                                                            let v3848 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v3849 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v3850 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3846, v3847) v3849 
                                                                                                                                                                            let _v3848 = v3850 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v3851 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v3852 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3846, v3847) v3851 
                                                                                                                                                                            let _v3848 = v3852 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v3853 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v3854 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3846, v3847) v3853 
                                                                                                                                                                            let _v3848 = v3854 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v3855 : Result<std_path_PathBuf, string> = match v3846 with Ok x -> Ok x | Error x -> Error (v3847 x)
                                                                                                                                                                            let _v3848 = v3855 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v3856 : Result<std_path_PathBuf, string> = match v3846 with Ok x -> Ok x | Error x -> Error (v3847 x)
                                                                                                                                                                            let _v3848 = v3856 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v3857 : Result<std_path_PathBuf, string> = match v3846 with Ok x -> Ok x | Error x -> Error (v3847 x)
                                                                                                                                                                            let _v3848 = v3857 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v3858 : Result<std_path_PathBuf, string> = _v3848 
                                                                                                                                                                            let v3861 : US8 = match v3858 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                                                                            match v3861 with
                                                                                                                                                                            | US8_1(v3964) -> (* Error *)
                                                                                                                                                                                let v3965 : string = $"file_system.read_link / error': {v3964} / error: {v3483} / name: {v3484}"
                                                                                                                                                                                let v3966 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v3967 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v3968 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3965 v3967 
                                                                                                                                                                                let _v3966 = v3968 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v3969 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v3970 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3965 v3969 
                                                                                                                                                                                let _v3966 = v3970 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v3971 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v3972 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3965 v3971 
                                                                                                                                                                                let _v3966 = v3972 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v3973 : std_io_Error = v3965 
                                                                                                                                                                                let _v3966 = v3973 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v3974 : std_io_Error = v3965 
                                                                                                                                                                                let _v3966 = v3974 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v3975 : std_io_Error = v3965 
                                                                                                                                                                                let _v3966 = v3975 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v3976 : std_io_Error = _v3966 
                                                                                                                                                                                let v3979 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v3980 : string = "Err($0)"
                                                                                                                                                                                let v3981 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3976 v3980 
                                                                                                                                                                                let _v3979 = v3981 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v3982 : string = "Err($0)"
                                                                                                                                                                                let v3983 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3976 v3982 
                                                                                                                                                                                let _v3979 = v3983 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v3984 : string = "Err($0)"
                                                                                                                                                                                let v3985 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3976 v3984 
                                                                                                                                                                                let _v3979 = v3985 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v3986 : Result<std_path_PathBuf, std_io_Error> = v3976 |> Error
                                                                                                                                                                                let _v3979 = v3986 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v3987 : Result<std_path_PathBuf, std_io_Error> = v3976 |> Error
                                                                                                                                                                                let _v3979 = v3987 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v3988 : Result<std_path_PathBuf, std_io_Error> = v3976 |> Error
                                                                                                                                                                                let _v3979 = v3988 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v3989 : Result<std_path_PathBuf, std_io_Error> = _v3979 
                                                                                                                                                                                v3989
                                                                                                                                                                            | US8_0(v3862) -> (* Ok *)
                                                                                                                                                                                let v3863 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v3864 : string = "$0.display()"
                                                                                                                                                                                let v3865 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v3862 v3864 
                                                                                                                                                                                let _v3863 = v3865 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v3866 : string = "$0.display()"
                                                                                                                                                                                let v3867 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v3862 v3866 
                                                                                                                                                                                let _v3863 = v3867 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v3868 : string = "$0.display()"
                                                                                                                                                                                let v3869 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v3862 v3868 
                                                                                                                                                                                let _v3863 = v3869 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v3870 : std_path_Display = v3862 |> unbox<std_path_Display>
                                                                                                                                                                                let _v3863 = v3870 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v3873 : std_path_Display = v3862 |> unbox<std_path_Display>
                                                                                                                                                                                let _v3863 = v3873 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v3876 : std_path_Display = v3862 |> unbox<std_path_Display>
                                                                                                                                                                                let _v3863 = v3876 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v3879 : std_path_Display = _v3863 
                                                                                                                                                                                let v3884 : string = v3879 |> string 
                                                                                                                                                                                let v3887 : string = method26(v3884, v3484)
                                                                                                                                                                                let v3888 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v3889 : string = "&*$0"
                                                                                                                                                                                let v3890 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v3887 v3889 
                                                                                                                                                                                let _v3888 = v3890 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v3891 : string = "&*$0"
                                                                                                                                                                                let v3892 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v3887 v3891 
                                                                                                                                                                                let _v3888 = v3892 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v3893 : string = "&*$0"
                                                                                                                                                                                let v3894 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v3887 v3893 
                                                                                                                                                                                let _v3888 = v3894 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v3895 : Ref<Str> = v3887 |> unbox<Ref<Str>>
                                                                                                                                                                                let _v3888 = v3895 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v3898 : Ref<Str> = v3887 |> unbox<Ref<Str>>
                                                                                                                                                                                let _v3888 = v3898 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v3901 : Ref<Str> = v3887 |> unbox<Ref<Str>>
                                                                                                                                                                                let _v3888 = v3901 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v3904 : Ref<Str> = _v3888 
                                                                                                                                                                                let v3909 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v3910 : string = "String::from($0)"
                                                                                                                                                                                let v3911 : std_string_String = Fable.Core.RustInterop.emitRustExpr v3904 v3910 
                                                                                                                                                                                let _v3909 = v3911 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v3912 : string = "String::from($0)"
                                                                                                                                                                                let v3913 : std_string_String = Fable.Core.RustInterop.emitRustExpr v3904 v3912 
                                                                                                                                                                                let _v3909 = v3913 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v3914 : string = "String::from($0)"
                                                                                                                                                                                let v3915 : std_string_String = Fable.Core.RustInterop.emitRustExpr v3904 v3914 
                                                                                                                                                                                let _v3909 = v3915 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v3916 : std_string_String = v3904 |> unbox<std_string_String>
                                                                                                                                                                                let _v3909 = v3916 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v3919 : std_string_String = v3904 |> unbox<std_string_String>
                                                                                                                                                                                let _v3909 = v3919 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v3922 : std_string_String = v3904 |> unbox<std_string_String>
                                                                                                                                                                                let _v3909 = v3922 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v3925 : std_string_String = _v3909 
                                                                                                                                                                                let v3930 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v3931 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                let v3932 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v3925 v3931 
                                                                                                                                                                                let _v3930 = v3932 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v3933 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                let v3934 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v3925 v3933 
                                                                                                                                                                                let _v3930 = v3934 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v3935 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                let v3936 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v3925 v3935 
                                                                                                                                                                                let _v3930 = v3936 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v3937 : std_path_PathBuf = v3925 |> std_path_PathBuf 
                                                                                                                                                                                let _v3930 = v3937 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v3940 : std_path_PathBuf = v3925 |> std_path_PathBuf 
                                                                                                                                                                                let _v3930 = v3940 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v3943 : std_path_PathBuf = v3925 |> std_path_PathBuf 
                                                                                                                                                                                let _v3930 = v3943 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v3946 : std_path_PathBuf = _v3930 
                                                                                                                                                                                let v3951 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v3952 : string = "Ok($0)"
                                                                                                                                                                                let v3953 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3946 v3952 
                                                                                                                                                                                let _v3951 = v3953 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v3954 : string = "Ok($0)"
                                                                                                                                                                                let v3955 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3946 v3954 
                                                                                                                                                                                let _v3951 = v3955 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v3956 : string = "Ok($0)"
                                                                                                                                                                                let v3957 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3946 v3956 
                                                                                                                                                                                let _v3951 = v3957 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v3958 : Result<std_path_PathBuf, std_io_Error> = v3946 |> Ok
                                                                                                                                                                                let _v3951 = v3958 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v3959 : Result<std_path_PathBuf, std_io_Error> = v3946 |> Ok
                                                                                                                                                                                let _v3951 = v3959 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v3960 : Result<std_path_PathBuf, std_io_Error> = v3946 |> Ok
                                                                                                                                                                                let _v3951 = v3960 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v3961 : Result<std_path_PathBuf, std_io_Error> = _v3951 
                                                                                                                                                                                v3961
                                                                                                                                                                        else
                                                                                                                                                                            let v3994 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3483} / path': {v3448} / name: {v3484}"
                                                                                                                                                                            let v3995 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v3996 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v3997 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3994 v3996 
                                                                                                                                                                            let _v3995 = v3997 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v3998 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v3999 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3994 v3998 
                                                                                                                                                                            let _v3995 = v3999 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v4000 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v4001 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3994 v4000 
                                                                                                                                                                            let _v3995 = v4001 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v4002 : std_io_Error = v3994 
                                                                                                                                                                            let _v3995 = v4002 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v4003 : std_io_Error = v3994 
                                                                                                                                                                            let _v3995 = v4003 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v4004 : std_io_Error = v3994 
                                                                                                                                                                            let _v3995 = v4004 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v4005 : std_io_Error = _v3995 
                                                                                                                                                                            let v4008 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v4009 : string = "Err($0)"
                                                                                                                                                                            let v4010 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4005 v4009 
                                                                                                                                                                            let _v4008 = v4010 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v4011 : string = "Err($0)"
                                                                                                                                                                            let v4012 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4005 v4011 
                                                                                                                                                                            let _v4008 = v4012 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v4013 : string = "Err($0)"
                                                                                                                                                                            let v4014 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4005 v4013 
                                                                                                                                                                            let _v4008 = v4014 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v4015 : Result<std_path_PathBuf, std_io_Error> = v4005 |> Error
                                                                                                                                                                            let _v4008 = v4015 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v4016 : Result<std_path_PathBuf, std_io_Error> = v4005 |> Error
                                                                                                                                                                            let _v4008 = v4016 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v4017 : Result<std_path_PathBuf, std_io_Error> = v4005 |> Error
                                                                                                                                                                            let _v4008 = v4017 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v4018 : Result<std_path_PathBuf, std_io_Error> = _v4008 
                                                                                                                                                                            v4018
                                                                                                                                                                    | _ ->
                                                                                                                                                                        let v4022 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3483} / path': {v3448} / name: {v3484}"
                                                                                                                                                                        let v4023 : unit = ()
                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                        let v4024 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                        let v4025 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4022 v4024 
                                                                                                                                                                        let _v4023 = v4025 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                        let v4026 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                        let v4027 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4022 v4026 
                                                                                                                                                                        let _v4023 = v4027 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                        let v4028 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                        let v4029 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4022 v4028 
                                                                                                                                                                        let _v4023 = v4029 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                        let v4030 : std_io_Error = v4022 
                                                                                                                                                                        let _v4023 = v4030 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                        let v4031 : std_io_Error = v4022 
                                                                                                                                                                        let _v4023 = v4031 
                                                                                                                                                                        #endif
#else
                                                                                                                                                                        let v4032 : std_io_Error = v4022 
                                                                                                                                                                        let _v4023 = v4032 
                                                                                                                                                                        #endif
                                                                                                                                                                        let v4033 : std_io_Error = _v4023 
                                                                                                                                                                        let v4036 : unit = ()
                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                        let v4037 : string = "Err($0)"
                                                                                                                                                                        let v4038 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4033 v4037 
                                                                                                                                                                        let _v4036 = v4038 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                        let v4039 : string = "Err($0)"
                                                                                                                                                                        let v4040 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4033 v4039 
                                                                                                                                                                        let _v4036 = v4040 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                        let v4041 : string = "Err($0)"
                                                                                                                                                                        let v4042 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4033 v4041 
                                                                                                                                                                        let _v4036 = v4042 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                        let v4043 : Result<std_path_PathBuf, std_io_Error> = v4033 |> Error
                                                                                                                                                                        let _v4036 = v4043 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                        let v4044 : Result<std_path_PathBuf, std_io_Error> = v4033 |> Error
                                                                                                                                                                        let _v4036 = v4044 
                                                                                                                                                                        #endif
#else
                                                                                                                                                                        let v4045 : Result<std_path_PathBuf, std_io_Error> = v4033 |> Error
                                                                                                                                                                        let _v4036 = v4045 
                                                                                                                                                                        #endif
                                                                                                                                                                        let v4046 : Result<std_path_PathBuf, std_io_Error> = _v4036 
                                                                                                                                                                        v4046
                                                                                                                                                                | US8_0(v3469) -> (* Ok *)
                                                                                                                                                                    let v3470 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v3471 : string = "Ok($0)"
                                                                                                                                                                    let v3472 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3469 v3471 
                                                                                                                                                                    let _v3470 = v3472 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v3473 : string = "Ok($0)"
                                                                                                                                                                    let v3474 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3469 v3473 
                                                                                                                                                                    let _v3470 = v3474 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v3475 : string = "Ok($0)"
                                                                                                                                                                    let v3476 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3469 v3475 
                                                                                                                                                                    let _v3470 = v3476 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v3477 : Result<std_path_PathBuf, std_io_Error> = v3469 |> Ok
                                                                                                                                                                    let _v3470 = v3477 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v3478 : Result<std_path_PathBuf, std_io_Error> = v3469 |> Ok
                                                                                                                                                                    let _v3470 = v3478 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v3479 : Result<std_path_PathBuf, std_io_Error> = v3469 |> Ok
                                                                                                                                                                    let _v3470 = v3479 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v3480 : Result<std_path_PathBuf, std_io_Error> = _v3470 
                                                                                                                                                                    v3480
                                                                                                                                                            let v4052 : (std_io_Error -> string) = method41()
                                                                                                                                                            let v4053 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v4054 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v4055 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4051, v4052) v4054 
                                                                                                                                                            let _v4053 = v4055 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v4056 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v4057 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4051, v4052) v4056 
                                                                                                                                                            let _v4053 = v4057 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v4058 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v4059 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4051, v4052) v4058 
                                                                                                                                                            let _v4053 = v4059 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v4060 : Result<std_path_PathBuf, string> = match v4051 with Ok x -> Ok x | Error x -> Error (v4052 x)
                                                                                                                                                            let _v4053 = v4060 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v4061 : Result<std_path_PathBuf, string> = match v4051 with Ok x -> Ok x | Error x -> Error (v4052 x)
                                                                                                                                                            let _v4053 = v4061 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v4062 : Result<std_path_PathBuf, string> = match v4051 with Ok x -> Ok x | Error x -> Error (v4052 x)
                                                                                                                                                            let _v4053 = v4062 
                                                                                                                                                            #endif
                                                                                                                                                            let v4063 : Result<std_path_PathBuf, string> = _v4053 
                                                                                                                                                            let v4066 : US8 = match v4063 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                                                            match v4066 with
                                                                                                                                                            | US8_1(v4169) -> (* Error *)
                                                                                                                                                                let v4170 : string = $"file_system.read_link / error': {v4169} / error: {v3428} / name: {v3429}"
                                                                                                                                                                let v4171 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v4172 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v4173 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4170 v4172 
                                                                                                                                                                let _v4171 = v4173 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v4174 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v4175 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4170 v4174 
                                                                                                                                                                let _v4171 = v4175 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v4176 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v4177 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4170 v4176 
                                                                                                                                                                let _v4171 = v4177 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v4178 : std_io_Error = v4170 
                                                                                                                                                                let _v4171 = v4178 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v4179 : std_io_Error = v4170 
                                                                                                                                                                let _v4171 = v4179 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v4180 : std_io_Error = v4170 
                                                                                                                                                                let _v4171 = v4180 
                                                                                                                                                                #endif
                                                                                                                                                                let v4181 : std_io_Error = _v4171 
                                                                                                                                                                let v4184 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v4185 : string = "Err($0)"
                                                                                                                                                                let v4186 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4181 v4185 
                                                                                                                                                                let _v4184 = v4186 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v4187 : string = "Err($0)"
                                                                                                                                                                let v4188 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4181 v4187 
                                                                                                                                                                let _v4184 = v4188 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v4189 : string = "Err($0)"
                                                                                                                                                                let v4190 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4181 v4189 
                                                                                                                                                                let _v4184 = v4190 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v4191 : Result<std_path_PathBuf, std_io_Error> = v4181 |> Error
                                                                                                                                                                let _v4184 = v4191 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v4192 : Result<std_path_PathBuf, std_io_Error> = v4181 |> Error
                                                                                                                                                                let _v4184 = v4192 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v4193 : Result<std_path_PathBuf, std_io_Error> = v4181 |> Error
                                                                                                                                                                let _v4184 = v4193 
                                                                                                                                                                #endif
                                                                                                                                                                let v4194 : Result<std_path_PathBuf, std_io_Error> = _v4184 
                                                                                                                                                                v4194
                                                                                                                                                            | US8_0(v4067) -> (* Ok *)
                                                                                                                                                                let v4068 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v4069 : string = "$0.display()"
                                                                                                                                                                let v4070 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4067 v4069 
                                                                                                                                                                let _v4068 = v4070 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v4071 : string = "$0.display()"
                                                                                                                                                                let v4072 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4067 v4071 
                                                                                                                                                                let _v4068 = v4072 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v4073 : string = "$0.display()"
                                                                                                                                                                let v4074 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4067 v4073 
                                                                                                                                                                let _v4068 = v4074 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v4075 : std_path_Display = v4067 |> unbox<std_path_Display>
                                                                                                                                                                let _v4068 = v4075 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v4078 : std_path_Display = v4067 |> unbox<std_path_Display>
                                                                                                                                                                let _v4068 = v4078 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v4081 : std_path_Display = v4067 |> unbox<std_path_Display>
                                                                                                                                                                let _v4068 = v4081 
                                                                                                                                                                #endif
                                                                                                                                                                let v4084 : std_path_Display = _v4068 
                                                                                                                                                                let v4089 : string = v4084 |> string 
                                                                                                                                                                let v4092 : string = method26(v4089, v3429)
                                                                                                                                                                let v4093 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v4094 : string = "&*$0"
                                                                                                                                                                let v4095 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4092 v4094 
                                                                                                                                                                let _v4093 = v4095 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v4096 : string = "&*$0"
                                                                                                                                                                let v4097 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4092 v4096 
                                                                                                                                                                let _v4093 = v4097 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v4098 : string = "&*$0"
                                                                                                                                                                let v4099 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4092 v4098 
                                                                                                                                                                let _v4093 = v4099 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v4100 : Ref<Str> = v4092 |> unbox<Ref<Str>>
                                                                                                                                                                let _v4093 = v4100 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v4103 : Ref<Str> = v4092 |> unbox<Ref<Str>>
                                                                                                                                                                let _v4093 = v4103 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v4106 : Ref<Str> = v4092 |> unbox<Ref<Str>>
                                                                                                                                                                let _v4093 = v4106 
                                                                                                                                                                #endif
                                                                                                                                                                let v4109 : Ref<Str> = _v4093 
                                                                                                                                                                let v4114 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v4115 : string = "String::from($0)"
                                                                                                                                                                let v4116 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4109 v4115 
                                                                                                                                                                let _v4114 = v4116 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v4117 : string = "String::from($0)"
                                                                                                                                                                let v4118 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4109 v4117 
                                                                                                                                                                let _v4114 = v4118 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v4119 : string = "String::from($0)"
                                                                                                                                                                let v4120 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4109 v4119 
                                                                                                                                                                let _v4114 = v4120 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v4121 : std_string_String = v4109 |> unbox<std_string_String>
                                                                                                                                                                let _v4114 = v4121 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v4124 : std_string_String = v4109 |> unbox<std_string_String>
                                                                                                                                                                let _v4114 = v4124 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v4127 : std_string_String = v4109 |> unbox<std_string_String>
                                                                                                                                                                let _v4114 = v4127 
                                                                                                                                                                #endif
                                                                                                                                                                let v4130 : std_string_String = _v4114 
                                                                                                                                                                let v4135 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v4136 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                let v4137 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4130 v4136 
                                                                                                                                                                let _v4135 = v4137 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v4138 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                let v4139 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4130 v4138 
                                                                                                                                                                let _v4135 = v4139 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v4140 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                let v4141 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4130 v4140 
                                                                                                                                                                let _v4135 = v4141 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v4142 : std_path_PathBuf = v4130 |> std_path_PathBuf 
                                                                                                                                                                let _v4135 = v4142 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v4145 : std_path_PathBuf = v4130 |> std_path_PathBuf 
                                                                                                                                                                let _v4135 = v4145 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v4148 : std_path_PathBuf = v4130 |> std_path_PathBuf 
                                                                                                                                                                let _v4135 = v4148 
                                                                                                                                                                #endif
                                                                                                                                                                let v4151 : std_path_PathBuf = _v4135 
                                                                                                                                                                let v4156 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v4157 : string = "Ok($0)"
                                                                                                                                                                let v4158 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4151 v4157 
                                                                                                                                                                let _v4156 = v4158 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v4159 : string = "Ok($0)"
                                                                                                                                                                let v4160 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4151 v4159 
                                                                                                                                                                let _v4156 = v4160 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v4161 : string = "Ok($0)"
                                                                                                                                                                let v4162 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4151 v4161 
                                                                                                                                                                let _v4156 = v4162 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v4163 : Result<std_path_PathBuf, std_io_Error> = v4151 |> Ok
                                                                                                                                                                let _v4156 = v4163 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v4164 : Result<std_path_PathBuf, std_io_Error> = v4151 |> Ok
                                                                                                                                                                let _v4156 = v4164 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v4165 : Result<std_path_PathBuf, std_io_Error> = v4151 |> Ok
                                                                                                                                                                let _v4156 = v4165 
                                                                                                                                                                #endif
                                                                                                                                                                let v4166 : Result<std_path_PathBuf, std_io_Error> = _v4156 
                                                                                                                                                                v4166
                                                                                                                                                        else
                                                                                                                                                            let v4199 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3428} / path': {v3393} / name: {v3429}"
                                                                                                                                                            let v4200 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v4201 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v4202 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4199 v4201 
                                                                                                                                                            let _v4200 = v4202 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v4203 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v4204 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4199 v4203 
                                                                                                                                                            let _v4200 = v4204 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v4205 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v4206 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4199 v4205 
                                                                                                                                                            let _v4200 = v4206 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v4207 : std_io_Error = v4199 
                                                                                                                                                            let _v4200 = v4207 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v4208 : std_io_Error = v4199 
                                                                                                                                                            let _v4200 = v4208 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v4209 : std_io_Error = v4199 
                                                                                                                                                            let _v4200 = v4209 
                                                                                                                                                            #endif
                                                                                                                                                            let v4210 : std_io_Error = _v4200 
                                                                                                                                                            let v4213 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v4214 : string = "Err($0)"
                                                                                                                                                            let v4215 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4210 v4214 
                                                                                                                                                            let _v4213 = v4215 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v4216 : string = "Err($0)"
                                                                                                                                                            let v4217 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4210 v4216 
                                                                                                                                                            let _v4213 = v4217 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v4218 : string = "Err($0)"
                                                                                                                                                            let v4219 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4210 v4218 
                                                                                                                                                            let _v4213 = v4219 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v4220 : Result<std_path_PathBuf, std_io_Error> = v4210 |> Error
                                                                                                                                                            let _v4213 = v4220 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v4221 : Result<std_path_PathBuf, std_io_Error> = v4210 |> Error
                                                                                                                                                            let _v4213 = v4221 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v4222 : Result<std_path_PathBuf, std_io_Error> = v4210 |> Error
                                                                                                                                                            let _v4213 = v4222 
                                                                                                                                                            #endif
                                                                                                                                                            let v4223 : Result<std_path_PathBuf, std_io_Error> = _v4213 
                                                                                                                                                            v4223
                                                                                                                                                    | _ ->
                                                                                                                                                        let v4227 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3428} / path': {v3393} / name: {v3429}"
                                                                                                                                                        let v4228 : unit = ()
                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                        let v4229 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                        let v4230 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4227 v4229 
                                                                                                                                                        let _v4228 = v4230 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                        let v4231 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                        let v4232 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4227 v4231 
                                                                                                                                                        let _v4228 = v4232 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                        let v4233 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                        let v4234 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4227 v4233 
                                                                                                                                                        let _v4228 = v4234 
                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                        let v4235 : std_io_Error = v4227 
                                                                                                                                                        let _v4228 = v4235 
                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                        let v4236 : std_io_Error = v4227 
                                                                                                                                                        let _v4228 = v4236 
                                                                                                                                                        #endif
#else
                                                                                                                                                        let v4237 : std_io_Error = v4227 
                                                                                                                                                        let _v4228 = v4237 
                                                                                                                                                        #endif
                                                                                                                                                        let v4238 : std_io_Error = _v4228 
                                                                                                                                                        let v4241 : unit = ()
                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                        let v4242 : string = "Err($0)"
                                                                                                                                                        let v4243 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4238 v4242 
                                                                                                                                                        let _v4241 = v4243 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                        let v4244 : string = "Err($0)"
                                                                                                                                                        let v4245 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4238 v4244 
                                                                                                                                                        let _v4241 = v4245 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                        let v4246 : string = "Err($0)"
                                                                                                                                                        let v4247 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4238 v4246 
                                                                                                                                                        let _v4241 = v4247 
                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                        let v4248 : Result<std_path_PathBuf, std_io_Error> = v4238 |> Error
                                                                                                                                                        let _v4241 = v4248 
                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                        let v4249 : Result<std_path_PathBuf, std_io_Error> = v4238 |> Error
                                                                                                                                                        let _v4241 = v4249 
                                                                                                                                                        #endif
#else
                                                                                                                                                        let v4250 : Result<std_path_PathBuf, std_io_Error> = v4238 |> Error
                                                                                                                                                        let _v4241 = v4250 
                                                                                                                                                        #endif
                                                                                                                                                        let v4251 : Result<std_path_PathBuf, std_io_Error> = _v4241 
                                                                                                                                                        v4251
                                                                                                                                                | US8_0(v3414) -> (* Ok *)
                                                                                                                                                    let v3415 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v3416 : string = "Ok($0)"
                                                                                                                                                    let v3417 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3414 v3416 
                                                                                                                                                    let _v3415 = v3417 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v3418 : string = "Ok($0)"
                                                                                                                                                    let v3419 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3414 v3418 
                                                                                                                                                    let _v3415 = v3419 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v3420 : string = "Ok($0)"
                                                                                                                                                    let v3421 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3414 v3420 
                                                                                                                                                    let _v3415 = v3421 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v3422 : Result<std_path_PathBuf, std_io_Error> = v3414 |> Ok
                                                                                                                                                    let _v3415 = v3422 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v3423 : Result<std_path_PathBuf, std_io_Error> = v3414 |> Ok
                                                                                                                                                    let _v3415 = v3423 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v3424 : Result<std_path_PathBuf, std_io_Error> = v3414 |> Ok
                                                                                                                                                    let _v3415 = v3424 
                                                                                                                                                    #endif
                                                                                                                                                    let v3425 : Result<std_path_PathBuf, std_io_Error> = _v3415 
                                                                                                                                                    v3425
                                                                                                                                            let v4257 : (std_io_Error -> string) = method41()
                                                                                                                                            let v4258 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v4259 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v4260 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4256, v4257) v4259 
                                                                                                                                            let _v4258 = v4260 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v4261 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v4262 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4256, v4257) v4261 
                                                                                                                                            let _v4258 = v4262 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v4263 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v4264 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4256, v4257) v4263 
                                                                                                                                            let _v4258 = v4264 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v4265 : Result<std_path_PathBuf, string> = match v4256 with Ok x -> Ok x | Error x -> Error (v4257 x)
                                                                                                                                            let _v4258 = v4265 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v4266 : Result<std_path_PathBuf, string> = match v4256 with Ok x -> Ok x | Error x -> Error (v4257 x)
                                                                                                                                            let _v4258 = v4266 
                                                                                                                                            #endif
#else
                                                                                                                                            let v4267 : Result<std_path_PathBuf, string> = match v4256 with Ok x -> Ok x | Error x -> Error (v4257 x)
                                                                                                                                            let _v4258 = v4267 
                                                                                                                                            #endif
                                                                                                                                            let v4268 : Result<std_path_PathBuf, string> = _v4258 
                                                                                                                                            let v4271 : US8 = match v4268 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                                            match v4271 with
                                                                                                                                            | US8_1(v4374) -> (* Error *)
                                                                                                                                                let v4375 : string = $"file_system.read_link / error': {v4374} / error: {v3373} / name: {v3374}"
                                                                                                                                                let v4376 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v4377 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v4378 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4375 v4377 
                                                                                                                                                let _v4376 = v4378 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v4379 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v4380 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4375 v4379 
                                                                                                                                                let _v4376 = v4380 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v4381 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v4382 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4375 v4381 
                                                                                                                                                let _v4376 = v4382 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v4383 : std_io_Error = v4375 
                                                                                                                                                let _v4376 = v4383 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v4384 : std_io_Error = v4375 
                                                                                                                                                let _v4376 = v4384 
                                                                                                                                                #endif
#else
                                                                                                                                                let v4385 : std_io_Error = v4375 
                                                                                                                                                let _v4376 = v4385 
                                                                                                                                                #endif
                                                                                                                                                let v4386 : std_io_Error = _v4376 
                                                                                                                                                let v4389 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v4390 : string = "Err($0)"
                                                                                                                                                let v4391 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4386 v4390 
                                                                                                                                                let _v4389 = v4391 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v4392 : string = "Err($0)"
                                                                                                                                                let v4393 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4386 v4392 
                                                                                                                                                let _v4389 = v4393 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v4394 : string = "Err($0)"
                                                                                                                                                let v4395 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4386 v4394 
                                                                                                                                                let _v4389 = v4395 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v4396 : Result<std_path_PathBuf, std_io_Error> = v4386 |> Error
                                                                                                                                                let _v4389 = v4396 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v4397 : Result<std_path_PathBuf, std_io_Error> = v4386 |> Error
                                                                                                                                                let _v4389 = v4397 
                                                                                                                                                #endif
#else
                                                                                                                                                let v4398 : Result<std_path_PathBuf, std_io_Error> = v4386 |> Error
                                                                                                                                                let _v4389 = v4398 
                                                                                                                                                #endif
                                                                                                                                                let v4399 : Result<std_path_PathBuf, std_io_Error> = _v4389 
                                                                                                                                                v4399
                                                                                                                                            | US8_0(v4272) -> (* Ok *)
                                                                                                                                                let v4273 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v4274 : string = "$0.display()"
                                                                                                                                                let v4275 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4272 v4274 
                                                                                                                                                let _v4273 = v4275 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v4276 : string = "$0.display()"
                                                                                                                                                let v4277 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4272 v4276 
                                                                                                                                                let _v4273 = v4277 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v4278 : string = "$0.display()"
                                                                                                                                                let v4279 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4272 v4278 
                                                                                                                                                let _v4273 = v4279 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v4280 : std_path_Display = v4272 |> unbox<std_path_Display>
                                                                                                                                                let _v4273 = v4280 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v4283 : std_path_Display = v4272 |> unbox<std_path_Display>
                                                                                                                                                let _v4273 = v4283 
                                                                                                                                                #endif
#else
                                                                                                                                                let v4286 : std_path_Display = v4272 |> unbox<std_path_Display>
                                                                                                                                                let _v4273 = v4286 
                                                                                                                                                #endif
                                                                                                                                                let v4289 : std_path_Display = _v4273 
                                                                                                                                                let v4294 : string = v4289 |> string 
                                                                                                                                                let v4297 : string = method26(v4294, v3374)
                                                                                                                                                let v4298 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v4299 : string = "&*$0"
                                                                                                                                                let v4300 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4297 v4299 
                                                                                                                                                let _v4298 = v4300 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v4301 : string = "&*$0"
                                                                                                                                                let v4302 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4297 v4301 
                                                                                                                                                let _v4298 = v4302 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v4303 : string = "&*$0"
                                                                                                                                                let v4304 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4297 v4303 
                                                                                                                                                let _v4298 = v4304 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v4305 : Ref<Str> = v4297 |> unbox<Ref<Str>>
                                                                                                                                                let _v4298 = v4305 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v4308 : Ref<Str> = v4297 |> unbox<Ref<Str>>
                                                                                                                                                let _v4298 = v4308 
                                                                                                                                                #endif
#else
                                                                                                                                                let v4311 : Ref<Str> = v4297 |> unbox<Ref<Str>>
                                                                                                                                                let _v4298 = v4311 
                                                                                                                                                #endif
                                                                                                                                                let v4314 : Ref<Str> = _v4298 
                                                                                                                                                let v4319 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v4320 : string = "String::from($0)"
                                                                                                                                                let v4321 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4314 v4320 
                                                                                                                                                let _v4319 = v4321 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v4322 : string = "String::from($0)"
                                                                                                                                                let v4323 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4314 v4322 
                                                                                                                                                let _v4319 = v4323 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v4324 : string = "String::from($0)"
                                                                                                                                                let v4325 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4314 v4324 
                                                                                                                                                let _v4319 = v4325 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v4326 : std_string_String = v4314 |> unbox<std_string_String>
                                                                                                                                                let _v4319 = v4326 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v4329 : std_string_String = v4314 |> unbox<std_string_String>
                                                                                                                                                let _v4319 = v4329 
                                                                                                                                                #endif
#else
                                                                                                                                                let v4332 : std_string_String = v4314 |> unbox<std_string_String>
                                                                                                                                                let _v4319 = v4332 
                                                                                                                                                #endif
                                                                                                                                                let v4335 : std_string_String = _v4319 
                                                                                                                                                let v4340 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v4341 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                let v4342 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4335 v4341 
                                                                                                                                                let _v4340 = v4342 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v4343 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                let v4344 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4335 v4343 
                                                                                                                                                let _v4340 = v4344 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v4345 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                let v4346 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4335 v4345 
                                                                                                                                                let _v4340 = v4346 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v4347 : std_path_PathBuf = v4335 |> std_path_PathBuf 
                                                                                                                                                let _v4340 = v4347 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v4350 : std_path_PathBuf = v4335 |> std_path_PathBuf 
                                                                                                                                                let _v4340 = v4350 
                                                                                                                                                #endif
#else
                                                                                                                                                let v4353 : std_path_PathBuf = v4335 |> std_path_PathBuf 
                                                                                                                                                let _v4340 = v4353 
                                                                                                                                                #endif
                                                                                                                                                let v4356 : std_path_PathBuf = _v4340 
                                                                                                                                                let v4361 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v4362 : string = "Ok($0)"
                                                                                                                                                let v4363 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4356 v4362 
                                                                                                                                                let _v4361 = v4363 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v4364 : string = "Ok($0)"
                                                                                                                                                let v4365 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4356 v4364 
                                                                                                                                                let _v4361 = v4365 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v4366 : string = "Ok($0)"
                                                                                                                                                let v4367 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4356 v4366 
                                                                                                                                                let _v4361 = v4367 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v4368 : Result<std_path_PathBuf, std_io_Error> = v4356 |> Ok
                                                                                                                                                let _v4361 = v4368 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v4369 : Result<std_path_PathBuf, std_io_Error> = v4356 |> Ok
                                                                                                                                                let _v4361 = v4369 
                                                                                                                                                #endif
#else
                                                                                                                                                let v4370 : Result<std_path_PathBuf, std_io_Error> = v4356 |> Ok
                                                                                                                                                let _v4361 = v4370 
                                                                                                                                                #endif
                                                                                                                                                let v4371 : Result<std_path_PathBuf, std_io_Error> = _v4361 
                                                                                                                                                v4371
                                                                                                                                        else
                                                                                                                                            let v4404 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3373} / path': {v3338} / name: {v3374}"
                                                                                                                                            let v4405 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v4406 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v4407 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4404 v4406 
                                                                                                                                            let _v4405 = v4407 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v4408 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v4409 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4404 v4408 
                                                                                                                                            let _v4405 = v4409 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v4410 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v4411 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4404 v4410 
                                                                                                                                            let _v4405 = v4411 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v4412 : std_io_Error = v4404 
                                                                                                                                            let _v4405 = v4412 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v4413 : std_io_Error = v4404 
                                                                                                                                            let _v4405 = v4413 
                                                                                                                                            #endif
#else
                                                                                                                                            let v4414 : std_io_Error = v4404 
                                                                                                                                            let _v4405 = v4414 
                                                                                                                                            #endif
                                                                                                                                            let v4415 : std_io_Error = _v4405 
                                                                                                                                            let v4418 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v4419 : string = "Err($0)"
                                                                                                                                            let v4420 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4415 v4419 
                                                                                                                                            let _v4418 = v4420 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v4421 : string = "Err($0)"
                                                                                                                                            let v4422 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4415 v4421 
                                                                                                                                            let _v4418 = v4422 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v4423 : string = "Err($0)"
                                                                                                                                            let v4424 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4415 v4423 
                                                                                                                                            let _v4418 = v4424 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v4425 : Result<std_path_PathBuf, std_io_Error> = v4415 |> Error
                                                                                                                                            let _v4418 = v4425 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v4426 : Result<std_path_PathBuf, std_io_Error> = v4415 |> Error
                                                                                                                                            let _v4418 = v4426 
                                                                                                                                            #endif
#else
                                                                                                                                            let v4427 : Result<std_path_PathBuf, std_io_Error> = v4415 |> Error
                                                                                                                                            let _v4418 = v4427 
                                                                                                                                            #endif
                                                                                                                                            let v4428 : Result<std_path_PathBuf, std_io_Error> = _v4418 
                                                                                                                                            v4428
                                                                                                                                    | _ ->
                                                                                                                                        let v4432 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3373} / path': {v3338} / name: {v3374}"
                                                                                                                                        let v4433 : unit = ()
                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                        let v4434 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                        let v4435 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4432 v4434 
                                                                                                                                        let _v4433 = v4435 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                        let v4436 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                        let v4437 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4432 v4436 
                                                                                                                                        let _v4433 = v4437 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                        let v4438 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                        let v4439 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4432 v4438 
                                                                                                                                        let _v4433 = v4439 
                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                        let v4440 : std_io_Error = v4432 
                                                                                                                                        let _v4433 = v4440 
                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                        let v4441 : std_io_Error = v4432 
                                                                                                                                        let _v4433 = v4441 
                                                                                                                                        #endif
#else
                                                                                                                                        let v4442 : std_io_Error = v4432 
                                                                                                                                        let _v4433 = v4442 
                                                                                                                                        #endif
                                                                                                                                        let v4443 : std_io_Error = _v4433 
                                                                                                                                        let v4446 : unit = ()
                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                        let v4447 : string = "Err($0)"
                                                                                                                                        let v4448 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4443 v4447 
                                                                                                                                        let _v4446 = v4448 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                        let v4449 : string = "Err($0)"
                                                                                                                                        let v4450 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4443 v4449 
                                                                                                                                        let _v4446 = v4450 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                        let v4451 : string = "Err($0)"
                                                                                                                                        let v4452 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4443 v4451 
                                                                                                                                        let _v4446 = v4452 
                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                        let v4453 : Result<std_path_PathBuf, std_io_Error> = v4443 |> Error
                                                                                                                                        let _v4446 = v4453 
                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                        let v4454 : Result<std_path_PathBuf, std_io_Error> = v4443 |> Error
                                                                                                                                        let _v4446 = v4454 
                                                                                                                                        #endif
#else
                                                                                                                                        let v4455 : Result<std_path_PathBuf, std_io_Error> = v4443 |> Error
                                                                                                                                        let _v4446 = v4455 
                                                                                                                                        #endif
                                                                                                                                        let v4456 : Result<std_path_PathBuf, std_io_Error> = _v4446 
                                                                                                                                        v4456
                                                                                                                                | US8_0(v3359) -> (* Ok *)
                                                                                                                                    let v3360 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v3361 : string = "Ok($0)"
                                                                                                                                    let v3362 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3359 v3361 
                                                                                                                                    let _v3360 = v3362 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v3363 : string = "Ok($0)"
                                                                                                                                    let v3364 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3359 v3363 
                                                                                                                                    let _v3360 = v3364 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v3365 : string = "Ok($0)"
                                                                                                                                    let v3366 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3359 v3365 
                                                                                                                                    let _v3360 = v3366 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v3367 : Result<std_path_PathBuf, std_io_Error> = v3359 |> Ok
                                                                                                                                    let _v3360 = v3367 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v3368 : Result<std_path_PathBuf, std_io_Error> = v3359 |> Ok
                                                                                                                                    let _v3360 = v3368 
                                                                                                                                    #endif
#else
                                                                                                                                    let v3369 : Result<std_path_PathBuf, std_io_Error> = v3359 |> Ok
                                                                                                                                    let _v3360 = v3369 
                                                                                                                                    #endif
                                                                                                                                    let v3370 : Result<std_path_PathBuf, std_io_Error> = _v3360 
                                                                                                                                    v3370
                                                                                                                            let v4462 : (std_io_Error -> string) = method41()
                                                                                                                            let v4463 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v4464 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v4465 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4461, v4462) v4464 
                                                                                                                            let _v4463 = v4465 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v4466 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v4467 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4461, v4462) v4466 
                                                                                                                            let _v4463 = v4467 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v4468 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v4469 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4461, v4462) v4468 
                                                                                                                            let _v4463 = v4469 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v4470 : Result<std_path_PathBuf, string> = match v4461 with Ok x -> Ok x | Error x -> Error (v4462 x)
                                                                                                                            let _v4463 = v4470 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v4471 : Result<std_path_PathBuf, string> = match v4461 with Ok x -> Ok x | Error x -> Error (v4462 x)
                                                                                                                            let _v4463 = v4471 
                                                                                                                            #endif
#else
                                                                                                                            let v4472 : Result<std_path_PathBuf, string> = match v4461 with Ok x -> Ok x | Error x -> Error (v4462 x)
                                                                                                                            let _v4463 = v4472 
                                                                                                                            #endif
                                                                                                                            let v4473 : Result<std_path_PathBuf, string> = _v4463 
                                                                                                                            let v4476 : US8 = match v4473 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                            match v4476 with
                                                                                                                            | US8_1(v4579) -> (* Error *)
                                                                                                                                let v4580 : string = $"file_system.read_link / error': {v4579} / error: {v3318} / name: {v3319}"
                                                                                                                                let v4581 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v4582 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v4583 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4580 v4582 
                                                                                                                                let _v4581 = v4583 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v4584 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v4585 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4580 v4584 
                                                                                                                                let _v4581 = v4585 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v4586 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v4587 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4580 v4586 
                                                                                                                                let _v4581 = v4587 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v4588 : std_io_Error = v4580 
                                                                                                                                let _v4581 = v4588 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v4589 : std_io_Error = v4580 
                                                                                                                                let _v4581 = v4589 
                                                                                                                                #endif
#else
                                                                                                                                let v4590 : std_io_Error = v4580 
                                                                                                                                let _v4581 = v4590 
                                                                                                                                #endif
                                                                                                                                let v4591 : std_io_Error = _v4581 
                                                                                                                                let v4594 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v4595 : string = "Err($0)"
                                                                                                                                let v4596 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4591 v4595 
                                                                                                                                let _v4594 = v4596 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v4597 : string = "Err($0)"
                                                                                                                                let v4598 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4591 v4597 
                                                                                                                                let _v4594 = v4598 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v4599 : string = "Err($0)"
                                                                                                                                let v4600 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4591 v4599 
                                                                                                                                let _v4594 = v4600 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v4601 : Result<std_path_PathBuf, std_io_Error> = v4591 |> Error
                                                                                                                                let _v4594 = v4601 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v4602 : Result<std_path_PathBuf, std_io_Error> = v4591 |> Error
                                                                                                                                let _v4594 = v4602 
                                                                                                                                #endif
#else
                                                                                                                                let v4603 : Result<std_path_PathBuf, std_io_Error> = v4591 |> Error
                                                                                                                                let _v4594 = v4603 
                                                                                                                                #endif
                                                                                                                                let v4604 : Result<std_path_PathBuf, std_io_Error> = _v4594 
                                                                                                                                v4604
                                                                                                                            | US8_0(v4477) -> (* Ok *)
                                                                                                                                let v4478 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v4479 : string = "$0.display()"
                                                                                                                                let v4480 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4477 v4479 
                                                                                                                                let _v4478 = v4480 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v4481 : string = "$0.display()"
                                                                                                                                let v4482 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4477 v4481 
                                                                                                                                let _v4478 = v4482 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v4483 : string = "$0.display()"
                                                                                                                                let v4484 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4477 v4483 
                                                                                                                                let _v4478 = v4484 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v4485 : std_path_Display = v4477 |> unbox<std_path_Display>
                                                                                                                                let _v4478 = v4485 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v4488 : std_path_Display = v4477 |> unbox<std_path_Display>
                                                                                                                                let _v4478 = v4488 
                                                                                                                                #endif
#else
                                                                                                                                let v4491 : std_path_Display = v4477 |> unbox<std_path_Display>
                                                                                                                                let _v4478 = v4491 
                                                                                                                                #endif
                                                                                                                                let v4494 : std_path_Display = _v4478 
                                                                                                                                let v4499 : string = v4494 |> string 
                                                                                                                                let v4502 : string = method26(v4499, v3319)
                                                                                                                                let v4503 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v4504 : string = "&*$0"
                                                                                                                                let v4505 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4502 v4504 
                                                                                                                                let _v4503 = v4505 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v4506 : string = "&*$0"
                                                                                                                                let v4507 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4502 v4506 
                                                                                                                                let _v4503 = v4507 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v4508 : string = "&*$0"
                                                                                                                                let v4509 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4502 v4508 
                                                                                                                                let _v4503 = v4509 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v4510 : Ref<Str> = v4502 |> unbox<Ref<Str>>
                                                                                                                                let _v4503 = v4510 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v4513 : Ref<Str> = v4502 |> unbox<Ref<Str>>
                                                                                                                                let _v4503 = v4513 
                                                                                                                                #endif
#else
                                                                                                                                let v4516 : Ref<Str> = v4502 |> unbox<Ref<Str>>
                                                                                                                                let _v4503 = v4516 
                                                                                                                                #endif
                                                                                                                                let v4519 : Ref<Str> = _v4503 
                                                                                                                                let v4524 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v4525 : string = "String::from($0)"
                                                                                                                                let v4526 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4519 v4525 
                                                                                                                                let _v4524 = v4526 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v4527 : string = "String::from($0)"
                                                                                                                                let v4528 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4519 v4527 
                                                                                                                                let _v4524 = v4528 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v4529 : string = "String::from($0)"
                                                                                                                                let v4530 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4519 v4529 
                                                                                                                                let _v4524 = v4530 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v4531 : std_string_String = v4519 |> unbox<std_string_String>
                                                                                                                                let _v4524 = v4531 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v4534 : std_string_String = v4519 |> unbox<std_string_String>
                                                                                                                                let _v4524 = v4534 
                                                                                                                                #endif
#else
                                                                                                                                let v4537 : std_string_String = v4519 |> unbox<std_string_String>
                                                                                                                                let _v4524 = v4537 
                                                                                                                                #endif
                                                                                                                                let v4540 : std_string_String = _v4524 
                                                                                                                                let v4545 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v4546 : string = "std::path::PathBuf::from($0)"
                                                                                                                                let v4547 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4540 v4546 
                                                                                                                                let _v4545 = v4547 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v4548 : string = "std::path::PathBuf::from($0)"
                                                                                                                                let v4549 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4540 v4548 
                                                                                                                                let _v4545 = v4549 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v4550 : string = "std::path::PathBuf::from($0)"
                                                                                                                                let v4551 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4540 v4550 
                                                                                                                                let _v4545 = v4551 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v4552 : std_path_PathBuf = v4540 |> std_path_PathBuf 
                                                                                                                                let _v4545 = v4552 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v4555 : std_path_PathBuf = v4540 |> std_path_PathBuf 
                                                                                                                                let _v4545 = v4555 
                                                                                                                                #endif
#else
                                                                                                                                let v4558 : std_path_PathBuf = v4540 |> std_path_PathBuf 
                                                                                                                                let _v4545 = v4558 
                                                                                                                                #endif
                                                                                                                                let v4561 : std_path_PathBuf = _v4545 
                                                                                                                                let v4566 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v4567 : string = "Ok($0)"
                                                                                                                                let v4568 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4561 v4567 
                                                                                                                                let _v4566 = v4568 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v4569 : string = "Ok($0)"
                                                                                                                                let v4570 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4561 v4569 
                                                                                                                                let _v4566 = v4570 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v4571 : string = "Ok($0)"
                                                                                                                                let v4572 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4561 v4571 
                                                                                                                                let _v4566 = v4572 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v4573 : Result<std_path_PathBuf, std_io_Error> = v4561 |> Ok
                                                                                                                                let _v4566 = v4573 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v4574 : Result<std_path_PathBuf, std_io_Error> = v4561 |> Ok
                                                                                                                                let _v4566 = v4574 
                                                                                                                                #endif
#else
                                                                                                                                let v4575 : Result<std_path_PathBuf, std_io_Error> = v4561 |> Ok
                                                                                                                                let _v4566 = v4575 
                                                                                                                                #endif
                                                                                                                                let v4576 : Result<std_path_PathBuf, std_io_Error> = _v4566 
                                                                                                                                v4576
                                                                                                                        else
                                                                                                                            let v4609 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3318} / path': {v3283} / name: {v3319}"
                                                                                                                            let v4610 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v4611 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v4612 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4609 v4611 
                                                                                                                            let _v4610 = v4612 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v4613 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v4614 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4609 v4613 
                                                                                                                            let _v4610 = v4614 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v4615 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v4616 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4609 v4615 
                                                                                                                            let _v4610 = v4616 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v4617 : std_io_Error = v4609 
                                                                                                                            let _v4610 = v4617 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v4618 : std_io_Error = v4609 
                                                                                                                            let _v4610 = v4618 
                                                                                                                            #endif
#else
                                                                                                                            let v4619 : std_io_Error = v4609 
                                                                                                                            let _v4610 = v4619 
                                                                                                                            #endif
                                                                                                                            let v4620 : std_io_Error = _v4610 
                                                                                                                            let v4623 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v4624 : string = "Err($0)"
                                                                                                                            let v4625 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4620 v4624 
                                                                                                                            let _v4623 = v4625 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v4626 : string = "Err($0)"
                                                                                                                            let v4627 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4620 v4626 
                                                                                                                            let _v4623 = v4627 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v4628 : string = "Err($0)"
                                                                                                                            let v4629 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4620 v4628 
                                                                                                                            let _v4623 = v4629 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v4630 : Result<std_path_PathBuf, std_io_Error> = v4620 |> Error
                                                                                                                            let _v4623 = v4630 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v4631 : Result<std_path_PathBuf, std_io_Error> = v4620 |> Error
                                                                                                                            let _v4623 = v4631 
                                                                                                                            #endif
#else
                                                                                                                            let v4632 : Result<std_path_PathBuf, std_io_Error> = v4620 |> Error
                                                                                                                            let _v4623 = v4632 
                                                                                                                            #endif
                                                                                                                            let v4633 : Result<std_path_PathBuf, std_io_Error> = _v4623 
                                                                                                                            v4633
                                                                                                                    | _ ->
                                                                                                                        let v4637 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3318} / path': {v3283} / name: {v3319}"
                                                                                                                        let v4638 : unit = ()
                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                        let v4639 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                        let v4640 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4637 v4639 
                                                                                                                        let _v4638 = v4640 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                        let v4641 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                        let v4642 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4637 v4641 
                                                                                                                        let _v4638 = v4642 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                        let v4643 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                        let v4644 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4637 v4643 
                                                                                                                        let _v4638 = v4644 
                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                        let v4645 : std_io_Error = v4637 
                                                                                                                        let _v4638 = v4645 
                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                        let v4646 : std_io_Error = v4637 
                                                                                                                        let _v4638 = v4646 
                                                                                                                        #endif
#else
                                                                                                                        let v4647 : std_io_Error = v4637 
                                                                                                                        let _v4638 = v4647 
                                                                                                                        #endif
                                                                                                                        let v4648 : std_io_Error = _v4638 
                                                                                                                        let v4651 : unit = ()
                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                        let v4652 : string = "Err($0)"
                                                                                                                        let v4653 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4648 v4652 
                                                                                                                        let _v4651 = v4653 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                        let v4654 : string = "Err($0)"
                                                                                                                        let v4655 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4648 v4654 
                                                                                                                        let _v4651 = v4655 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                        let v4656 : string = "Err($0)"
                                                                                                                        let v4657 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4648 v4656 
                                                                                                                        let _v4651 = v4657 
                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                        let v4658 : Result<std_path_PathBuf, std_io_Error> = v4648 |> Error
                                                                                                                        let _v4651 = v4658 
                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                        let v4659 : Result<std_path_PathBuf, std_io_Error> = v4648 |> Error
                                                                                                                        let _v4651 = v4659 
                                                                                                                        #endif
#else
                                                                                                                        let v4660 : Result<std_path_PathBuf, std_io_Error> = v4648 |> Error
                                                                                                                        let _v4651 = v4660 
                                                                                                                        #endif
                                                                                                                        let v4661 : Result<std_path_PathBuf, std_io_Error> = _v4651 
                                                                                                                        v4661
                                                                                                                | US8_0(v3304) -> (* Ok *)
                                                                                                                    let v3305 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v3306 : string = "Ok($0)"
                                                                                                                    let v3307 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3304 v3306 
                                                                                                                    let _v3305 = v3307 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v3308 : string = "Ok($0)"
                                                                                                                    let v3309 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3304 v3308 
                                                                                                                    let _v3305 = v3309 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v3310 : string = "Ok($0)"
                                                                                                                    let v3311 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3304 v3310 
                                                                                                                    let _v3305 = v3311 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v3312 : Result<std_path_PathBuf, std_io_Error> = v3304 |> Ok
                                                                                                                    let _v3305 = v3312 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v3313 : Result<std_path_PathBuf, std_io_Error> = v3304 |> Ok
                                                                                                                    let _v3305 = v3313 
                                                                                                                    #endif
#else
                                                                                                                    let v3314 : Result<std_path_PathBuf, std_io_Error> = v3304 |> Ok
                                                                                                                    let _v3305 = v3314 
                                                                                                                    #endif
                                                                                                                    let v3315 : Result<std_path_PathBuf, std_io_Error> = _v3305 
                                                                                                                    v3315
                                                                                                            let v4667 : (std_io_Error -> string) = method41()
                                                                                                            let v4668 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v4669 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v4670 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4666, v4667) v4669 
                                                                                                            let _v4668 = v4670 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v4671 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v4672 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4666, v4667) v4671 
                                                                                                            let _v4668 = v4672 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v4673 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v4674 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4666, v4667) v4673 
                                                                                                            let _v4668 = v4674 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v4675 : Result<std_path_PathBuf, string> = match v4666 with Ok x -> Ok x | Error x -> Error (v4667 x)
                                                                                                            let _v4668 = v4675 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v4676 : Result<std_path_PathBuf, string> = match v4666 with Ok x -> Ok x | Error x -> Error (v4667 x)
                                                                                                            let _v4668 = v4676 
                                                                                                            #endif
#else
                                                                                                            let v4677 : Result<std_path_PathBuf, string> = match v4666 with Ok x -> Ok x | Error x -> Error (v4667 x)
                                                                                                            let _v4668 = v4677 
                                                                                                            #endif
                                                                                                            let v4678 : Result<std_path_PathBuf, string> = _v4668 
                                                                                                            let v4681 : US8 = match v4678 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                            match v4681 with
                                                                                                            | US8_1(v4784) -> (* Error *)
                                                                                                                let v4785 : string = $"file_system.read_link / error': {v4784} / error: {v3263} / name: {v3264}"
                                                                                                                let v4786 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v4787 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v4788 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4785 v4787 
                                                                                                                let _v4786 = v4788 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v4789 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v4790 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4785 v4789 
                                                                                                                let _v4786 = v4790 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v4791 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v4792 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4785 v4791 
                                                                                                                let _v4786 = v4792 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v4793 : std_io_Error = v4785 
                                                                                                                let _v4786 = v4793 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v4794 : std_io_Error = v4785 
                                                                                                                let _v4786 = v4794 
                                                                                                                #endif
#else
                                                                                                                let v4795 : std_io_Error = v4785 
                                                                                                                let _v4786 = v4795 
                                                                                                                #endif
                                                                                                                let v4796 : std_io_Error = _v4786 
                                                                                                                let v4799 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v4800 : string = "Err($0)"
                                                                                                                let v4801 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4796 v4800 
                                                                                                                let _v4799 = v4801 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v4802 : string = "Err($0)"
                                                                                                                let v4803 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4796 v4802 
                                                                                                                let _v4799 = v4803 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v4804 : string = "Err($0)"
                                                                                                                let v4805 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4796 v4804 
                                                                                                                let _v4799 = v4805 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v4806 : Result<std_path_PathBuf, std_io_Error> = v4796 |> Error
                                                                                                                let _v4799 = v4806 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v4807 : Result<std_path_PathBuf, std_io_Error> = v4796 |> Error
                                                                                                                let _v4799 = v4807 
                                                                                                                #endif
#else
                                                                                                                let v4808 : Result<std_path_PathBuf, std_io_Error> = v4796 |> Error
                                                                                                                let _v4799 = v4808 
                                                                                                                #endif
                                                                                                                let v4809 : Result<std_path_PathBuf, std_io_Error> = _v4799 
                                                                                                                v4809
                                                                                                            | US8_0(v4682) -> (* Ok *)
                                                                                                                let v4683 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v4684 : string = "$0.display()"
                                                                                                                let v4685 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4682 v4684 
                                                                                                                let _v4683 = v4685 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v4686 : string = "$0.display()"
                                                                                                                let v4687 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4682 v4686 
                                                                                                                let _v4683 = v4687 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v4688 : string = "$0.display()"
                                                                                                                let v4689 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4682 v4688 
                                                                                                                let _v4683 = v4689 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v4690 : std_path_Display = v4682 |> unbox<std_path_Display>
                                                                                                                let _v4683 = v4690 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v4693 : std_path_Display = v4682 |> unbox<std_path_Display>
                                                                                                                let _v4683 = v4693 
                                                                                                                #endif
#else
                                                                                                                let v4696 : std_path_Display = v4682 |> unbox<std_path_Display>
                                                                                                                let _v4683 = v4696 
                                                                                                                #endif
                                                                                                                let v4699 : std_path_Display = _v4683 
                                                                                                                let v4704 : string = v4699 |> string 
                                                                                                                let v4707 : string = method26(v4704, v3264)
                                                                                                                let v4708 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v4709 : string = "&*$0"
                                                                                                                let v4710 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4707 v4709 
                                                                                                                let _v4708 = v4710 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v4711 : string = "&*$0"
                                                                                                                let v4712 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4707 v4711 
                                                                                                                let _v4708 = v4712 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v4713 : string = "&*$0"
                                                                                                                let v4714 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4707 v4713 
                                                                                                                let _v4708 = v4714 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v4715 : Ref<Str> = v4707 |> unbox<Ref<Str>>
                                                                                                                let _v4708 = v4715 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v4718 : Ref<Str> = v4707 |> unbox<Ref<Str>>
                                                                                                                let _v4708 = v4718 
                                                                                                                #endif
#else
                                                                                                                let v4721 : Ref<Str> = v4707 |> unbox<Ref<Str>>
                                                                                                                let _v4708 = v4721 
                                                                                                                #endif
                                                                                                                let v4724 : Ref<Str> = _v4708 
                                                                                                                let v4729 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v4730 : string = "String::from($0)"
                                                                                                                let v4731 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4724 v4730 
                                                                                                                let _v4729 = v4731 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v4732 : string = "String::from($0)"
                                                                                                                let v4733 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4724 v4732 
                                                                                                                let _v4729 = v4733 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v4734 : string = "String::from($0)"
                                                                                                                let v4735 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4724 v4734 
                                                                                                                let _v4729 = v4735 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v4736 : std_string_String = v4724 |> unbox<std_string_String>
                                                                                                                let _v4729 = v4736 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v4739 : std_string_String = v4724 |> unbox<std_string_String>
                                                                                                                let _v4729 = v4739 
                                                                                                                #endif
#else
                                                                                                                let v4742 : std_string_String = v4724 |> unbox<std_string_String>
                                                                                                                let _v4729 = v4742 
                                                                                                                #endif
                                                                                                                let v4745 : std_string_String = _v4729 
                                                                                                                let v4750 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v4751 : string = "std::path::PathBuf::from($0)"
                                                                                                                let v4752 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4745 v4751 
                                                                                                                let _v4750 = v4752 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v4753 : string = "std::path::PathBuf::from($0)"
                                                                                                                let v4754 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4745 v4753 
                                                                                                                let _v4750 = v4754 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v4755 : string = "std::path::PathBuf::from($0)"
                                                                                                                let v4756 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4745 v4755 
                                                                                                                let _v4750 = v4756 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v4757 : std_path_PathBuf = v4745 |> std_path_PathBuf 
                                                                                                                let _v4750 = v4757 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v4760 : std_path_PathBuf = v4745 |> std_path_PathBuf 
                                                                                                                let _v4750 = v4760 
                                                                                                                #endif
#else
                                                                                                                let v4763 : std_path_PathBuf = v4745 |> std_path_PathBuf 
                                                                                                                let _v4750 = v4763 
                                                                                                                #endif
                                                                                                                let v4766 : std_path_PathBuf = _v4750 
                                                                                                                let v4771 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v4772 : string = "Ok($0)"
                                                                                                                let v4773 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4766 v4772 
                                                                                                                let _v4771 = v4773 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v4774 : string = "Ok($0)"
                                                                                                                let v4775 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4766 v4774 
                                                                                                                let _v4771 = v4775 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v4776 : string = "Ok($0)"
                                                                                                                let v4777 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4766 v4776 
                                                                                                                let _v4771 = v4777 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v4778 : Result<std_path_PathBuf, std_io_Error> = v4766 |> Ok
                                                                                                                let _v4771 = v4778 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v4779 : Result<std_path_PathBuf, std_io_Error> = v4766 |> Ok
                                                                                                                let _v4771 = v4779 
                                                                                                                #endif
#else
                                                                                                                let v4780 : Result<std_path_PathBuf, std_io_Error> = v4766 |> Ok
                                                                                                                let _v4771 = v4780 
                                                                                                                #endif
                                                                                                                let v4781 : Result<std_path_PathBuf, std_io_Error> = _v4771 
                                                                                                                v4781
                                                                                                        else
                                                                                                            let v4814 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3263} / path': {v3228} / name: {v3264}"
                                                                                                            let v4815 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v4816 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v4817 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4814 v4816 
                                                                                                            let _v4815 = v4817 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v4818 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v4819 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4814 v4818 
                                                                                                            let _v4815 = v4819 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v4820 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v4821 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4814 v4820 
                                                                                                            let _v4815 = v4821 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v4822 : std_io_Error = v4814 
                                                                                                            let _v4815 = v4822 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v4823 : std_io_Error = v4814 
                                                                                                            let _v4815 = v4823 
                                                                                                            #endif
#else
                                                                                                            let v4824 : std_io_Error = v4814 
                                                                                                            let _v4815 = v4824 
                                                                                                            #endif
                                                                                                            let v4825 : std_io_Error = _v4815 
                                                                                                            let v4828 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v4829 : string = "Err($0)"
                                                                                                            let v4830 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4825 v4829 
                                                                                                            let _v4828 = v4830 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v4831 : string = "Err($0)"
                                                                                                            let v4832 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4825 v4831 
                                                                                                            let _v4828 = v4832 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v4833 : string = "Err($0)"
                                                                                                            let v4834 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4825 v4833 
                                                                                                            let _v4828 = v4834 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v4835 : Result<std_path_PathBuf, std_io_Error> = v4825 |> Error
                                                                                                            let _v4828 = v4835 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v4836 : Result<std_path_PathBuf, std_io_Error> = v4825 |> Error
                                                                                                            let _v4828 = v4836 
                                                                                                            #endif
#else
                                                                                                            let v4837 : Result<std_path_PathBuf, std_io_Error> = v4825 |> Error
                                                                                                            let _v4828 = v4837 
                                                                                                            #endif
                                                                                                            let v4838 : Result<std_path_PathBuf, std_io_Error> = _v4828 
                                                                                                            v4838
                                                                                                    | _ ->
                                                                                                        let v4842 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3263} / path': {v3228} / name: {v3264}"
                                                                                                        let v4843 : unit = ()
                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                        let v4844 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                        let v4845 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4842 v4844 
                                                                                                        let _v4843 = v4845 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                        let v4846 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                        let v4847 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4842 v4846 
                                                                                                        let _v4843 = v4847 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                        let v4848 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                        let v4849 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4842 v4848 
                                                                                                        let _v4843 = v4849 
                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                        let v4850 : std_io_Error = v4842 
                                                                                                        let _v4843 = v4850 
                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                        let v4851 : std_io_Error = v4842 
                                                                                                        let _v4843 = v4851 
                                                                                                        #endif
#else
                                                                                                        let v4852 : std_io_Error = v4842 
                                                                                                        let _v4843 = v4852 
                                                                                                        #endif
                                                                                                        let v4853 : std_io_Error = _v4843 
                                                                                                        let v4856 : unit = ()
                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                        let v4857 : string = "Err($0)"
                                                                                                        let v4858 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4853 v4857 
                                                                                                        let _v4856 = v4858 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                        let v4859 : string = "Err($0)"
                                                                                                        let v4860 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4853 v4859 
                                                                                                        let _v4856 = v4860 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                        let v4861 : string = "Err($0)"
                                                                                                        let v4862 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4853 v4861 
                                                                                                        let _v4856 = v4862 
                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                        let v4863 : Result<std_path_PathBuf, std_io_Error> = v4853 |> Error
                                                                                                        let _v4856 = v4863 
                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                        let v4864 : Result<std_path_PathBuf, std_io_Error> = v4853 |> Error
                                                                                                        let _v4856 = v4864 
                                                                                                        #endif
#else
                                                                                                        let v4865 : Result<std_path_PathBuf, std_io_Error> = v4853 |> Error
                                                                                                        let _v4856 = v4865 
                                                                                                        #endif
                                                                                                        let v4866 : Result<std_path_PathBuf, std_io_Error> = _v4856 
                                                                                                        v4866
                                                                                                | US8_0(v3249) -> (* Ok *)
                                                                                                    let v3250 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v3251 : string = "Ok($0)"
                                                                                                    let v3252 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3249 v3251 
                                                                                                    let _v3250 = v3252 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v3253 : string = "Ok($0)"
                                                                                                    let v3254 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3249 v3253 
                                                                                                    let _v3250 = v3254 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v3255 : string = "Ok($0)"
                                                                                                    let v3256 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3249 v3255 
                                                                                                    let _v3250 = v3256 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v3257 : Result<std_path_PathBuf, std_io_Error> = v3249 |> Ok
                                                                                                    let _v3250 = v3257 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v3258 : Result<std_path_PathBuf, std_io_Error> = v3249 |> Ok
                                                                                                    let _v3250 = v3258 
                                                                                                    #endif
#else
                                                                                                    let v3259 : Result<std_path_PathBuf, std_io_Error> = v3249 |> Ok
                                                                                                    let _v3250 = v3259 
                                                                                                    #endif
                                                                                                    let v3260 : Result<std_path_PathBuf, std_io_Error> = _v3250 
                                                                                                    v3260
                                                                                            let v4872 : (std_io_Error -> string) = method41()
                                                                                            let v4873 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v4874 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v4875 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4871, v4872) v4874 
                                                                                            let _v4873 = v4875 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v4876 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v4877 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4871, v4872) v4876 
                                                                                            let _v4873 = v4877 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v4878 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v4879 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4871, v4872) v4878 
                                                                                            let _v4873 = v4879 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v4880 : Result<std_path_PathBuf, string> = match v4871 with Ok x -> Ok x | Error x -> Error (v4872 x)
                                                                                            let _v4873 = v4880 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v4881 : Result<std_path_PathBuf, string> = match v4871 with Ok x -> Ok x | Error x -> Error (v4872 x)
                                                                                            let _v4873 = v4881 
                                                                                            #endif
#else
                                                                                            let v4882 : Result<std_path_PathBuf, string> = match v4871 with Ok x -> Ok x | Error x -> Error (v4872 x)
                                                                                            let _v4873 = v4882 
                                                                                            #endif
                                                                                            let v4883 : Result<std_path_PathBuf, string> = _v4873 
                                                                                            let v4886 : US8 = match v4883 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                            match v4886 with
                                                                                            | US8_1(v4989) -> (* Error *)
                                                                                                let v4990 : string = $"file_system.read_link / error': {v4989} / error: {v3208} / name: {v3209}"
                                                                                                let v4991 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v4992 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v4993 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4990 v4992 
                                                                                                let _v4991 = v4993 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v4994 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v4995 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4990 v4994 
                                                                                                let _v4991 = v4995 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v4996 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v4997 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4990 v4996 
                                                                                                let _v4991 = v4997 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v4998 : std_io_Error = v4990 
                                                                                                let _v4991 = v4998 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v4999 : std_io_Error = v4990 
                                                                                                let _v4991 = v4999 
                                                                                                #endif
#else
                                                                                                let v5000 : std_io_Error = v4990 
                                                                                                let _v4991 = v5000 
                                                                                                #endif
                                                                                                let v5001 : std_io_Error = _v4991 
                                                                                                let v5004 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v5005 : string = "Err($0)"
                                                                                                let v5006 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5001 v5005 
                                                                                                let _v5004 = v5006 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v5007 : string = "Err($0)"
                                                                                                let v5008 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5001 v5007 
                                                                                                let _v5004 = v5008 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v5009 : string = "Err($0)"
                                                                                                let v5010 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5001 v5009 
                                                                                                let _v5004 = v5010 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v5011 : Result<std_path_PathBuf, std_io_Error> = v5001 |> Error
                                                                                                let _v5004 = v5011 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v5012 : Result<std_path_PathBuf, std_io_Error> = v5001 |> Error
                                                                                                let _v5004 = v5012 
                                                                                                #endif
#else
                                                                                                let v5013 : Result<std_path_PathBuf, std_io_Error> = v5001 |> Error
                                                                                                let _v5004 = v5013 
                                                                                                #endif
                                                                                                let v5014 : Result<std_path_PathBuf, std_io_Error> = _v5004 
                                                                                                v5014
                                                                                            | US8_0(v4887) -> (* Ok *)
                                                                                                let v4888 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v4889 : string = "$0.display()"
                                                                                                let v4890 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4887 v4889 
                                                                                                let _v4888 = v4890 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v4891 : string = "$0.display()"
                                                                                                let v4892 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4887 v4891 
                                                                                                let _v4888 = v4892 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v4893 : string = "$0.display()"
                                                                                                let v4894 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4887 v4893 
                                                                                                let _v4888 = v4894 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v4895 : std_path_Display = v4887 |> unbox<std_path_Display>
                                                                                                let _v4888 = v4895 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v4898 : std_path_Display = v4887 |> unbox<std_path_Display>
                                                                                                let _v4888 = v4898 
                                                                                                #endif
#else
                                                                                                let v4901 : std_path_Display = v4887 |> unbox<std_path_Display>
                                                                                                let _v4888 = v4901 
                                                                                                #endif
                                                                                                let v4904 : std_path_Display = _v4888 
                                                                                                let v4909 : string = v4904 |> string 
                                                                                                let v4912 : string = method26(v4909, v3209)
                                                                                                let v4913 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v4914 : string = "&*$0"
                                                                                                let v4915 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4912 v4914 
                                                                                                let _v4913 = v4915 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v4916 : string = "&*$0"
                                                                                                let v4917 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4912 v4916 
                                                                                                let _v4913 = v4917 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v4918 : string = "&*$0"
                                                                                                let v4919 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4912 v4918 
                                                                                                let _v4913 = v4919 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v4920 : Ref<Str> = v4912 |> unbox<Ref<Str>>
                                                                                                let _v4913 = v4920 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v4923 : Ref<Str> = v4912 |> unbox<Ref<Str>>
                                                                                                let _v4913 = v4923 
                                                                                                #endif
#else
                                                                                                let v4926 : Ref<Str> = v4912 |> unbox<Ref<Str>>
                                                                                                let _v4913 = v4926 
                                                                                                #endif
                                                                                                let v4929 : Ref<Str> = _v4913 
                                                                                                let v4934 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v4935 : string = "String::from($0)"
                                                                                                let v4936 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4929 v4935 
                                                                                                let _v4934 = v4936 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v4937 : string = "String::from($0)"
                                                                                                let v4938 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4929 v4937 
                                                                                                let _v4934 = v4938 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v4939 : string = "String::from($0)"
                                                                                                let v4940 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4929 v4939 
                                                                                                let _v4934 = v4940 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v4941 : std_string_String = v4929 |> unbox<std_string_String>
                                                                                                let _v4934 = v4941 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v4944 : std_string_String = v4929 |> unbox<std_string_String>
                                                                                                let _v4934 = v4944 
                                                                                                #endif
#else
                                                                                                let v4947 : std_string_String = v4929 |> unbox<std_string_String>
                                                                                                let _v4934 = v4947 
                                                                                                #endif
                                                                                                let v4950 : std_string_String = _v4934 
                                                                                                let v4955 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v4956 : string = "std::path::PathBuf::from($0)"
                                                                                                let v4957 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4950 v4956 
                                                                                                let _v4955 = v4957 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v4958 : string = "std::path::PathBuf::from($0)"
                                                                                                let v4959 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4950 v4958 
                                                                                                let _v4955 = v4959 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v4960 : string = "std::path::PathBuf::from($0)"
                                                                                                let v4961 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4950 v4960 
                                                                                                let _v4955 = v4961 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v4962 : std_path_PathBuf = v4950 |> std_path_PathBuf 
                                                                                                let _v4955 = v4962 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v4965 : std_path_PathBuf = v4950 |> std_path_PathBuf 
                                                                                                let _v4955 = v4965 
                                                                                                #endif
#else
                                                                                                let v4968 : std_path_PathBuf = v4950 |> std_path_PathBuf 
                                                                                                let _v4955 = v4968 
                                                                                                #endif
                                                                                                let v4971 : std_path_PathBuf = _v4955 
                                                                                                let v4976 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v4977 : string = "Ok($0)"
                                                                                                let v4978 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4971 v4977 
                                                                                                let _v4976 = v4978 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v4979 : string = "Ok($0)"
                                                                                                let v4980 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4971 v4979 
                                                                                                let _v4976 = v4980 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v4981 : string = "Ok($0)"
                                                                                                let v4982 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4971 v4981 
                                                                                                let _v4976 = v4982 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v4983 : Result<std_path_PathBuf, std_io_Error> = v4971 |> Ok
                                                                                                let _v4976 = v4983 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v4984 : Result<std_path_PathBuf, std_io_Error> = v4971 |> Ok
                                                                                                let _v4976 = v4984 
                                                                                                #endif
#else
                                                                                                let v4985 : Result<std_path_PathBuf, std_io_Error> = v4971 |> Ok
                                                                                                let _v4976 = v4985 
                                                                                                #endif
                                                                                                let v4986 : Result<std_path_PathBuf, std_io_Error> = _v4976 
                                                                                                v4986
                                                                                        else
                                                                                            let v5019 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3208} / path': {v3173} / name: {v3209}"
                                                                                            let v5020 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v5021 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v5022 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5019 v5021 
                                                                                            let _v5020 = v5022 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v5023 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v5024 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5019 v5023 
                                                                                            let _v5020 = v5024 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v5025 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v5026 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5019 v5025 
                                                                                            let _v5020 = v5026 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v5027 : std_io_Error = v5019 
                                                                                            let _v5020 = v5027 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v5028 : std_io_Error = v5019 
                                                                                            let _v5020 = v5028 
                                                                                            #endif
#else
                                                                                            let v5029 : std_io_Error = v5019 
                                                                                            let _v5020 = v5029 
                                                                                            #endif
                                                                                            let v5030 : std_io_Error = _v5020 
                                                                                            let v5033 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v5034 : string = "Err($0)"
                                                                                            let v5035 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5030 v5034 
                                                                                            let _v5033 = v5035 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v5036 : string = "Err($0)"
                                                                                            let v5037 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5030 v5036 
                                                                                            let _v5033 = v5037 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v5038 : string = "Err($0)"
                                                                                            let v5039 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5030 v5038 
                                                                                            let _v5033 = v5039 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v5040 : Result<std_path_PathBuf, std_io_Error> = v5030 |> Error
                                                                                            let _v5033 = v5040 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v5041 : Result<std_path_PathBuf, std_io_Error> = v5030 |> Error
                                                                                            let _v5033 = v5041 
                                                                                            #endif
#else
                                                                                            let v5042 : Result<std_path_PathBuf, std_io_Error> = v5030 |> Error
                                                                                            let _v5033 = v5042 
                                                                                            #endif
                                                                                            let v5043 : Result<std_path_PathBuf, std_io_Error> = _v5033 
                                                                                            v5043
                                                                                    | _ ->
                                                                                        let v5047 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3208} / path': {v3173} / name: {v3209}"
                                                                                        let v5048 : unit = ()
                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                        let v5049 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                        let v5050 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5047 v5049 
                                                                                        let _v5048 = v5050 
                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                        let v5051 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                        let v5052 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5047 v5051 
                                                                                        let _v5048 = v5052 
                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                        let v5053 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                        let v5054 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5047 v5053 
                                                                                        let _v5048 = v5054 
                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                        let v5055 : std_io_Error = v5047 
                                                                                        let _v5048 = v5055 
                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                        let v5056 : std_io_Error = v5047 
                                                                                        let _v5048 = v5056 
                                                                                        #endif
#else
                                                                                        let v5057 : std_io_Error = v5047 
                                                                                        let _v5048 = v5057 
                                                                                        #endif
                                                                                        let v5058 : std_io_Error = _v5048 
                                                                                        let v5061 : unit = ()
                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                        let v5062 : string = "Err($0)"
                                                                                        let v5063 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5058 v5062 
                                                                                        let _v5061 = v5063 
                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                        let v5064 : string = "Err($0)"
                                                                                        let v5065 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5058 v5064 
                                                                                        let _v5061 = v5065 
                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                        let v5066 : string = "Err($0)"
                                                                                        let v5067 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5058 v5066 
                                                                                        let _v5061 = v5067 
                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                        let v5068 : Result<std_path_PathBuf, std_io_Error> = v5058 |> Error
                                                                                        let _v5061 = v5068 
                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                        let v5069 : Result<std_path_PathBuf, std_io_Error> = v5058 |> Error
                                                                                        let _v5061 = v5069 
                                                                                        #endif
#else
                                                                                        let v5070 : Result<std_path_PathBuf, std_io_Error> = v5058 |> Error
                                                                                        let _v5061 = v5070 
                                                                                        #endif
                                                                                        let v5071 : Result<std_path_PathBuf, std_io_Error> = _v5061 
                                                                                        v5071
                                                                                | US8_0(v3194) -> (* Ok *)
                                                                                    let v3195 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v3196 : string = "Ok($0)"
                                                                                    let v3197 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3194 v3196 
                                                                                    let _v3195 = v3197 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v3198 : string = "Ok($0)"
                                                                                    let v3199 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3194 v3198 
                                                                                    let _v3195 = v3199 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v3200 : string = "Ok($0)"
                                                                                    let v3201 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3194 v3200 
                                                                                    let _v3195 = v3201 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v3202 : Result<std_path_PathBuf, std_io_Error> = v3194 |> Ok
                                                                                    let _v3195 = v3202 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v3203 : Result<std_path_PathBuf, std_io_Error> = v3194 |> Ok
                                                                                    let _v3195 = v3203 
                                                                                    #endif
#else
                                                                                    let v3204 : Result<std_path_PathBuf, std_io_Error> = v3194 |> Ok
                                                                                    let _v3195 = v3204 
                                                                                    #endif
                                                                                    let v3205 : Result<std_path_PathBuf, std_io_Error> = _v3195 
                                                                                    v3205
                                                                            let v5077 : (std_io_Error -> string) = method41()
                                                                            let v5078 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v5079 : string = "$0.map_err(|x| $1(x))"
                                                                            let v5080 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5076, v5077) v5079 
                                                                            let _v5078 = v5080 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v5081 : string = "$0.map_err(|x| $1(x))"
                                                                            let v5082 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5076, v5077) v5081 
                                                                            let _v5078 = v5082 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v5083 : string = "$0.map_err(|x| $1(x))"
                                                                            let v5084 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5076, v5077) v5083 
                                                                            let _v5078 = v5084 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v5085 : Result<std_path_PathBuf, string> = match v5076 with Ok x -> Ok x | Error x -> Error (v5077 x)
                                                                            let _v5078 = v5085 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v5086 : Result<std_path_PathBuf, string> = match v5076 with Ok x -> Ok x | Error x -> Error (v5077 x)
                                                                            let _v5078 = v5086 
                                                                            #endif
#else
                                                                            let v5087 : Result<std_path_PathBuf, string> = match v5076 with Ok x -> Ok x | Error x -> Error (v5077 x)
                                                                            let _v5078 = v5087 
                                                                            #endif
                                                                            let v5088 : Result<std_path_PathBuf, string> = _v5078 
                                                                            let v5091 : US8 = match v5088 with Ok x -> v2970 x | Error x -> v2971 x
                                                                            match v5091 with
                                                                            | US8_1(v5194) -> (* Error *)
                                                                                let v5195 : string = $"file_system.read_link / error': {v5194} / error: {v3153} / name: {v3154}"
                                                                                let v5196 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v5197 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v5198 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5195 v5197 
                                                                                let _v5196 = v5198 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v5199 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v5200 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5195 v5199 
                                                                                let _v5196 = v5200 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v5201 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v5202 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5195 v5201 
                                                                                let _v5196 = v5202 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v5203 : std_io_Error = v5195 
                                                                                let _v5196 = v5203 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v5204 : std_io_Error = v5195 
                                                                                let _v5196 = v5204 
                                                                                #endif
#else
                                                                                let v5205 : std_io_Error = v5195 
                                                                                let _v5196 = v5205 
                                                                                #endif
                                                                                let v5206 : std_io_Error = _v5196 
                                                                                let v5209 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v5210 : string = "Err($0)"
                                                                                let v5211 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5206 v5210 
                                                                                let _v5209 = v5211 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v5212 : string = "Err($0)"
                                                                                let v5213 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5206 v5212 
                                                                                let _v5209 = v5213 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v5214 : string = "Err($0)"
                                                                                let v5215 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5206 v5214 
                                                                                let _v5209 = v5215 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v5216 : Result<std_path_PathBuf, std_io_Error> = v5206 |> Error
                                                                                let _v5209 = v5216 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v5217 : Result<std_path_PathBuf, std_io_Error> = v5206 |> Error
                                                                                let _v5209 = v5217 
                                                                                #endif
#else
                                                                                let v5218 : Result<std_path_PathBuf, std_io_Error> = v5206 |> Error
                                                                                let _v5209 = v5218 
                                                                                #endif
                                                                                let v5219 : Result<std_path_PathBuf, std_io_Error> = _v5209 
                                                                                v5219
                                                                            | US8_0(v5092) -> (* Ok *)
                                                                                let v5093 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v5094 : string = "$0.display()"
                                                                                let v5095 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5092 v5094 
                                                                                let _v5093 = v5095 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v5096 : string = "$0.display()"
                                                                                let v5097 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5092 v5096 
                                                                                let _v5093 = v5097 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v5098 : string = "$0.display()"
                                                                                let v5099 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5092 v5098 
                                                                                let _v5093 = v5099 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v5100 : std_path_Display = v5092 |> unbox<std_path_Display>
                                                                                let _v5093 = v5100 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v5103 : std_path_Display = v5092 |> unbox<std_path_Display>
                                                                                let _v5093 = v5103 
                                                                                #endif
#else
                                                                                let v5106 : std_path_Display = v5092 |> unbox<std_path_Display>
                                                                                let _v5093 = v5106 
                                                                                #endif
                                                                                let v5109 : std_path_Display = _v5093 
                                                                                let v5114 : string = v5109 |> string 
                                                                                let v5117 : string = method26(v5114, v3154)
                                                                                let v5118 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v5119 : string = "&*$0"
                                                                                let v5120 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5117 v5119 
                                                                                let _v5118 = v5120 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v5121 : string = "&*$0"
                                                                                let v5122 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5117 v5121 
                                                                                let _v5118 = v5122 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v5123 : string = "&*$0"
                                                                                let v5124 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5117 v5123 
                                                                                let _v5118 = v5124 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v5125 : Ref<Str> = v5117 |> unbox<Ref<Str>>
                                                                                let _v5118 = v5125 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v5128 : Ref<Str> = v5117 |> unbox<Ref<Str>>
                                                                                let _v5118 = v5128 
                                                                                #endif
#else
                                                                                let v5131 : Ref<Str> = v5117 |> unbox<Ref<Str>>
                                                                                let _v5118 = v5131 
                                                                                #endif
                                                                                let v5134 : Ref<Str> = _v5118 
                                                                                let v5139 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v5140 : string = "String::from($0)"
                                                                                let v5141 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5134 v5140 
                                                                                let _v5139 = v5141 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v5142 : string = "String::from($0)"
                                                                                let v5143 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5134 v5142 
                                                                                let _v5139 = v5143 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v5144 : string = "String::from($0)"
                                                                                let v5145 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5134 v5144 
                                                                                let _v5139 = v5145 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v5146 : std_string_String = v5134 |> unbox<std_string_String>
                                                                                let _v5139 = v5146 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v5149 : std_string_String = v5134 |> unbox<std_string_String>
                                                                                let _v5139 = v5149 
                                                                                #endif
#else
                                                                                let v5152 : std_string_String = v5134 |> unbox<std_string_String>
                                                                                let _v5139 = v5152 
                                                                                #endif
                                                                                let v5155 : std_string_String = _v5139 
                                                                                let v5160 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v5161 : string = "std::path::PathBuf::from($0)"
                                                                                let v5162 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5155 v5161 
                                                                                let _v5160 = v5162 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v5163 : string = "std::path::PathBuf::from($0)"
                                                                                let v5164 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5155 v5163 
                                                                                let _v5160 = v5164 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v5165 : string = "std::path::PathBuf::from($0)"
                                                                                let v5166 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5155 v5165 
                                                                                let _v5160 = v5166 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v5167 : std_path_PathBuf = v5155 |> std_path_PathBuf 
                                                                                let _v5160 = v5167 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v5170 : std_path_PathBuf = v5155 |> std_path_PathBuf 
                                                                                let _v5160 = v5170 
                                                                                #endif
#else
                                                                                let v5173 : std_path_PathBuf = v5155 |> std_path_PathBuf 
                                                                                let _v5160 = v5173 
                                                                                #endif
                                                                                let v5176 : std_path_PathBuf = _v5160 
                                                                                let v5181 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v5182 : string = "Ok($0)"
                                                                                let v5183 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5176 v5182 
                                                                                let _v5181 = v5183 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v5184 : string = "Ok($0)"
                                                                                let v5185 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5176 v5184 
                                                                                let _v5181 = v5185 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v5186 : string = "Ok($0)"
                                                                                let v5187 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5176 v5186 
                                                                                let _v5181 = v5187 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v5188 : Result<std_path_PathBuf, std_io_Error> = v5176 |> Ok
                                                                                let _v5181 = v5188 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v5189 : Result<std_path_PathBuf, std_io_Error> = v5176 |> Ok
                                                                                let _v5181 = v5189 
                                                                                #endif
#else
                                                                                let v5190 : Result<std_path_PathBuf, std_io_Error> = v5176 |> Ok
                                                                                let _v5181 = v5190 
                                                                                #endif
                                                                                let v5191 : Result<std_path_PathBuf, std_io_Error> = _v5181 
                                                                                v5191
                                                                        else
                                                                            let v5224 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3153} / path': {v3118} / name: {v3154}"
                                                                            let v5225 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v5226 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v5227 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5224 v5226 
                                                                            let _v5225 = v5227 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v5228 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v5229 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5224 v5228 
                                                                            let _v5225 = v5229 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v5230 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v5231 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5224 v5230 
                                                                            let _v5225 = v5231 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v5232 : std_io_Error = v5224 
                                                                            let _v5225 = v5232 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v5233 : std_io_Error = v5224 
                                                                            let _v5225 = v5233 
                                                                            #endif
#else
                                                                            let v5234 : std_io_Error = v5224 
                                                                            let _v5225 = v5234 
                                                                            #endif
                                                                            let v5235 : std_io_Error = _v5225 
                                                                            let v5238 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v5239 : string = "Err($0)"
                                                                            let v5240 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5235 v5239 
                                                                            let _v5238 = v5240 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v5241 : string = "Err($0)"
                                                                            let v5242 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5235 v5241 
                                                                            let _v5238 = v5242 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v5243 : string = "Err($0)"
                                                                            let v5244 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5235 v5243 
                                                                            let _v5238 = v5244 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v5245 : Result<std_path_PathBuf, std_io_Error> = v5235 |> Error
                                                                            let _v5238 = v5245 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v5246 : Result<std_path_PathBuf, std_io_Error> = v5235 |> Error
                                                                            let _v5238 = v5246 
                                                                            #endif
#else
                                                                            let v5247 : Result<std_path_PathBuf, std_io_Error> = v5235 |> Error
                                                                            let _v5238 = v5247 
                                                                            #endif
                                                                            let v5248 : Result<std_path_PathBuf, std_io_Error> = _v5238 
                                                                            v5248
                                                                    | _ ->
                                                                        let v5252 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3153} / path': {v3118} / name: {v3154}"
                                                                        let v5253 : unit = ()
                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                        let v5254 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                        let v5255 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5252 v5254 
                                                                        let _v5253 = v5255 
                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                        let v5256 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                        let v5257 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5252 v5256 
                                                                        let _v5253 = v5257 
                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                        let v5258 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                        let v5259 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5252 v5258 
                                                                        let _v5253 = v5259 
                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                        let v5260 : std_io_Error = v5252 
                                                                        let _v5253 = v5260 
                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                        let v5261 : std_io_Error = v5252 
                                                                        let _v5253 = v5261 
                                                                        #endif
#else
                                                                        let v5262 : std_io_Error = v5252 
                                                                        let _v5253 = v5262 
                                                                        #endif
                                                                        let v5263 : std_io_Error = _v5253 
                                                                        let v5266 : unit = ()
                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                        let v5267 : string = "Err($0)"
                                                                        let v5268 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5263 v5267 
                                                                        let _v5266 = v5268 
                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                        let v5269 : string = "Err($0)"
                                                                        let v5270 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5263 v5269 
                                                                        let _v5266 = v5270 
                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                        let v5271 : string = "Err($0)"
                                                                        let v5272 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5263 v5271 
                                                                        let _v5266 = v5272 
                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                        let v5273 : Result<std_path_PathBuf, std_io_Error> = v5263 |> Error
                                                                        let _v5266 = v5273 
                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                        let v5274 : Result<std_path_PathBuf, std_io_Error> = v5263 |> Error
                                                                        let _v5266 = v5274 
                                                                        #endif
#else
                                                                        let v5275 : Result<std_path_PathBuf, std_io_Error> = v5263 |> Error
                                                                        let _v5266 = v5275 
                                                                        #endif
                                                                        let v5276 : Result<std_path_PathBuf, std_io_Error> = _v5266 
                                                                        v5276
                                                                | US8_0(v3139) -> (* Ok *)
                                                                    let v3140 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v3141 : string = "Ok($0)"
                                                                    let v3142 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3139 v3141 
                                                                    let _v3140 = v3142 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v3143 : string = "Ok($0)"
                                                                    let v3144 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3139 v3143 
                                                                    let _v3140 = v3144 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v3145 : string = "Ok($0)"
                                                                    let v3146 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3139 v3145 
                                                                    let _v3140 = v3146 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v3147 : Result<std_path_PathBuf, std_io_Error> = v3139 |> Ok
                                                                    let _v3140 = v3147 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v3148 : Result<std_path_PathBuf, std_io_Error> = v3139 |> Ok
                                                                    let _v3140 = v3148 
                                                                    #endif
#else
                                                                    let v3149 : Result<std_path_PathBuf, std_io_Error> = v3139 |> Ok
                                                                    let _v3140 = v3149 
                                                                    #endif
                                                                    let v3150 : Result<std_path_PathBuf, std_io_Error> = _v3140 
                                                                    v3150
                                                            let v5282 : (std_io_Error -> string) = method41()
                                                            let v5283 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v5284 : string = "$0.map_err(|x| $1(x))"
                                                            let v5285 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5281, v5282) v5284 
                                                            let _v5283 = v5285 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v5286 : string = "$0.map_err(|x| $1(x))"
                                                            let v5287 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5281, v5282) v5286 
                                                            let _v5283 = v5287 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v5288 : string = "$0.map_err(|x| $1(x))"
                                                            let v5289 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5281, v5282) v5288 
                                                            let _v5283 = v5289 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v5290 : Result<std_path_PathBuf, string> = match v5281 with Ok x -> Ok x | Error x -> Error (v5282 x)
                                                            let _v5283 = v5290 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v5291 : Result<std_path_PathBuf, string> = match v5281 with Ok x -> Ok x | Error x -> Error (v5282 x)
                                                            let _v5283 = v5291 
                                                            #endif
#else
                                                            let v5292 : Result<std_path_PathBuf, string> = match v5281 with Ok x -> Ok x | Error x -> Error (v5282 x)
                                                            let _v5283 = v5292 
                                                            #endif
                                                            let v5293 : Result<std_path_PathBuf, string> = _v5283 
                                                            let v5296 : US8 = match v5293 with Ok x -> v2970 x | Error x -> v2971 x
                                                            match v5296 with
                                                            | US8_1(v5399) -> (* Error *)
                                                                let v5400 : string = $"file_system.read_link / error': {v5399} / error: {v3098} / name: {v3099}"
                                                                let v5401 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v5402 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v5403 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5400 v5402 
                                                                let _v5401 = v5403 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v5404 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v5405 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5400 v5404 
                                                                let _v5401 = v5405 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v5406 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v5407 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5400 v5406 
                                                                let _v5401 = v5407 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v5408 : std_io_Error = v5400 
                                                                let _v5401 = v5408 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v5409 : std_io_Error = v5400 
                                                                let _v5401 = v5409 
                                                                #endif
#else
                                                                let v5410 : std_io_Error = v5400 
                                                                let _v5401 = v5410 
                                                                #endif
                                                                let v5411 : std_io_Error = _v5401 
                                                                let v5414 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v5415 : string = "Err($0)"
                                                                let v5416 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5411 v5415 
                                                                let _v5414 = v5416 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v5417 : string = "Err($0)"
                                                                let v5418 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5411 v5417 
                                                                let _v5414 = v5418 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v5419 : string = "Err($0)"
                                                                let v5420 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5411 v5419 
                                                                let _v5414 = v5420 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v5421 : Result<std_path_PathBuf, std_io_Error> = v5411 |> Error
                                                                let _v5414 = v5421 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v5422 : Result<std_path_PathBuf, std_io_Error> = v5411 |> Error
                                                                let _v5414 = v5422 
                                                                #endif
#else
                                                                let v5423 : Result<std_path_PathBuf, std_io_Error> = v5411 |> Error
                                                                let _v5414 = v5423 
                                                                #endif
                                                                let v5424 : Result<std_path_PathBuf, std_io_Error> = _v5414 
                                                                v5424
                                                            | US8_0(v5297) -> (* Ok *)
                                                                let v5298 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v5299 : string = "$0.display()"
                                                                let v5300 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5297 v5299 
                                                                let _v5298 = v5300 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v5301 : string = "$0.display()"
                                                                let v5302 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5297 v5301 
                                                                let _v5298 = v5302 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v5303 : string = "$0.display()"
                                                                let v5304 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5297 v5303 
                                                                let _v5298 = v5304 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v5305 : std_path_Display = v5297 |> unbox<std_path_Display>
                                                                let _v5298 = v5305 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v5308 : std_path_Display = v5297 |> unbox<std_path_Display>
                                                                let _v5298 = v5308 
                                                                #endif
#else
                                                                let v5311 : std_path_Display = v5297 |> unbox<std_path_Display>
                                                                let _v5298 = v5311 
                                                                #endif
                                                                let v5314 : std_path_Display = _v5298 
                                                                let v5319 : string = v5314 |> string 
                                                                let v5322 : string = method26(v5319, v3099)
                                                                let v5323 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v5324 : string = "&*$0"
                                                                let v5325 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5322 v5324 
                                                                let _v5323 = v5325 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v5326 : string = "&*$0"
                                                                let v5327 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5322 v5326 
                                                                let _v5323 = v5327 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v5328 : string = "&*$0"
                                                                let v5329 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5322 v5328 
                                                                let _v5323 = v5329 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v5330 : Ref<Str> = v5322 |> unbox<Ref<Str>>
                                                                let _v5323 = v5330 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v5333 : Ref<Str> = v5322 |> unbox<Ref<Str>>
                                                                let _v5323 = v5333 
                                                                #endif
#else
                                                                let v5336 : Ref<Str> = v5322 |> unbox<Ref<Str>>
                                                                let _v5323 = v5336 
                                                                #endif
                                                                let v5339 : Ref<Str> = _v5323 
                                                                let v5344 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v5345 : string = "String::from($0)"
                                                                let v5346 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5339 v5345 
                                                                let _v5344 = v5346 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v5347 : string = "String::from($0)"
                                                                let v5348 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5339 v5347 
                                                                let _v5344 = v5348 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v5349 : string = "String::from($0)"
                                                                let v5350 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5339 v5349 
                                                                let _v5344 = v5350 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v5351 : std_string_String = v5339 |> unbox<std_string_String>
                                                                let _v5344 = v5351 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v5354 : std_string_String = v5339 |> unbox<std_string_String>
                                                                let _v5344 = v5354 
                                                                #endif
#else
                                                                let v5357 : std_string_String = v5339 |> unbox<std_string_String>
                                                                let _v5344 = v5357 
                                                                #endif
                                                                let v5360 : std_string_String = _v5344 
                                                                let v5365 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v5366 : string = "std::path::PathBuf::from($0)"
                                                                let v5367 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5360 v5366 
                                                                let _v5365 = v5367 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v5368 : string = "std::path::PathBuf::from($0)"
                                                                let v5369 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5360 v5368 
                                                                let _v5365 = v5369 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v5370 : string = "std::path::PathBuf::from($0)"
                                                                let v5371 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5360 v5370 
                                                                let _v5365 = v5371 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v5372 : std_path_PathBuf = v5360 |> std_path_PathBuf 
                                                                let _v5365 = v5372 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v5375 : std_path_PathBuf = v5360 |> std_path_PathBuf 
                                                                let _v5365 = v5375 
                                                                #endif
#else
                                                                let v5378 : std_path_PathBuf = v5360 |> std_path_PathBuf 
                                                                let _v5365 = v5378 
                                                                #endif
                                                                let v5381 : std_path_PathBuf = _v5365 
                                                                let v5386 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v5387 : string = "Ok($0)"
                                                                let v5388 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5381 v5387 
                                                                let _v5386 = v5388 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v5389 : string = "Ok($0)"
                                                                let v5390 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5381 v5389 
                                                                let _v5386 = v5390 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v5391 : string = "Ok($0)"
                                                                let v5392 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5381 v5391 
                                                                let _v5386 = v5392 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v5393 : Result<std_path_PathBuf, std_io_Error> = v5381 |> Ok
                                                                let _v5386 = v5393 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v5394 : Result<std_path_PathBuf, std_io_Error> = v5381 |> Ok
                                                                let _v5386 = v5394 
                                                                #endif
#else
                                                                let v5395 : Result<std_path_PathBuf, std_io_Error> = v5381 |> Ok
                                                                let _v5386 = v5395 
                                                                #endif
                                                                let v5396 : Result<std_path_PathBuf, std_io_Error> = _v5386 
                                                                v5396
                                                        else
                                                            let v5429 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3098} / path': {v3063} / name: {v3099}"
                                                            let v5430 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v5431 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v5432 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5429 v5431 
                                                            let _v5430 = v5432 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v5433 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v5434 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5429 v5433 
                                                            let _v5430 = v5434 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v5435 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v5436 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5429 v5435 
                                                            let _v5430 = v5436 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v5437 : std_io_Error = v5429 
                                                            let _v5430 = v5437 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v5438 : std_io_Error = v5429 
                                                            let _v5430 = v5438 
                                                            #endif
#else
                                                            let v5439 : std_io_Error = v5429 
                                                            let _v5430 = v5439 
                                                            #endif
                                                            let v5440 : std_io_Error = _v5430 
                                                            let v5443 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v5444 : string = "Err($0)"
                                                            let v5445 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5440 v5444 
                                                            let _v5443 = v5445 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v5446 : string = "Err($0)"
                                                            let v5447 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5440 v5446 
                                                            let _v5443 = v5447 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v5448 : string = "Err($0)"
                                                            let v5449 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5440 v5448 
                                                            let _v5443 = v5449 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v5450 : Result<std_path_PathBuf, std_io_Error> = v5440 |> Error
                                                            let _v5443 = v5450 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v5451 : Result<std_path_PathBuf, std_io_Error> = v5440 |> Error
                                                            let _v5443 = v5451 
                                                            #endif
#else
                                                            let v5452 : Result<std_path_PathBuf, std_io_Error> = v5440 |> Error
                                                            let _v5443 = v5452 
                                                            #endif
                                                            let v5453 : Result<std_path_PathBuf, std_io_Error> = _v5443 
                                                            v5453
                                                    | _ ->
                                                        let v5457 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3098} / path': {v3063} / name: {v3099}"
                                                        let v5458 : unit = ()
                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                        let v5459 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                        let v5460 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5457 v5459 
                                                        let _v5458 = v5460 
                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                        let v5461 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                        let v5462 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5457 v5461 
                                                        let _v5458 = v5462 
                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                        let v5463 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                        let v5464 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5457 v5463 
                                                        let _v5458 = v5464 
                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                        let v5465 : std_io_Error = v5457 
                                                        let _v5458 = v5465 
                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                        let v5466 : std_io_Error = v5457 
                                                        let _v5458 = v5466 
                                                        #endif
#else
                                                        let v5467 : std_io_Error = v5457 
                                                        let _v5458 = v5467 
                                                        #endif
                                                        let v5468 : std_io_Error = _v5458 
                                                        let v5471 : unit = ()
                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                        let v5472 : string = "Err($0)"
                                                        let v5473 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5468 v5472 
                                                        let _v5471 = v5473 
                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                        let v5474 : string = "Err($0)"
                                                        let v5475 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5468 v5474 
                                                        let _v5471 = v5475 
                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                        let v5476 : string = "Err($0)"
                                                        let v5477 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5468 v5476 
                                                        let _v5471 = v5477 
                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                        let v5478 : Result<std_path_PathBuf, std_io_Error> = v5468 |> Error
                                                        let _v5471 = v5478 
                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                        let v5479 : Result<std_path_PathBuf, std_io_Error> = v5468 |> Error
                                                        let _v5471 = v5479 
                                                        #endif
#else
                                                        let v5480 : Result<std_path_PathBuf, std_io_Error> = v5468 |> Error
                                                        let _v5471 = v5480 
                                                        #endif
                                                        let v5481 : Result<std_path_PathBuf, std_io_Error> = _v5471 
                                                        v5481
                                                | US8_0(v3084) -> (* Ok *)
                                                    let v3085 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v3086 : string = "Ok($0)"
                                                    let v3087 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3084 v3086 
                                                    let _v3085 = v3087 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v3088 : string = "Ok($0)"
                                                    let v3089 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3084 v3088 
                                                    let _v3085 = v3089 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v3090 : string = "Ok($0)"
                                                    let v3091 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3084 v3090 
                                                    let _v3085 = v3091 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v3092 : Result<std_path_PathBuf, std_io_Error> = v3084 |> Ok
                                                    let _v3085 = v3092 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v3093 : Result<std_path_PathBuf, std_io_Error> = v3084 |> Ok
                                                    let _v3085 = v3093 
                                                    #endif
#else
                                                    let v3094 : Result<std_path_PathBuf, std_io_Error> = v3084 |> Ok
                                                    let _v3085 = v3094 
                                                    #endif
                                                    let v3095 : Result<std_path_PathBuf, std_io_Error> = _v3085 
                                                    v3095
                                            let v5487 : (std_io_Error -> string) = method41()
                                            let v5488 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v5489 : string = "$0.map_err(|x| $1(x))"
                                            let v5490 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5486, v5487) v5489 
                                            let _v5488 = v5490 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v5491 : string = "$0.map_err(|x| $1(x))"
                                            let v5492 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5486, v5487) v5491 
                                            let _v5488 = v5492 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v5493 : string = "$0.map_err(|x| $1(x))"
                                            let v5494 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5486, v5487) v5493 
                                            let _v5488 = v5494 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v5495 : Result<std_path_PathBuf, string> = match v5486 with Ok x -> Ok x | Error x -> Error (v5487 x)
                                            let _v5488 = v5495 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v5496 : Result<std_path_PathBuf, string> = match v5486 with Ok x -> Ok x | Error x -> Error (v5487 x)
                                            let _v5488 = v5496 
                                            #endif
#else
                                            let v5497 : Result<std_path_PathBuf, string> = match v5486 with Ok x -> Ok x | Error x -> Error (v5487 x)
                                            let _v5488 = v5497 
                                            #endif
                                            let v5498 : Result<std_path_PathBuf, string> = _v5488 
                                            let v5501 : US8 = match v5498 with Ok x -> v2970 x | Error x -> v2971 x
                                            match v5501 with
                                            | US8_1(v5604) -> (* Error *)
                                                let v5605 : string = $"file_system.read_link / error': {v5604} / error: {v3043} / name: {v3044}"
                                                let v5606 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v5607 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v5608 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5605 v5607 
                                                let _v5606 = v5608 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v5609 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v5610 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5605 v5609 
                                                let _v5606 = v5610 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v5611 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v5612 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5605 v5611 
                                                let _v5606 = v5612 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v5613 : std_io_Error = v5605 
                                                let _v5606 = v5613 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v5614 : std_io_Error = v5605 
                                                let _v5606 = v5614 
                                                #endif
#else
                                                let v5615 : std_io_Error = v5605 
                                                let _v5606 = v5615 
                                                #endif
                                                let v5616 : std_io_Error = _v5606 
                                                let v5619 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v5620 : string = "Err($0)"
                                                let v5621 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5616 v5620 
                                                let _v5619 = v5621 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v5622 : string = "Err($0)"
                                                let v5623 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5616 v5622 
                                                let _v5619 = v5623 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v5624 : string = "Err($0)"
                                                let v5625 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5616 v5624 
                                                let _v5619 = v5625 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v5626 : Result<std_path_PathBuf, std_io_Error> = v5616 |> Error
                                                let _v5619 = v5626 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v5627 : Result<std_path_PathBuf, std_io_Error> = v5616 |> Error
                                                let _v5619 = v5627 
                                                #endif
#else
                                                let v5628 : Result<std_path_PathBuf, std_io_Error> = v5616 |> Error
                                                let _v5619 = v5628 
                                                #endif
                                                let v5629 : Result<std_path_PathBuf, std_io_Error> = _v5619 
                                                v5629
                                            | US8_0(v5502) -> (* Ok *)
                                                let v5503 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v5504 : string = "$0.display()"
                                                let v5505 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5502 v5504 
                                                let _v5503 = v5505 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v5506 : string = "$0.display()"
                                                let v5507 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5502 v5506 
                                                let _v5503 = v5507 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v5508 : string = "$0.display()"
                                                let v5509 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5502 v5508 
                                                let _v5503 = v5509 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v5510 : std_path_Display = v5502 |> unbox<std_path_Display>
                                                let _v5503 = v5510 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v5513 : std_path_Display = v5502 |> unbox<std_path_Display>
                                                let _v5503 = v5513 
                                                #endif
#else
                                                let v5516 : std_path_Display = v5502 |> unbox<std_path_Display>
                                                let _v5503 = v5516 
                                                #endif
                                                let v5519 : std_path_Display = _v5503 
                                                let v5524 : string = v5519 |> string 
                                                let v5527 : string = method26(v5524, v3044)
                                                let v5528 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v5529 : string = "&*$0"
                                                let v5530 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5527 v5529 
                                                let _v5528 = v5530 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v5531 : string = "&*$0"
                                                let v5532 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5527 v5531 
                                                let _v5528 = v5532 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v5533 : string = "&*$0"
                                                let v5534 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5527 v5533 
                                                let _v5528 = v5534 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v5535 : Ref<Str> = v5527 |> unbox<Ref<Str>>
                                                let _v5528 = v5535 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v5538 : Ref<Str> = v5527 |> unbox<Ref<Str>>
                                                let _v5528 = v5538 
                                                #endif
#else
                                                let v5541 : Ref<Str> = v5527 |> unbox<Ref<Str>>
                                                let _v5528 = v5541 
                                                #endif
                                                let v5544 : Ref<Str> = _v5528 
                                                let v5549 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v5550 : string = "String::from($0)"
                                                let v5551 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5544 v5550 
                                                let _v5549 = v5551 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v5552 : string = "String::from($0)"
                                                let v5553 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5544 v5552 
                                                let _v5549 = v5553 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v5554 : string = "String::from($0)"
                                                let v5555 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5544 v5554 
                                                let _v5549 = v5555 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v5556 : std_string_String = v5544 |> unbox<std_string_String>
                                                let _v5549 = v5556 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v5559 : std_string_String = v5544 |> unbox<std_string_String>
                                                let _v5549 = v5559 
                                                #endif
#else
                                                let v5562 : std_string_String = v5544 |> unbox<std_string_String>
                                                let _v5549 = v5562 
                                                #endif
                                                let v5565 : std_string_String = _v5549 
                                                let v5570 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v5571 : string = "std::path::PathBuf::from($0)"
                                                let v5572 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5565 v5571 
                                                let _v5570 = v5572 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v5573 : string = "std::path::PathBuf::from($0)"
                                                let v5574 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5565 v5573 
                                                let _v5570 = v5574 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v5575 : string = "std::path::PathBuf::from($0)"
                                                let v5576 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5565 v5575 
                                                let _v5570 = v5576 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v5577 : std_path_PathBuf = v5565 |> std_path_PathBuf 
                                                let _v5570 = v5577 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v5580 : std_path_PathBuf = v5565 |> std_path_PathBuf 
                                                let _v5570 = v5580 
                                                #endif
#else
                                                let v5583 : std_path_PathBuf = v5565 |> std_path_PathBuf 
                                                let _v5570 = v5583 
                                                #endif
                                                let v5586 : std_path_PathBuf = _v5570 
                                                let v5591 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v5592 : string = "Ok($0)"
                                                let v5593 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5586 v5592 
                                                let _v5591 = v5593 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v5594 : string = "Ok($0)"
                                                let v5595 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5586 v5594 
                                                let _v5591 = v5595 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v5596 : string = "Ok($0)"
                                                let v5597 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5586 v5596 
                                                let _v5591 = v5597 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v5598 : Result<std_path_PathBuf, std_io_Error> = v5586 |> Ok
                                                let _v5591 = v5598 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v5599 : Result<std_path_PathBuf, std_io_Error> = v5586 |> Ok
                                                let _v5591 = v5599 
                                                #endif
#else
                                                let v5600 : Result<std_path_PathBuf, std_io_Error> = v5586 |> Ok
                                                let _v5591 = v5600 
                                                #endif
                                                let v5601 : Result<std_path_PathBuf, std_io_Error> = _v5591 
                                                v5601
                                        else
                                            let v5634 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3043} / path': {v3007} / name: {v3044}"
                                            let v5635 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v5636 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v5637 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5634 v5636 
                                            let _v5635 = v5637 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v5638 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v5639 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5634 v5638 
                                            let _v5635 = v5639 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v5640 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v5641 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5634 v5640 
                                            let _v5635 = v5641 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v5642 : std_io_Error = v5634 
                                            let _v5635 = v5642 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v5643 : std_io_Error = v5634 
                                            let _v5635 = v5643 
                                            #endif
#else
                                            let v5644 : std_io_Error = v5634 
                                            let _v5635 = v5644 
                                            #endif
                                            let v5645 : std_io_Error = _v5635 
                                            let v5648 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v5649 : string = "Err($0)"
                                            let v5650 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5645 v5649 
                                            let _v5648 = v5650 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v5651 : string = "Err($0)"
                                            let v5652 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5645 v5651 
                                            let _v5648 = v5652 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v5653 : string = "Err($0)"
                                            let v5654 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5645 v5653 
                                            let _v5648 = v5654 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v5655 : Result<std_path_PathBuf, std_io_Error> = v5645 |> Error
                                            let _v5648 = v5655 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v5656 : Result<std_path_PathBuf, std_io_Error> = v5645 |> Error
                                            let _v5648 = v5656 
                                            #endif
#else
                                            let v5657 : Result<std_path_PathBuf, std_io_Error> = v5645 |> Error
                                            let _v5648 = v5657 
                                            #endif
                                            let v5658 : Result<std_path_PathBuf, std_io_Error> = _v5648 
                                            v5658
                                    | _ ->
                                        let v5662 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v3043} / path': {v3007} / name: {v3044}"
                                        let v5663 : unit = ()
                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                        let v5664 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                        let v5665 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5662 v5664 
                                        let _v5663 = v5665 
                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                        let v5666 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                        let v5667 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5662 v5666 
                                        let _v5663 = v5667 
                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                        let v5668 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                        let v5669 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5662 v5668 
                                        let _v5663 = v5669 
                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                        let v5670 : std_io_Error = v5662 
                                        let _v5663 = v5670 
                                        #endif
#if FABLE_COMPILER_PYTHON
                                        let v5671 : std_io_Error = v5662 
                                        let _v5663 = v5671 
                                        #endif
#else
                                        let v5672 : std_io_Error = v5662 
                                        let _v5663 = v5672 
                                        #endif
                                        let v5673 : std_io_Error = _v5663 
                                        let v5676 : unit = ()
                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                        let v5677 : string = "Err($0)"
                                        let v5678 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5673 v5677 
                                        let _v5676 = v5678 
                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                        let v5679 : string = "Err($0)"
                                        let v5680 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5673 v5679 
                                        let _v5676 = v5680 
                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                        let v5681 : string = "Err($0)"
                                        let v5682 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5673 v5681 
                                        let _v5676 = v5682 
                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                        let v5683 : Result<std_path_PathBuf, std_io_Error> = v5673 |> Error
                                        let _v5676 = v5683 
                                        #endif
#if FABLE_COMPILER_PYTHON
                                        let v5684 : Result<std_path_PathBuf, std_io_Error> = v5673 |> Error
                                        let _v5676 = v5684 
                                        #endif
#else
                                        let v5685 : Result<std_path_PathBuf, std_io_Error> = v5673 |> Error
                                        let _v5676 = v5685 
                                        #endif
                                        let v5686 : Result<std_path_PathBuf, std_io_Error> = _v5676 
                                        v5686
                                | US8_0(v3029) -> (* Ok *)
                                    let v3030 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v3031 : string = "Ok($0)"
                                    let v3032 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3029 v3031 
                                    let _v3030 = v3032 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v3033 : string = "Ok($0)"
                                    let v3034 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3029 v3033 
                                    let _v3030 = v3034 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v3035 : string = "Ok($0)"
                                    let v3036 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3029 v3035 
                                    let _v3030 = v3036 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v3037 : Result<std_path_PathBuf, std_io_Error> = v3029 |> Ok
                                    let _v3030 = v3037 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v3038 : Result<std_path_PathBuf, std_io_Error> = v3029 |> Ok
                                    let _v3030 = v3038 
                                    #endif
#else
                                    let v3039 : Result<std_path_PathBuf, std_io_Error> = v3029 |> Ok
                                    let _v3030 = v3039 
                                    #endif
                                    let v3040 : Result<std_path_PathBuf, std_io_Error> = _v3030 
                                    v3040
                            let v5692 : (std_io_Error -> string) = method41()
                            let v5693 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v5694 : string = "$0.map_err(|x| $1(x))"
                            let v5695 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5691, v5692) v5694 
                            let _v5693 = v5695 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v5696 : string = "$0.map_err(|x| $1(x))"
                            let v5697 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5691, v5692) v5696 
                            let _v5693 = v5697 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v5698 : string = "$0.map_err(|x| $1(x))"
                            let v5699 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5691, v5692) v5698 
                            let _v5693 = v5699 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v5700 : Result<std_path_PathBuf, string> = match v5691 with Ok x -> Ok x | Error x -> Error (v5692 x)
                            let _v5693 = v5700 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v5701 : Result<std_path_PathBuf, string> = match v5691 with Ok x -> Ok x | Error x -> Error (v5692 x)
                            let _v5693 = v5701 
                            #endif
#else
                            let v5702 : Result<std_path_PathBuf, string> = match v5691 with Ok x -> Ok x | Error x -> Error (v5692 x)
                            let _v5693 = v5702 
                            #endif
                            let v5703 : Result<std_path_PathBuf, string> = _v5693 
                            let v5706 : US8 = match v5703 with Ok x -> v2970 x | Error x -> v2971 x
                            match v5706 with
                            | US8_1(v5809) -> (* Error *)
                                let v5810 : string = $"file_system.read_link / error': {v5809} / error: {v2987} / name: {v2988}"
                                let v5811 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v5812 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v5813 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5810 v5812 
                                let _v5811 = v5813 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v5814 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v5815 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5810 v5814 
                                let _v5811 = v5815 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v5816 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v5817 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5810 v5816 
                                let _v5811 = v5817 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v5818 : std_io_Error = v5810 
                                let _v5811 = v5818 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v5819 : std_io_Error = v5810 
                                let _v5811 = v5819 
                                #endif
#else
                                let v5820 : std_io_Error = v5810 
                                let _v5811 = v5820 
                                #endif
                                let v5821 : std_io_Error = _v5811 
                                let v5824 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v5825 : string = "Err($0)"
                                let v5826 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5821 v5825 
                                let _v5824 = v5826 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v5827 : string = "Err($0)"
                                let v5828 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5821 v5827 
                                let _v5824 = v5828 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v5829 : string = "Err($0)"
                                let v5830 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5821 v5829 
                                let _v5824 = v5830 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v5831 : Result<std_path_PathBuf, std_io_Error> = v5821 |> Error
                                let _v5824 = v5831 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v5832 : Result<std_path_PathBuf, std_io_Error> = v5821 |> Error
                                let _v5824 = v5832 
                                #endif
#else
                                let v5833 : Result<std_path_PathBuf, std_io_Error> = v5821 |> Error
                                let _v5824 = v5833 
                                #endif
                                let v5834 : Result<std_path_PathBuf, std_io_Error> = _v5824 
                                v5834
                            | US8_0(v5707) -> (* Ok *)
                                let v5708 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v5709 : string = "$0.display()"
                                let v5710 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5707 v5709 
                                let _v5708 = v5710 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v5711 : string = "$0.display()"
                                let v5712 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5707 v5711 
                                let _v5708 = v5712 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v5713 : string = "$0.display()"
                                let v5714 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5707 v5713 
                                let _v5708 = v5714 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v5715 : std_path_Display = v5707 |> unbox<std_path_Display>
                                let _v5708 = v5715 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v5718 : std_path_Display = v5707 |> unbox<std_path_Display>
                                let _v5708 = v5718 
                                #endif
#else
                                let v5721 : std_path_Display = v5707 |> unbox<std_path_Display>
                                let _v5708 = v5721 
                                #endif
                                let v5724 : std_path_Display = _v5708 
                                let v5729 : string = v5724 |> string 
                                let v5732 : string = method26(v5729, v2988)
                                let v5733 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v5734 : string = "&*$0"
                                let v5735 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5732 v5734 
                                let _v5733 = v5735 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v5736 : string = "&*$0"
                                let v5737 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5732 v5736 
                                let _v5733 = v5737 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v5738 : string = "&*$0"
                                let v5739 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5732 v5738 
                                let _v5733 = v5739 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v5740 : Ref<Str> = v5732 |> unbox<Ref<Str>>
                                let _v5733 = v5740 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v5743 : Ref<Str> = v5732 |> unbox<Ref<Str>>
                                let _v5733 = v5743 
                                #endif
#else
                                let v5746 : Ref<Str> = v5732 |> unbox<Ref<Str>>
                                let _v5733 = v5746 
                                #endif
                                let v5749 : Ref<Str> = _v5733 
                                let v5754 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v5755 : string = "String::from($0)"
                                let v5756 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5749 v5755 
                                let _v5754 = v5756 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v5757 : string = "String::from($0)"
                                let v5758 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5749 v5757 
                                let _v5754 = v5758 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v5759 : string = "String::from($0)"
                                let v5760 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5749 v5759 
                                let _v5754 = v5760 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v5761 : std_string_String = v5749 |> unbox<std_string_String>
                                let _v5754 = v5761 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v5764 : std_string_String = v5749 |> unbox<std_string_String>
                                let _v5754 = v5764 
                                #endif
#else
                                let v5767 : std_string_String = v5749 |> unbox<std_string_String>
                                let _v5754 = v5767 
                                #endif
                                let v5770 : std_string_String = _v5754 
                                let v5775 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v5776 : string = "std::path::PathBuf::from($0)"
                                let v5777 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5770 v5776 
                                let _v5775 = v5777 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v5778 : string = "std::path::PathBuf::from($0)"
                                let v5779 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5770 v5778 
                                let _v5775 = v5779 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v5780 : string = "std::path::PathBuf::from($0)"
                                let v5781 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5770 v5780 
                                let _v5775 = v5781 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v5782 : std_path_PathBuf = v5770 |> std_path_PathBuf 
                                let _v5775 = v5782 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v5785 : std_path_PathBuf = v5770 |> std_path_PathBuf 
                                let _v5775 = v5785 
                                #endif
#else
                                let v5788 : std_path_PathBuf = v5770 |> std_path_PathBuf 
                                let _v5775 = v5788 
                                #endif
                                let v5791 : std_path_PathBuf = _v5775 
                                let v5796 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v5797 : string = "Ok($0)"
                                let v5798 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5791 v5797 
                                let _v5796 = v5798 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v5799 : string = "Ok($0)"
                                let v5800 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5791 v5799 
                                let _v5796 = v5800 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v5801 : string = "Ok($0)"
                                let v5802 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5791 v5801 
                                let _v5796 = v5802 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v5803 : Result<std_path_PathBuf, std_io_Error> = v5791 |> Ok
                                let _v5796 = v5803 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v5804 : Result<std_path_PathBuf, std_io_Error> = v5791 |> Ok
                                let _v5796 = v5804 
                                #endif
#else
                                let v5805 : Result<std_path_PathBuf, std_io_Error> = v5791 |> Ok
                                let _v5796 = v5805 
                                #endif
                                let v5806 : Result<std_path_PathBuf, std_io_Error> = _v5796 
                                v5806
                        else
                            let v5839 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v2987} / path': {v0} / name: {v2988}"
                            let v5840 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v5841 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v5842 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5839 v5841 
                            let _v5840 = v5842 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v5843 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v5844 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5839 v5843 
                            let _v5840 = v5844 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v5845 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v5846 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5839 v5845 
                            let _v5840 = v5846 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v5847 : std_io_Error = v5839 
                            let _v5840 = v5847 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v5848 : std_io_Error = v5839 
                            let _v5840 = v5848 
                            #endif
#else
                            let v5849 : std_io_Error = v5839 
                            let _v5840 = v5849 
                            #endif
                            let v5850 : std_io_Error = _v5840 
                            let v5853 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v5854 : string = "Err($0)"
                            let v5855 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5850 v5854 
                            let _v5853 = v5855 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v5856 : string = "Err($0)"
                            let v5857 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5850 v5856 
                            let _v5853 = v5857 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v5858 : string = "Err($0)"
                            let v5859 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5850 v5858 
                            let _v5853 = v5859 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v5860 : Result<std_path_PathBuf, std_io_Error> = v5850 |> Error
                            let _v5853 = v5860 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v5861 : Result<std_path_PathBuf, std_io_Error> = v5850 |> Error
                            let _v5853 = v5861 
                            #endif
#else
                            let v5862 : Result<std_path_PathBuf, std_io_Error> = v5850 |> Error
                            let _v5853 = v5862 
                            #endif
                            let v5863 : Result<std_path_PathBuf, std_io_Error> = _v5853 
                            v5863
                    | _ ->
                        let v5867 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v2987} / path': {v0} / name: {v2988}"
                        let v5868 : unit = ()
                        
#if FABLE_COMPILER || WASM || CONTRACT
                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                        let v5869 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                        let v5870 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5867 v5869 
                        let _v5868 = v5870 
                        #endif
#if FABLE_COMPILER_RUST && WASM
                        let v5871 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                        let v5872 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5867 v5871 
                        let _v5868 = v5872 
                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                        let v5873 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                        let v5874 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5867 v5873 
                        let _v5868 = v5874 
                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                        let v5875 : std_io_Error = v5867 
                        let _v5868 = v5875 
                        #endif
#if FABLE_COMPILER_PYTHON
                        let v5876 : std_io_Error = v5867 
                        let _v5868 = v5876 
                        #endif
#else
                        let v5877 : std_io_Error = v5867 
                        let _v5868 = v5877 
                        #endif
                        let v5878 : std_io_Error = _v5868 
                        let v5881 : unit = ()
                        
#if FABLE_COMPILER || WASM || CONTRACT
                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                        let v5882 : string = "Err($0)"
                        let v5883 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5878 v5882 
                        let _v5881 = v5883 
                        #endif
#if FABLE_COMPILER_RUST && WASM
                        let v5884 : string = "Err($0)"
                        let v5885 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5878 v5884 
                        let _v5881 = v5885 
                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                        let v5886 : string = "Err($0)"
                        let v5887 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5878 v5886 
                        let _v5881 = v5887 
                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                        let v5888 : Result<std_path_PathBuf, std_io_Error> = v5878 |> Error
                        let _v5881 = v5888 
                        #endif
#if FABLE_COMPILER_PYTHON
                        let v5889 : Result<std_path_PathBuf, std_io_Error> = v5878 |> Error
                        let _v5881 = v5889 
                        #endif
#else
                        let v5890 : Result<std_path_PathBuf, std_io_Error> = v5878 |> Error
                        let _v5881 = v5890 
                        #endif
                        let v5891 : Result<std_path_PathBuf, std_io_Error> = _v5881 
                        v5891
                | US8_0(v2973) -> (* Ok *)
                    let v2974 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v2975 : string = "Ok($0)"
                    let v2976 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2973 v2975 
                    let _v2974 = v2976 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v2977 : string = "Ok($0)"
                    let v2978 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2973 v2977 
                    let _v2974 = v2978 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v2979 : string = "Ok($0)"
                    let v2980 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2973 v2979 
                    let _v2974 = v2980 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v2981 : Result<std_path_PathBuf, std_io_Error> = v2973 |> Ok
                    let _v2974 = v2981 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v2982 : Result<std_path_PathBuf, std_io_Error> = v2973 |> Ok
                    let _v2974 = v2982 
                    #endif
#else
                    let v2983 : Result<std_path_PathBuf, std_io_Error> = v2973 |> Ok
                    let _v2974 = v2983 
                    #endif
                    let v2984 : Result<std_path_PathBuf, std_io_Error> = _v2974 
                    v2984
        let _v3 = v5897 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v5898 : bool = method30(v0)
        let v8844 : Result<std_path_PathBuf, std_io_Error> =
            if v5898 then
                let v5899 : string = "std::fs::read_link(&*$0)"
                let v5900 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v0 v5899 
                v5900
            else
                let v5901 : string = "std::fs::read_link(&*$0)"
                let v5902 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v0 v5901 
                let v5903 : (std_io_Error -> string) = method41()
                let v5904 : unit = ()
                
#if FABLE_COMPILER || WASM || CONTRACT
                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                let v5905 : string = "$0.map_err(|x| $1(x))"
                let v5906 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5902, v5903) v5905 
                let _v5904 = v5906 
                #endif
#if FABLE_COMPILER_RUST && WASM
                let v5907 : string = "$0.map_err(|x| $1(x))"
                let v5908 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5902, v5903) v5907 
                let _v5904 = v5908 
                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                let v5909 : string = "$0.map_err(|x| $1(x))"
                let v5910 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5902, v5903) v5909 
                let _v5904 = v5910 
                #endif
#if FABLE_COMPILER_TYPESCRIPT
                let v5911 : Result<std_path_PathBuf, string> = match v5902 with Ok x -> Ok x | Error x -> Error (v5903 x)
                let _v5904 = v5911 
                #endif
#if FABLE_COMPILER_PYTHON
                let v5912 : Result<std_path_PathBuf, string> = match v5902 with Ok x -> Ok x | Error x -> Error (v5903 x)
                let _v5904 = v5912 
                #endif
#else
                let v5913 : Result<std_path_PathBuf, string> = match v5902 with Ok x -> Ok x | Error x -> Error (v5903 x)
                let _v5904 = v5913 
                #endif
                let v5914 : Result<std_path_PathBuf, string> = _v5904 
                let v5917 : (std_path_PathBuf -> US8) = closure16()
                let v5918 : (string -> US8) = closure17()
                let v5919 : US8 = match v5914 with Ok x -> v5917 x | Error x -> v5918 x
                match v5919 with
                | US8_1(v5934) -> (* Error *)
                    let v5935 : string = method43(v0)
                    let v5936 : string option = method32(v0)
                    let v5937 : (string -> US1) = method5()
                    let v5938 : US1 option = v5936 |> Option.map v5937 
                    let v5949 : US1 = US1_1
                    let v5950 : US1 = v5938 |> Option.defaultValue v5949 
                    match v5950 with
                    | US1_0(v5954) -> (* Some *)
                        let v5955 : string = ""
                        let v5956 : bool = v0 <> v5955 
                        if v5956 then
                            let v5959 : string = "std::fs::read_link(&*$0)"
                            let v5960 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5954 v5959 
                            let v5961 : (std_io_Error -> string) = method41()
                            let v5962 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v5963 : string = "$0.map_err(|x| $1(x))"
                            let v5964 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5960, v5961) v5963 
                            let _v5962 = v5964 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v5965 : string = "$0.map_err(|x| $1(x))"
                            let v5966 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5960, v5961) v5965 
                            let _v5962 = v5966 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v5967 : string = "$0.map_err(|x| $1(x))"
                            let v5968 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5960, v5961) v5967 
                            let _v5962 = v5968 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v5969 : Result<std_path_PathBuf, string> = match v5960 with Ok x -> Ok x | Error x -> Error (v5961 x)
                            let _v5962 = v5969 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v5970 : Result<std_path_PathBuf, string> = match v5960 with Ok x -> Ok x | Error x -> Error (v5961 x)
                            let _v5962 = v5970 
                            #endif
#else
                            let v5971 : Result<std_path_PathBuf, string> = match v5960 with Ok x -> Ok x | Error x -> Error (v5961 x)
                            let _v5962 = v5971 
                            #endif
                            let v5972 : Result<std_path_PathBuf, string> = _v5962 
                            let v5975 : US8 = match v5972 with Ok x -> v5917 x | Error x -> v5918 x
                            let v8638 : Result<std_path_PathBuf, std_io_Error> =
                                match v5975 with
                                | US8_1(v5990) -> (* Error *)
                                    let v5991 : string = method43(v5954)
                                    let v5992 : string option = method32(v5954)
                                    let v5993 : (string -> US1) = method5()
                                    let v5994 : US1 option = v5992 |> Option.map v5993 
                                    let v6005 : US1 = US1_1
                                    let v6006 : US1 = v5994 |> Option.defaultValue v6005 
                                    match v6006 with
                                    | US1_0(v6010) -> (* Some *)
                                        let v6011 : bool = v5954 <> v5955 
                                        if v6011 then
                                            let v6014 : string = "std::fs::read_link(&*$0)"
                                            let v6015 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6010 v6014 
                                            let v6016 : (std_io_Error -> string) = method41()
                                            let v6017 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v6018 : string = "$0.map_err(|x| $1(x))"
                                            let v6019 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6015, v6016) v6018 
                                            let _v6017 = v6019 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v6020 : string = "$0.map_err(|x| $1(x))"
                                            let v6021 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6015, v6016) v6020 
                                            let _v6017 = v6021 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v6022 : string = "$0.map_err(|x| $1(x))"
                                            let v6023 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6015, v6016) v6022 
                                            let _v6017 = v6023 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v6024 : Result<std_path_PathBuf, string> = match v6015 with Ok x -> Ok x | Error x -> Error (v6016 x)
                                            let _v6017 = v6024 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v6025 : Result<std_path_PathBuf, string> = match v6015 with Ok x -> Ok x | Error x -> Error (v6016 x)
                                            let _v6017 = v6025 
                                            #endif
#else
                                            let v6026 : Result<std_path_PathBuf, string> = match v6015 with Ok x -> Ok x | Error x -> Error (v6016 x)
                                            let _v6017 = v6026 
                                            #endif
                                            let v6027 : Result<std_path_PathBuf, string> = _v6017 
                                            let v6030 : US8 = match v6027 with Ok x -> v5917 x | Error x -> v5918 x
                                            let v8433 : Result<std_path_PathBuf, std_io_Error> =
                                                match v6030 with
                                                | US8_1(v6045) -> (* Error *)
                                                    let v6046 : string = method43(v6010)
                                                    let v6047 : string option = method32(v6010)
                                                    let v6048 : (string -> US1) = method5()
                                                    let v6049 : US1 option = v6047 |> Option.map v6048 
                                                    let v6060 : US1 = US1_1
                                                    let v6061 : US1 = v6049 |> Option.defaultValue v6060 
                                                    match v6061 with
                                                    | US1_0(v6065) -> (* Some *)
                                                        let v6066 : bool = v6010 <> v5955 
                                                        if v6066 then
                                                            let v6069 : string = "std::fs::read_link(&*$0)"
                                                            let v6070 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6065 v6069 
                                                            let v6071 : (std_io_Error -> string) = method41()
                                                            let v6072 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v6073 : string = "$0.map_err(|x| $1(x))"
                                                            let v6074 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6070, v6071) v6073 
                                                            let _v6072 = v6074 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v6075 : string = "$0.map_err(|x| $1(x))"
                                                            let v6076 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6070, v6071) v6075 
                                                            let _v6072 = v6076 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v6077 : string = "$0.map_err(|x| $1(x))"
                                                            let v6078 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6070, v6071) v6077 
                                                            let _v6072 = v6078 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v6079 : Result<std_path_PathBuf, string> = match v6070 with Ok x -> Ok x | Error x -> Error (v6071 x)
                                                            let _v6072 = v6079 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v6080 : Result<std_path_PathBuf, string> = match v6070 with Ok x -> Ok x | Error x -> Error (v6071 x)
                                                            let _v6072 = v6080 
                                                            #endif
#else
                                                            let v6081 : Result<std_path_PathBuf, string> = match v6070 with Ok x -> Ok x | Error x -> Error (v6071 x)
                                                            let _v6072 = v6081 
                                                            #endif
                                                            let v6082 : Result<std_path_PathBuf, string> = _v6072 
                                                            let v6085 : US8 = match v6082 with Ok x -> v5917 x | Error x -> v5918 x
                                                            let v8228 : Result<std_path_PathBuf, std_io_Error> =
                                                                match v6085 with
                                                                | US8_1(v6100) -> (* Error *)
                                                                    let v6101 : string = method43(v6065)
                                                                    let v6102 : string option = method32(v6065)
                                                                    let v6103 : (string -> US1) = method5()
                                                                    let v6104 : US1 option = v6102 |> Option.map v6103 
                                                                    let v6115 : US1 = US1_1
                                                                    let v6116 : US1 = v6104 |> Option.defaultValue v6115 
                                                                    match v6116 with
                                                                    | US1_0(v6120) -> (* Some *)
                                                                        let v6121 : bool = v6065 <> v5955 
                                                                        if v6121 then
                                                                            let v6124 : string = "std::fs::read_link(&*$0)"
                                                                            let v6125 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6120 v6124 
                                                                            let v6126 : (std_io_Error -> string) = method41()
                                                                            let v6127 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v6128 : string = "$0.map_err(|x| $1(x))"
                                                                            let v6129 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6125, v6126) v6128 
                                                                            let _v6127 = v6129 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v6130 : string = "$0.map_err(|x| $1(x))"
                                                                            let v6131 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6125, v6126) v6130 
                                                                            let _v6127 = v6131 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v6132 : string = "$0.map_err(|x| $1(x))"
                                                                            let v6133 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6125, v6126) v6132 
                                                                            let _v6127 = v6133 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v6134 : Result<std_path_PathBuf, string> = match v6125 with Ok x -> Ok x | Error x -> Error (v6126 x)
                                                                            let _v6127 = v6134 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v6135 : Result<std_path_PathBuf, string> = match v6125 with Ok x -> Ok x | Error x -> Error (v6126 x)
                                                                            let _v6127 = v6135 
                                                                            #endif
#else
                                                                            let v6136 : Result<std_path_PathBuf, string> = match v6125 with Ok x -> Ok x | Error x -> Error (v6126 x)
                                                                            let _v6127 = v6136 
                                                                            #endif
                                                                            let v6137 : Result<std_path_PathBuf, string> = _v6127 
                                                                            let v6140 : US8 = match v6137 with Ok x -> v5917 x | Error x -> v5918 x
                                                                            let v8023 : Result<std_path_PathBuf, std_io_Error> =
                                                                                match v6140 with
                                                                                | US8_1(v6155) -> (* Error *)
                                                                                    let v6156 : string = method43(v6120)
                                                                                    let v6157 : string option = method32(v6120)
                                                                                    let v6158 : (string -> US1) = method5()
                                                                                    let v6159 : US1 option = v6157 |> Option.map v6158 
                                                                                    let v6170 : US1 = US1_1
                                                                                    let v6171 : US1 = v6159 |> Option.defaultValue v6170 
                                                                                    match v6171 with
                                                                                    | US1_0(v6175) -> (* Some *)
                                                                                        let v6176 : bool = v6120 <> v5955 
                                                                                        if v6176 then
                                                                                            let v6179 : string = "std::fs::read_link(&*$0)"
                                                                                            let v6180 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6175 v6179 
                                                                                            let v6181 : (std_io_Error -> string) = method41()
                                                                                            let v6182 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v6183 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v6184 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6180, v6181) v6183 
                                                                                            let _v6182 = v6184 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v6185 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v6186 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6180, v6181) v6185 
                                                                                            let _v6182 = v6186 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v6187 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v6188 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6180, v6181) v6187 
                                                                                            let _v6182 = v6188 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v6189 : Result<std_path_PathBuf, string> = match v6180 with Ok x -> Ok x | Error x -> Error (v6181 x)
                                                                                            let _v6182 = v6189 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v6190 : Result<std_path_PathBuf, string> = match v6180 with Ok x -> Ok x | Error x -> Error (v6181 x)
                                                                                            let _v6182 = v6190 
                                                                                            #endif
#else
                                                                                            let v6191 : Result<std_path_PathBuf, string> = match v6180 with Ok x -> Ok x | Error x -> Error (v6181 x)
                                                                                            let _v6182 = v6191 
                                                                                            #endif
                                                                                            let v6192 : Result<std_path_PathBuf, string> = _v6182 
                                                                                            let v6195 : US8 = match v6192 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                            let v7818 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                match v6195 with
                                                                                                | US8_1(v6210) -> (* Error *)
                                                                                                    let v6211 : string = method43(v6175)
                                                                                                    let v6212 : string option = method32(v6175)
                                                                                                    let v6213 : (string -> US1) = method5()
                                                                                                    let v6214 : US1 option = v6212 |> Option.map v6213 
                                                                                                    let v6225 : US1 = US1_1
                                                                                                    let v6226 : US1 = v6214 |> Option.defaultValue v6225 
                                                                                                    match v6226 with
                                                                                                    | US1_0(v6230) -> (* Some *)
                                                                                                        let v6231 : bool = v6175 <> v5955 
                                                                                                        if v6231 then
                                                                                                            let v6234 : string = "std::fs::read_link(&*$0)"
                                                                                                            let v6235 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6230 v6234 
                                                                                                            let v6236 : (std_io_Error -> string) = method41()
                                                                                                            let v6237 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v6238 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v6239 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6235, v6236) v6238 
                                                                                                            let _v6237 = v6239 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v6240 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v6241 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6235, v6236) v6240 
                                                                                                            let _v6237 = v6241 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v6242 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v6243 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6235, v6236) v6242 
                                                                                                            let _v6237 = v6243 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v6244 : Result<std_path_PathBuf, string> = match v6235 with Ok x -> Ok x | Error x -> Error (v6236 x)
                                                                                                            let _v6237 = v6244 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v6245 : Result<std_path_PathBuf, string> = match v6235 with Ok x -> Ok x | Error x -> Error (v6236 x)
                                                                                                            let _v6237 = v6245 
                                                                                                            #endif
#else
                                                                                                            let v6246 : Result<std_path_PathBuf, string> = match v6235 with Ok x -> Ok x | Error x -> Error (v6236 x)
                                                                                                            let _v6237 = v6246 
                                                                                                            #endif
                                                                                                            let v6247 : Result<std_path_PathBuf, string> = _v6237 
                                                                                                            let v6250 : US8 = match v6247 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                            let v7613 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                match v6250 with
                                                                                                                | US8_1(v6265) -> (* Error *)
                                                                                                                    let v6266 : string = method43(v6230)
                                                                                                                    let v6267 : string option = method32(v6230)
                                                                                                                    let v6268 : (string -> US1) = method5()
                                                                                                                    let v6269 : US1 option = v6267 |> Option.map v6268 
                                                                                                                    let v6280 : US1 = US1_1
                                                                                                                    let v6281 : US1 = v6269 |> Option.defaultValue v6280 
                                                                                                                    match v6281 with
                                                                                                                    | US1_0(v6285) -> (* Some *)
                                                                                                                        let v6286 : bool = v6230 <> v5955 
                                                                                                                        if v6286 then
                                                                                                                            let v6289 : string = "std::fs::read_link(&*$0)"
                                                                                                                            let v6290 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6285 v6289 
                                                                                                                            let v6291 : (std_io_Error -> string) = method41()
                                                                                                                            let v6292 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v6293 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v6294 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6290, v6291) v6293 
                                                                                                                            let _v6292 = v6294 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v6295 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v6296 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6290, v6291) v6295 
                                                                                                                            let _v6292 = v6296 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v6297 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v6298 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6290, v6291) v6297 
                                                                                                                            let _v6292 = v6298 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v6299 : Result<std_path_PathBuf, string> = match v6290 with Ok x -> Ok x | Error x -> Error (v6291 x)
                                                                                                                            let _v6292 = v6299 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v6300 : Result<std_path_PathBuf, string> = match v6290 with Ok x -> Ok x | Error x -> Error (v6291 x)
                                                                                                                            let _v6292 = v6300 
                                                                                                                            #endif
#else
                                                                                                                            let v6301 : Result<std_path_PathBuf, string> = match v6290 with Ok x -> Ok x | Error x -> Error (v6291 x)
                                                                                                                            let _v6292 = v6301 
                                                                                                                            #endif
                                                                                                                            let v6302 : Result<std_path_PathBuf, string> = _v6292 
                                                                                                                            let v6305 : US8 = match v6302 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                            let v7408 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                match v6305 with
                                                                                                                                | US8_1(v6320) -> (* Error *)
                                                                                                                                    let v6321 : string = method43(v6285)
                                                                                                                                    let v6322 : string option = method32(v6285)
                                                                                                                                    let v6323 : (string -> US1) = method5()
                                                                                                                                    let v6324 : US1 option = v6322 |> Option.map v6323 
                                                                                                                                    let v6335 : US1 = US1_1
                                                                                                                                    let v6336 : US1 = v6324 |> Option.defaultValue v6335 
                                                                                                                                    match v6336 with
                                                                                                                                    | US1_0(v6340) -> (* Some *)
                                                                                                                                        let v6341 : bool = v6285 <> v5955 
                                                                                                                                        if v6341 then
                                                                                                                                            let v6344 : string = "std::fs::read_link(&*$0)"
                                                                                                                                            let v6345 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6340 v6344 
                                                                                                                                            let v6346 : (std_io_Error -> string) = method41()
                                                                                                                                            let v6347 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v6348 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v6349 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6345, v6346) v6348 
                                                                                                                                            let _v6347 = v6349 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v6350 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v6351 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6345, v6346) v6350 
                                                                                                                                            let _v6347 = v6351 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v6352 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v6353 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6345, v6346) v6352 
                                                                                                                                            let _v6347 = v6353 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v6354 : Result<std_path_PathBuf, string> = match v6345 with Ok x -> Ok x | Error x -> Error (v6346 x)
                                                                                                                                            let _v6347 = v6354 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v6355 : Result<std_path_PathBuf, string> = match v6345 with Ok x -> Ok x | Error x -> Error (v6346 x)
                                                                                                                                            let _v6347 = v6355 
                                                                                                                                            #endif
#else
                                                                                                                                            let v6356 : Result<std_path_PathBuf, string> = match v6345 with Ok x -> Ok x | Error x -> Error (v6346 x)
                                                                                                                                            let _v6347 = v6356 
                                                                                                                                            #endif
                                                                                                                                            let v6357 : Result<std_path_PathBuf, string> = _v6347 
                                                                                                                                            let v6360 : US8 = match v6357 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                                            let v7203 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                match v6360 with
                                                                                                                                                | US8_1(v6375) -> (* Error *)
                                                                                                                                                    let v6376 : string = method43(v6340)
                                                                                                                                                    let v6377 : string option = method32(v6340)
                                                                                                                                                    let v6378 : (string -> US1) = method5()
                                                                                                                                                    let v6379 : US1 option = v6377 |> Option.map v6378 
                                                                                                                                                    let v6390 : US1 = US1_1
                                                                                                                                                    let v6391 : US1 = v6379 |> Option.defaultValue v6390 
                                                                                                                                                    match v6391 with
                                                                                                                                                    | US1_0(v6395) -> (* Some *)
                                                                                                                                                        let v6396 : bool = v6340 <> v5955 
                                                                                                                                                        if v6396 then
                                                                                                                                                            let v6399 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                            let v6400 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6395 v6399 
                                                                                                                                                            let v6401 : (std_io_Error -> string) = method41()
                                                                                                                                                            let v6402 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v6403 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v6404 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6400, v6401) v6403 
                                                                                                                                                            let _v6402 = v6404 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v6405 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v6406 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6400, v6401) v6405 
                                                                                                                                                            let _v6402 = v6406 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v6407 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v6408 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6400, v6401) v6407 
                                                                                                                                                            let _v6402 = v6408 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v6409 : Result<std_path_PathBuf, string> = match v6400 with Ok x -> Ok x | Error x -> Error (v6401 x)
                                                                                                                                                            let _v6402 = v6409 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v6410 : Result<std_path_PathBuf, string> = match v6400 with Ok x -> Ok x | Error x -> Error (v6401 x)
                                                                                                                                                            let _v6402 = v6410 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v6411 : Result<std_path_PathBuf, string> = match v6400 with Ok x -> Ok x | Error x -> Error (v6401 x)
                                                                                                                                                            let _v6402 = v6411 
                                                                                                                                                            #endif
                                                                                                                                                            let v6412 : Result<std_path_PathBuf, string> = _v6402 
                                                                                                                                                            let v6415 : US8 = match v6412 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                                                            let v6998 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                match v6415 with
                                                                                                                                                                | US8_1(v6430) -> (* Error *)
                                                                                                                                                                    let v6431 : string = method43(v6395)
                                                                                                                                                                    let v6432 : string option = method32(v6395)
                                                                                                                                                                    let v6433 : (string -> US1) = method5()
                                                                                                                                                                    let v6434 : US1 option = v6432 |> Option.map v6433 
                                                                                                                                                                    let v6445 : US1 = US1_1
                                                                                                                                                                    let v6446 : US1 = v6434 |> Option.defaultValue v6445 
                                                                                                                                                                    match v6446 with
                                                                                                                                                                    | US1_0(v6450) -> (* Some *)
                                                                                                                                                                        let v6451 : bool = v6395 <> v5955 
                                                                                                                                                                        if v6451 then
                                                                                                                                                                            let v6454 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                                            let v6455 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6450 v6454 
                                                                                                                                                                            let v6456 : (std_io_Error -> string) = method41()
                                                                                                                                                                            let v6457 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v6458 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v6459 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6455, v6456) v6458 
                                                                                                                                                                            let _v6457 = v6459 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v6460 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v6461 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6455, v6456) v6460 
                                                                                                                                                                            let _v6457 = v6461 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v6462 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v6463 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6455, v6456) v6462 
                                                                                                                                                                            let _v6457 = v6463 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v6464 : Result<std_path_PathBuf, string> = match v6455 with Ok x -> Ok x | Error x -> Error (v6456 x)
                                                                                                                                                                            let _v6457 = v6464 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v6465 : Result<std_path_PathBuf, string> = match v6455 with Ok x -> Ok x | Error x -> Error (v6456 x)
                                                                                                                                                                            let _v6457 = v6465 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v6466 : Result<std_path_PathBuf, string> = match v6455 with Ok x -> Ok x | Error x -> Error (v6456 x)
                                                                                                                                                                            let _v6457 = v6466 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v6467 : Result<std_path_PathBuf, string> = _v6457 
                                                                                                                                                                            let v6470 : US8 = match v6467 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                                                                            let v6793 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                match v6470 with
                                                                                                                                                                                | US8_1(v6485) -> (* Error *)
                                                                                                                                                                                    let v6486 : string = method43(v6450)
                                                                                                                                                                                    let v6487 : string option = method32(v6450)
                                                                                                                                                                                    let v6488 : (string -> US1) = method5()
                                                                                                                                                                                    let v6489 : US1 option = v6487 |> Option.map v6488 
                                                                                                                                                                                    let v6500 : US1 = US1_1
                                                                                                                                                                                    let v6501 : US1 = v6489 |> Option.defaultValue v6500 
                                                                                                                                                                                    match v6501 with
                                                                                                                                                                                    | US1_0(v6505) -> (* Some *)
                                                                                                                                                                                        let v6506 : bool = v6450 <> v5955 
                                                                                                                                                                                        if v6506 then
                                                                                                                                                                                            let v6509 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                                                            let v6510 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6505 v6509 
                                                                                                                                                                                            let v6511 : (std_io_Error -> string) = method41()
                                                                                                                                                                                            let v6512 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v6513 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v6514 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6510, v6511) v6513 
                                                                                                                                                                                            let _v6512 = v6514 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v6515 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v6516 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6510, v6511) v6515 
                                                                                                                                                                                            let _v6512 = v6516 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v6517 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v6518 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6510, v6511) v6517 
                                                                                                                                                                                            let _v6512 = v6518 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v6519 : Result<std_path_PathBuf, string> = match v6510 with Ok x -> Ok x | Error x -> Error (v6511 x)
                                                                                                                                                                                            let _v6512 = v6519 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v6520 : Result<std_path_PathBuf, string> = match v6510 with Ok x -> Ok x | Error x -> Error (v6511 x)
                                                                                                                                                                                            let _v6512 = v6520 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v6521 : Result<std_path_PathBuf, string> = match v6510 with Ok x -> Ok x | Error x -> Error (v6511 x)
                                                                                                                                                                                            let _v6512 = v6521 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v6522 : Result<std_path_PathBuf, string> = _v6512 
                                                                                                                                                                                            let v6525 : US8 = match v6522 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                                                                                            let v6588 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                                match v6525 with
                                                                                                                                                                                                | US8_1(v6540) -> (* Error *)
                                                                                                                                                                                                    let v6541 : string = method43(v6505)
                                                                                                                                                                                                    let v6542 : string option = method32(v6505)
                                                                                                                                                                                                    let v6543 : (string -> US1) = method5()
                                                                                                                                                                                                    let v6544 : US1 option = v6542 |> Option.map v6543 
                                                                                                                                                                                                    let v6555 : US1 = US1_1
                                                                                                                                                                                                    let v6556 : US1 = v6544 |> Option.defaultValue v6555 
                                                                                                                                                                                                    let v6560 : string = $"file_system.read_link / path: {v0} / n: {11uy} / path': {v6505} / name: {v6541}"
                                                                                                                                                                                                    let v6561 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v6562 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v6563 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6560 v6562 
                                                                                                                                                                                                    let _v6561 = v6563 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v6564 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v6565 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6560 v6564 
                                                                                                                                                                                                    let _v6561 = v6565 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v6566 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v6567 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6560 v6566 
                                                                                                                                                                                                    let _v6561 = v6567 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v6568 : std_io_Error = v6560 
                                                                                                                                                                                                    let _v6561 = v6568 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v6569 : std_io_Error = v6560 
                                                                                                                                                                                                    let _v6561 = v6569 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v6570 : std_io_Error = v6560 
                                                                                                                                                                                                    let _v6561 = v6570 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v6571 : std_io_Error = _v6561 
                                                                                                                                                                                                    let v6574 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v6575 : string = "Err($0)"
                                                                                                                                                                                                    let v6576 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6571 v6575 
                                                                                                                                                                                                    let _v6574 = v6576 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v6577 : string = "Err($0)"
                                                                                                                                                                                                    let v6578 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6571 v6577 
                                                                                                                                                                                                    let _v6574 = v6578 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v6579 : string = "Err($0)"
                                                                                                                                                                                                    let v6580 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6571 v6579 
                                                                                                                                                                                                    let _v6574 = v6580 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v6581 : Result<std_path_PathBuf, std_io_Error> = v6571 |> Error
                                                                                                                                                                                                    let _v6574 = v6581 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v6582 : Result<std_path_PathBuf, std_io_Error> = v6571 |> Error
                                                                                                                                                                                                    let _v6574 = v6582 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v6583 : Result<std_path_PathBuf, std_io_Error> = v6571 |> Error
                                                                                                                                                                                                    let _v6574 = v6583 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v6584 : Result<std_path_PathBuf, std_io_Error> = _v6574 
                                                                                                                                                                                                    v6584
                                                                                                                                                                                                | US8_0(v6526) -> (* Ok *)
                                                                                                                                                                                                    let v6527 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v6528 : string = "Ok($0)"
                                                                                                                                                                                                    let v6529 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6526 v6528 
                                                                                                                                                                                                    let _v6527 = v6529 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v6530 : string = "Ok($0)"
                                                                                                                                                                                                    let v6531 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6526 v6530 
                                                                                                                                                                                                    let _v6527 = v6531 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v6532 : string = "Ok($0)"
                                                                                                                                                                                                    let v6533 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6526 v6532 
                                                                                                                                                                                                    let _v6527 = v6533 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v6534 : Result<std_path_PathBuf, std_io_Error> = v6526 |> Ok
                                                                                                                                                                                                    let _v6527 = v6534 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v6535 : Result<std_path_PathBuf, std_io_Error> = v6526 |> Ok
                                                                                                                                                                                                    let _v6527 = v6535 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v6536 : Result<std_path_PathBuf, std_io_Error> = v6526 |> Ok
                                                                                                                                                                                                    let _v6527 = v6536 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v6537 : Result<std_path_PathBuf, std_io_Error> = _v6527 
                                                                                                                                                                                                    v6537
                                                                                                                                                                                            let v6589 : (std_io_Error -> string) = method41()
                                                                                                                                                                                            let v6590 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v6591 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v6592 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6588, v6589) v6591 
                                                                                                                                                                                            let _v6590 = v6592 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v6593 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v6594 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6588, v6589) v6593 
                                                                                                                                                                                            let _v6590 = v6594 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v6595 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v6596 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6588, v6589) v6595 
                                                                                                                                                                                            let _v6590 = v6596 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v6597 : Result<std_path_PathBuf, string> = match v6588 with Ok x -> Ok x | Error x -> Error (v6589 x)
                                                                                                                                                                                            let _v6590 = v6597 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v6598 : Result<std_path_PathBuf, string> = match v6588 with Ok x -> Ok x | Error x -> Error (v6589 x)
                                                                                                                                                                                            let _v6590 = v6598 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v6599 : Result<std_path_PathBuf, string> = match v6588 with Ok x -> Ok x | Error x -> Error (v6589 x)
                                                                                                                                                                                            let _v6590 = v6599 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v6600 : Result<std_path_PathBuf, string> = _v6590 
                                                                                                                                                                                            let v6603 : US8 = match v6600 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                                                                                            match v6603 with
                                                                                                                                                                                            | US8_1(v6706) -> (* Error *)
                                                                                                                                                                                                let v6707 : string = $"file_system.read_link / error': {v6706} / error: {v6485} / name: {v6486}"
                                                                                                                                                                                                let v6708 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v6709 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v6710 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6707 v6709 
                                                                                                                                                                                                let _v6708 = v6710 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v6711 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v6712 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6707 v6711 
                                                                                                                                                                                                let _v6708 = v6712 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v6713 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v6714 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6707 v6713 
                                                                                                                                                                                                let _v6708 = v6714 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v6715 : std_io_Error = v6707 
                                                                                                                                                                                                let _v6708 = v6715 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v6716 : std_io_Error = v6707 
                                                                                                                                                                                                let _v6708 = v6716 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v6717 : std_io_Error = v6707 
                                                                                                                                                                                                let _v6708 = v6717 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v6718 : std_io_Error = _v6708 
                                                                                                                                                                                                let v6721 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v6722 : string = "Err($0)"
                                                                                                                                                                                                let v6723 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6718 v6722 
                                                                                                                                                                                                let _v6721 = v6723 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v6724 : string = "Err($0)"
                                                                                                                                                                                                let v6725 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6718 v6724 
                                                                                                                                                                                                let _v6721 = v6725 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v6726 : string = "Err($0)"
                                                                                                                                                                                                let v6727 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6718 v6726 
                                                                                                                                                                                                let _v6721 = v6727 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v6728 : Result<std_path_PathBuf, std_io_Error> = v6718 |> Error
                                                                                                                                                                                                let _v6721 = v6728 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v6729 : Result<std_path_PathBuf, std_io_Error> = v6718 |> Error
                                                                                                                                                                                                let _v6721 = v6729 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v6730 : Result<std_path_PathBuf, std_io_Error> = v6718 |> Error
                                                                                                                                                                                                let _v6721 = v6730 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v6731 : Result<std_path_PathBuf, std_io_Error> = _v6721 
                                                                                                                                                                                                v6731
                                                                                                                                                                                            | US8_0(v6604) -> (* Ok *)
                                                                                                                                                                                                let v6605 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v6606 : string = "$0.display()"
                                                                                                                                                                                                let v6607 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v6604 v6606 
                                                                                                                                                                                                let _v6605 = v6607 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v6608 : string = "$0.display()"
                                                                                                                                                                                                let v6609 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v6604 v6608 
                                                                                                                                                                                                let _v6605 = v6609 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v6610 : string = "$0.display()"
                                                                                                                                                                                                let v6611 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v6604 v6610 
                                                                                                                                                                                                let _v6605 = v6611 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v6612 : std_path_Display = v6604 |> unbox<std_path_Display>
                                                                                                                                                                                                let _v6605 = v6612 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v6615 : std_path_Display = v6604 |> unbox<std_path_Display>
                                                                                                                                                                                                let _v6605 = v6615 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v6618 : std_path_Display = v6604 |> unbox<std_path_Display>
                                                                                                                                                                                                let _v6605 = v6618 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v6621 : std_path_Display = _v6605 
                                                                                                                                                                                                let v6626 : string = v6621 |> string 
                                                                                                                                                                                                let v6629 : string = method26(v6626, v6486)
                                                                                                                                                                                                let v6630 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v6631 : string = "&*$0"
                                                                                                                                                                                                let v6632 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6629 v6631 
                                                                                                                                                                                                let _v6630 = v6632 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v6633 : string = "&*$0"
                                                                                                                                                                                                let v6634 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6629 v6633 
                                                                                                                                                                                                let _v6630 = v6634 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v6635 : string = "&*$0"
                                                                                                                                                                                                let v6636 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6629 v6635 
                                                                                                                                                                                                let _v6630 = v6636 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v6637 : Ref<Str> = v6629 |> unbox<Ref<Str>>
                                                                                                                                                                                                let _v6630 = v6637 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v6640 : Ref<Str> = v6629 |> unbox<Ref<Str>>
                                                                                                                                                                                                let _v6630 = v6640 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v6643 : Ref<Str> = v6629 |> unbox<Ref<Str>>
                                                                                                                                                                                                let _v6630 = v6643 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v6646 : Ref<Str> = _v6630 
                                                                                                                                                                                                let v6651 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v6652 : string = "String::from($0)"
                                                                                                                                                                                                let v6653 : std_string_String = Fable.Core.RustInterop.emitRustExpr v6646 v6652 
                                                                                                                                                                                                let _v6651 = v6653 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v6654 : string = "String::from($0)"
                                                                                                                                                                                                let v6655 : std_string_String = Fable.Core.RustInterop.emitRustExpr v6646 v6654 
                                                                                                                                                                                                let _v6651 = v6655 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v6656 : string = "String::from($0)"
                                                                                                                                                                                                let v6657 : std_string_String = Fable.Core.RustInterop.emitRustExpr v6646 v6656 
                                                                                                                                                                                                let _v6651 = v6657 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v6658 : std_string_String = v6646 |> unbox<std_string_String>
                                                                                                                                                                                                let _v6651 = v6658 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v6661 : std_string_String = v6646 |> unbox<std_string_String>
                                                                                                                                                                                                let _v6651 = v6661 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v6664 : std_string_String = v6646 |> unbox<std_string_String>
                                                                                                                                                                                                let _v6651 = v6664 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v6667 : std_string_String = _v6651 
                                                                                                                                                                                                let v6672 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v6673 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                let v6674 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v6667 v6673 
                                                                                                                                                                                                let _v6672 = v6674 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v6675 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                let v6676 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v6667 v6675 
                                                                                                                                                                                                let _v6672 = v6676 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v6677 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                let v6678 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v6667 v6677 
                                                                                                                                                                                                let _v6672 = v6678 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v6679 : std_path_PathBuf = v6667 |> std_path_PathBuf 
                                                                                                                                                                                                let _v6672 = v6679 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v6682 : std_path_PathBuf = v6667 |> std_path_PathBuf 
                                                                                                                                                                                                let _v6672 = v6682 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v6685 : std_path_PathBuf = v6667 |> std_path_PathBuf 
                                                                                                                                                                                                let _v6672 = v6685 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v6688 : std_path_PathBuf = _v6672 
                                                                                                                                                                                                let v6693 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v6694 : string = "Ok($0)"
                                                                                                                                                                                                let v6695 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6688 v6694 
                                                                                                                                                                                                let _v6693 = v6695 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v6696 : string = "Ok($0)"
                                                                                                                                                                                                let v6697 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6688 v6696 
                                                                                                                                                                                                let _v6693 = v6697 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v6698 : string = "Ok($0)"
                                                                                                                                                                                                let v6699 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6688 v6698 
                                                                                                                                                                                                let _v6693 = v6699 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v6700 : Result<std_path_PathBuf, std_io_Error> = v6688 |> Ok
                                                                                                                                                                                                let _v6693 = v6700 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v6701 : Result<std_path_PathBuf, std_io_Error> = v6688 |> Ok
                                                                                                                                                                                                let _v6693 = v6701 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v6702 : Result<std_path_PathBuf, std_io_Error> = v6688 |> Ok
                                                                                                                                                                                                let _v6693 = v6702 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v6703 : Result<std_path_PathBuf, std_io_Error> = _v6693 
                                                                                                                                                                                                v6703
                                                                                                                                                                                        else
                                                                                                                                                                                            let v6736 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v6485} / path': {v6450} / name: {v6486}"
                                                                                                                                                                                            let v6737 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v6738 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v6739 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6736 v6738 
                                                                                                                                                                                            let _v6737 = v6739 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v6740 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v6741 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6736 v6740 
                                                                                                                                                                                            let _v6737 = v6741 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v6742 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v6743 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6736 v6742 
                                                                                                                                                                                            let _v6737 = v6743 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v6744 : std_io_Error = v6736 
                                                                                                                                                                                            let _v6737 = v6744 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v6745 : std_io_Error = v6736 
                                                                                                                                                                                            let _v6737 = v6745 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v6746 : std_io_Error = v6736 
                                                                                                                                                                                            let _v6737 = v6746 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v6747 : std_io_Error = _v6737 
                                                                                                                                                                                            let v6750 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v6751 : string = "Err($0)"
                                                                                                                                                                                            let v6752 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6747 v6751 
                                                                                                                                                                                            let _v6750 = v6752 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v6753 : string = "Err($0)"
                                                                                                                                                                                            let v6754 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6747 v6753 
                                                                                                                                                                                            let _v6750 = v6754 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v6755 : string = "Err($0)"
                                                                                                                                                                                            let v6756 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6747 v6755 
                                                                                                                                                                                            let _v6750 = v6756 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v6757 : Result<std_path_PathBuf, std_io_Error> = v6747 |> Error
                                                                                                                                                                                            let _v6750 = v6757 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v6758 : Result<std_path_PathBuf, std_io_Error> = v6747 |> Error
                                                                                                                                                                                            let _v6750 = v6758 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v6759 : Result<std_path_PathBuf, std_io_Error> = v6747 |> Error
                                                                                                                                                                                            let _v6750 = v6759 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v6760 : Result<std_path_PathBuf, std_io_Error> = _v6750 
                                                                                                                                                                                            v6760
                                                                                                                                                                                    | _ ->
                                                                                                                                                                                        let v6764 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v6485} / path': {v6450} / name: {v6486}"
                                                                                                                                                                                        let v6765 : unit = ()
                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                        let v6766 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                        let v6767 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6764 v6766 
                                                                                                                                                                                        let _v6765 = v6767 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                        let v6768 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                        let v6769 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6764 v6768 
                                                                                                                                                                                        let _v6765 = v6769 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                        let v6770 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                        let v6771 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6764 v6770 
                                                                                                                                                                                        let _v6765 = v6771 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                        let v6772 : std_io_Error = v6764 
                                                                                                                                                                                        let _v6765 = v6772 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                        let v6773 : std_io_Error = v6764 
                                                                                                                                                                                        let _v6765 = v6773 
                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                        let v6774 : std_io_Error = v6764 
                                                                                                                                                                                        let _v6765 = v6774 
                                                                                                                                                                                        #endif
                                                                                                                                                                                        let v6775 : std_io_Error = _v6765 
                                                                                                                                                                                        let v6778 : unit = ()
                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                        let v6779 : string = "Err($0)"
                                                                                                                                                                                        let v6780 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6775 v6779 
                                                                                                                                                                                        let _v6778 = v6780 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                        let v6781 : string = "Err($0)"
                                                                                                                                                                                        let v6782 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6775 v6781 
                                                                                                                                                                                        let _v6778 = v6782 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                        let v6783 : string = "Err($0)"
                                                                                                                                                                                        let v6784 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6775 v6783 
                                                                                                                                                                                        let _v6778 = v6784 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                        let v6785 : Result<std_path_PathBuf, std_io_Error> = v6775 |> Error
                                                                                                                                                                                        let _v6778 = v6785 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                        let v6786 : Result<std_path_PathBuf, std_io_Error> = v6775 |> Error
                                                                                                                                                                                        let _v6778 = v6786 
                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                        let v6787 : Result<std_path_PathBuf, std_io_Error> = v6775 |> Error
                                                                                                                                                                                        let _v6778 = v6787 
                                                                                                                                                                                        #endif
                                                                                                                                                                                        let v6788 : Result<std_path_PathBuf, std_io_Error> = _v6778 
                                                                                                                                                                                        v6788
                                                                                                                                                                                | US8_0(v6471) -> (* Ok *)
                                                                                                                                                                                    let v6472 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v6473 : string = "Ok($0)"
                                                                                                                                                                                    let v6474 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6471 v6473 
                                                                                                                                                                                    let _v6472 = v6474 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v6475 : string = "Ok($0)"
                                                                                                                                                                                    let v6476 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6471 v6475 
                                                                                                                                                                                    let _v6472 = v6476 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v6477 : string = "Ok($0)"
                                                                                                                                                                                    let v6478 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6471 v6477 
                                                                                                                                                                                    let _v6472 = v6478 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v6479 : Result<std_path_PathBuf, std_io_Error> = v6471 |> Ok
                                                                                                                                                                                    let _v6472 = v6479 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v6480 : Result<std_path_PathBuf, std_io_Error> = v6471 |> Ok
                                                                                                                                                                                    let _v6472 = v6480 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v6481 : Result<std_path_PathBuf, std_io_Error> = v6471 |> Ok
                                                                                                                                                                                    let _v6472 = v6481 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v6482 : Result<std_path_PathBuf, std_io_Error> = _v6472 
                                                                                                                                                                                    v6482
                                                                                                                                                                            let v6794 : (std_io_Error -> string) = method41()
                                                                                                                                                                            let v6795 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v6796 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v6797 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6793, v6794) v6796 
                                                                                                                                                                            let _v6795 = v6797 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v6798 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v6799 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6793, v6794) v6798 
                                                                                                                                                                            let _v6795 = v6799 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v6800 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v6801 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6793, v6794) v6800 
                                                                                                                                                                            let _v6795 = v6801 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v6802 : Result<std_path_PathBuf, string> = match v6793 with Ok x -> Ok x | Error x -> Error (v6794 x)
                                                                                                                                                                            let _v6795 = v6802 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v6803 : Result<std_path_PathBuf, string> = match v6793 with Ok x -> Ok x | Error x -> Error (v6794 x)
                                                                                                                                                                            let _v6795 = v6803 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v6804 : Result<std_path_PathBuf, string> = match v6793 with Ok x -> Ok x | Error x -> Error (v6794 x)
                                                                                                                                                                            let _v6795 = v6804 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v6805 : Result<std_path_PathBuf, string> = _v6795 
                                                                                                                                                                            let v6808 : US8 = match v6805 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                                                                            match v6808 with
                                                                                                                                                                            | US8_1(v6911) -> (* Error *)
                                                                                                                                                                                let v6912 : string = $"file_system.read_link / error': {v6911} / error: {v6430} / name: {v6431}"
                                                                                                                                                                                let v6913 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v6914 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v6915 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6912 v6914 
                                                                                                                                                                                let _v6913 = v6915 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v6916 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v6917 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6912 v6916 
                                                                                                                                                                                let _v6913 = v6917 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v6918 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v6919 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6912 v6918 
                                                                                                                                                                                let _v6913 = v6919 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v6920 : std_io_Error = v6912 
                                                                                                                                                                                let _v6913 = v6920 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v6921 : std_io_Error = v6912 
                                                                                                                                                                                let _v6913 = v6921 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v6922 : std_io_Error = v6912 
                                                                                                                                                                                let _v6913 = v6922 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v6923 : std_io_Error = _v6913 
                                                                                                                                                                                let v6926 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v6927 : string = "Err($0)"
                                                                                                                                                                                let v6928 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6923 v6927 
                                                                                                                                                                                let _v6926 = v6928 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v6929 : string = "Err($0)"
                                                                                                                                                                                let v6930 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6923 v6929 
                                                                                                                                                                                let _v6926 = v6930 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v6931 : string = "Err($0)"
                                                                                                                                                                                let v6932 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6923 v6931 
                                                                                                                                                                                let _v6926 = v6932 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v6933 : Result<std_path_PathBuf, std_io_Error> = v6923 |> Error
                                                                                                                                                                                let _v6926 = v6933 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v6934 : Result<std_path_PathBuf, std_io_Error> = v6923 |> Error
                                                                                                                                                                                let _v6926 = v6934 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v6935 : Result<std_path_PathBuf, std_io_Error> = v6923 |> Error
                                                                                                                                                                                let _v6926 = v6935 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v6936 : Result<std_path_PathBuf, std_io_Error> = _v6926 
                                                                                                                                                                                v6936
                                                                                                                                                                            | US8_0(v6809) -> (* Ok *)
                                                                                                                                                                                let v6810 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v6811 : string = "$0.display()"
                                                                                                                                                                                let v6812 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v6809 v6811 
                                                                                                                                                                                let _v6810 = v6812 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v6813 : string = "$0.display()"
                                                                                                                                                                                let v6814 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v6809 v6813 
                                                                                                                                                                                let _v6810 = v6814 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v6815 : string = "$0.display()"
                                                                                                                                                                                let v6816 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v6809 v6815 
                                                                                                                                                                                let _v6810 = v6816 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v6817 : std_path_Display = v6809 |> unbox<std_path_Display>
                                                                                                                                                                                let _v6810 = v6817 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v6820 : std_path_Display = v6809 |> unbox<std_path_Display>
                                                                                                                                                                                let _v6810 = v6820 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v6823 : std_path_Display = v6809 |> unbox<std_path_Display>
                                                                                                                                                                                let _v6810 = v6823 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v6826 : std_path_Display = _v6810 
                                                                                                                                                                                let v6831 : string = v6826 |> string 
                                                                                                                                                                                let v6834 : string = method26(v6831, v6431)
                                                                                                                                                                                let v6835 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v6836 : string = "&*$0"
                                                                                                                                                                                let v6837 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6834 v6836 
                                                                                                                                                                                let _v6835 = v6837 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v6838 : string = "&*$0"
                                                                                                                                                                                let v6839 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6834 v6838 
                                                                                                                                                                                let _v6835 = v6839 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v6840 : string = "&*$0"
                                                                                                                                                                                let v6841 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6834 v6840 
                                                                                                                                                                                let _v6835 = v6841 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v6842 : Ref<Str> = v6834 |> unbox<Ref<Str>>
                                                                                                                                                                                let _v6835 = v6842 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v6845 : Ref<Str> = v6834 |> unbox<Ref<Str>>
                                                                                                                                                                                let _v6835 = v6845 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v6848 : Ref<Str> = v6834 |> unbox<Ref<Str>>
                                                                                                                                                                                let _v6835 = v6848 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v6851 : Ref<Str> = _v6835 
                                                                                                                                                                                let v6856 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v6857 : string = "String::from($0)"
                                                                                                                                                                                let v6858 : std_string_String = Fable.Core.RustInterop.emitRustExpr v6851 v6857 
                                                                                                                                                                                let _v6856 = v6858 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v6859 : string = "String::from($0)"
                                                                                                                                                                                let v6860 : std_string_String = Fable.Core.RustInterop.emitRustExpr v6851 v6859 
                                                                                                                                                                                let _v6856 = v6860 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v6861 : string = "String::from($0)"
                                                                                                                                                                                let v6862 : std_string_String = Fable.Core.RustInterop.emitRustExpr v6851 v6861 
                                                                                                                                                                                let _v6856 = v6862 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v6863 : std_string_String = v6851 |> unbox<std_string_String>
                                                                                                                                                                                let _v6856 = v6863 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v6866 : std_string_String = v6851 |> unbox<std_string_String>
                                                                                                                                                                                let _v6856 = v6866 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v6869 : std_string_String = v6851 |> unbox<std_string_String>
                                                                                                                                                                                let _v6856 = v6869 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v6872 : std_string_String = _v6856 
                                                                                                                                                                                let v6877 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v6878 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                let v6879 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v6872 v6878 
                                                                                                                                                                                let _v6877 = v6879 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v6880 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                let v6881 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v6872 v6880 
                                                                                                                                                                                let _v6877 = v6881 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v6882 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                let v6883 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v6872 v6882 
                                                                                                                                                                                let _v6877 = v6883 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v6884 : std_path_PathBuf = v6872 |> std_path_PathBuf 
                                                                                                                                                                                let _v6877 = v6884 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v6887 : std_path_PathBuf = v6872 |> std_path_PathBuf 
                                                                                                                                                                                let _v6877 = v6887 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v6890 : std_path_PathBuf = v6872 |> std_path_PathBuf 
                                                                                                                                                                                let _v6877 = v6890 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v6893 : std_path_PathBuf = _v6877 
                                                                                                                                                                                let v6898 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v6899 : string = "Ok($0)"
                                                                                                                                                                                let v6900 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6893 v6899 
                                                                                                                                                                                let _v6898 = v6900 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v6901 : string = "Ok($0)"
                                                                                                                                                                                let v6902 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6893 v6901 
                                                                                                                                                                                let _v6898 = v6902 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v6903 : string = "Ok($0)"
                                                                                                                                                                                let v6904 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6893 v6903 
                                                                                                                                                                                let _v6898 = v6904 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v6905 : Result<std_path_PathBuf, std_io_Error> = v6893 |> Ok
                                                                                                                                                                                let _v6898 = v6905 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v6906 : Result<std_path_PathBuf, std_io_Error> = v6893 |> Ok
                                                                                                                                                                                let _v6898 = v6906 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v6907 : Result<std_path_PathBuf, std_io_Error> = v6893 |> Ok
                                                                                                                                                                                let _v6898 = v6907 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v6908 : Result<std_path_PathBuf, std_io_Error> = _v6898 
                                                                                                                                                                                v6908
                                                                                                                                                                        else
                                                                                                                                                                            let v6941 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v6430} / path': {v6395} / name: {v6431}"
                                                                                                                                                                            let v6942 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v6943 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v6944 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6941 v6943 
                                                                                                                                                                            let _v6942 = v6944 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v6945 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v6946 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6941 v6945 
                                                                                                                                                                            let _v6942 = v6946 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v6947 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v6948 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6941 v6947 
                                                                                                                                                                            let _v6942 = v6948 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v6949 : std_io_Error = v6941 
                                                                                                                                                                            let _v6942 = v6949 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v6950 : std_io_Error = v6941 
                                                                                                                                                                            let _v6942 = v6950 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v6951 : std_io_Error = v6941 
                                                                                                                                                                            let _v6942 = v6951 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v6952 : std_io_Error = _v6942 
                                                                                                                                                                            let v6955 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v6956 : string = "Err($0)"
                                                                                                                                                                            let v6957 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6952 v6956 
                                                                                                                                                                            let _v6955 = v6957 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v6958 : string = "Err($0)"
                                                                                                                                                                            let v6959 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6952 v6958 
                                                                                                                                                                            let _v6955 = v6959 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v6960 : string = "Err($0)"
                                                                                                                                                                            let v6961 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6952 v6960 
                                                                                                                                                                            let _v6955 = v6961 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v6962 : Result<std_path_PathBuf, std_io_Error> = v6952 |> Error
                                                                                                                                                                            let _v6955 = v6962 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v6963 : Result<std_path_PathBuf, std_io_Error> = v6952 |> Error
                                                                                                                                                                            let _v6955 = v6963 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v6964 : Result<std_path_PathBuf, std_io_Error> = v6952 |> Error
                                                                                                                                                                            let _v6955 = v6964 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v6965 : Result<std_path_PathBuf, std_io_Error> = _v6955 
                                                                                                                                                                            v6965
                                                                                                                                                                    | _ ->
                                                                                                                                                                        let v6969 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v6430} / path': {v6395} / name: {v6431}"
                                                                                                                                                                        let v6970 : unit = ()
                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                        let v6971 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                        let v6972 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6969 v6971 
                                                                                                                                                                        let _v6970 = v6972 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                        let v6973 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                        let v6974 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6969 v6973 
                                                                                                                                                                        let _v6970 = v6974 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                        let v6975 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                        let v6976 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6969 v6975 
                                                                                                                                                                        let _v6970 = v6976 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                        let v6977 : std_io_Error = v6969 
                                                                                                                                                                        let _v6970 = v6977 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                        let v6978 : std_io_Error = v6969 
                                                                                                                                                                        let _v6970 = v6978 
                                                                                                                                                                        #endif
#else
                                                                                                                                                                        let v6979 : std_io_Error = v6969 
                                                                                                                                                                        let _v6970 = v6979 
                                                                                                                                                                        #endif
                                                                                                                                                                        let v6980 : std_io_Error = _v6970 
                                                                                                                                                                        let v6983 : unit = ()
                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                        let v6984 : string = "Err($0)"
                                                                                                                                                                        let v6985 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6980 v6984 
                                                                                                                                                                        let _v6983 = v6985 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                        let v6986 : string = "Err($0)"
                                                                                                                                                                        let v6987 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6980 v6986 
                                                                                                                                                                        let _v6983 = v6987 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                        let v6988 : string = "Err($0)"
                                                                                                                                                                        let v6989 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6980 v6988 
                                                                                                                                                                        let _v6983 = v6989 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                        let v6990 : Result<std_path_PathBuf, std_io_Error> = v6980 |> Error
                                                                                                                                                                        let _v6983 = v6990 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                        let v6991 : Result<std_path_PathBuf, std_io_Error> = v6980 |> Error
                                                                                                                                                                        let _v6983 = v6991 
                                                                                                                                                                        #endif
#else
                                                                                                                                                                        let v6992 : Result<std_path_PathBuf, std_io_Error> = v6980 |> Error
                                                                                                                                                                        let _v6983 = v6992 
                                                                                                                                                                        #endif
                                                                                                                                                                        let v6993 : Result<std_path_PathBuf, std_io_Error> = _v6983 
                                                                                                                                                                        v6993
                                                                                                                                                                | US8_0(v6416) -> (* Ok *)
                                                                                                                                                                    let v6417 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v6418 : string = "Ok($0)"
                                                                                                                                                                    let v6419 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6416 v6418 
                                                                                                                                                                    let _v6417 = v6419 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v6420 : string = "Ok($0)"
                                                                                                                                                                    let v6421 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6416 v6420 
                                                                                                                                                                    let _v6417 = v6421 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v6422 : string = "Ok($0)"
                                                                                                                                                                    let v6423 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6416 v6422 
                                                                                                                                                                    let _v6417 = v6423 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v6424 : Result<std_path_PathBuf, std_io_Error> = v6416 |> Ok
                                                                                                                                                                    let _v6417 = v6424 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v6425 : Result<std_path_PathBuf, std_io_Error> = v6416 |> Ok
                                                                                                                                                                    let _v6417 = v6425 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v6426 : Result<std_path_PathBuf, std_io_Error> = v6416 |> Ok
                                                                                                                                                                    let _v6417 = v6426 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v6427 : Result<std_path_PathBuf, std_io_Error> = _v6417 
                                                                                                                                                                    v6427
                                                                                                                                                            let v6999 : (std_io_Error -> string) = method41()
                                                                                                                                                            let v7000 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v7001 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v7002 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6998, v6999) v7001 
                                                                                                                                                            let _v7000 = v7002 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v7003 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v7004 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6998, v6999) v7003 
                                                                                                                                                            let _v7000 = v7004 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v7005 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v7006 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6998, v6999) v7005 
                                                                                                                                                            let _v7000 = v7006 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v7007 : Result<std_path_PathBuf, string> = match v6998 with Ok x -> Ok x | Error x -> Error (v6999 x)
                                                                                                                                                            let _v7000 = v7007 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v7008 : Result<std_path_PathBuf, string> = match v6998 with Ok x -> Ok x | Error x -> Error (v6999 x)
                                                                                                                                                            let _v7000 = v7008 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v7009 : Result<std_path_PathBuf, string> = match v6998 with Ok x -> Ok x | Error x -> Error (v6999 x)
                                                                                                                                                            let _v7000 = v7009 
                                                                                                                                                            #endif
                                                                                                                                                            let v7010 : Result<std_path_PathBuf, string> = _v7000 
                                                                                                                                                            let v7013 : US8 = match v7010 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                                                            match v7013 with
                                                                                                                                                            | US8_1(v7116) -> (* Error *)
                                                                                                                                                                let v7117 : string = $"file_system.read_link / error': {v7116} / error: {v6375} / name: {v6376}"
                                                                                                                                                                let v7118 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v7119 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v7120 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7117 v7119 
                                                                                                                                                                let _v7118 = v7120 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v7121 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v7122 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7117 v7121 
                                                                                                                                                                let _v7118 = v7122 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v7123 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v7124 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7117 v7123 
                                                                                                                                                                let _v7118 = v7124 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v7125 : std_io_Error = v7117 
                                                                                                                                                                let _v7118 = v7125 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v7126 : std_io_Error = v7117 
                                                                                                                                                                let _v7118 = v7126 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v7127 : std_io_Error = v7117 
                                                                                                                                                                let _v7118 = v7127 
                                                                                                                                                                #endif
                                                                                                                                                                let v7128 : std_io_Error = _v7118 
                                                                                                                                                                let v7131 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v7132 : string = "Err($0)"
                                                                                                                                                                let v7133 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7128 v7132 
                                                                                                                                                                let _v7131 = v7133 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v7134 : string = "Err($0)"
                                                                                                                                                                let v7135 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7128 v7134 
                                                                                                                                                                let _v7131 = v7135 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v7136 : string = "Err($0)"
                                                                                                                                                                let v7137 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7128 v7136 
                                                                                                                                                                let _v7131 = v7137 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v7138 : Result<std_path_PathBuf, std_io_Error> = v7128 |> Error
                                                                                                                                                                let _v7131 = v7138 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v7139 : Result<std_path_PathBuf, std_io_Error> = v7128 |> Error
                                                                                                                                                                let _v7131 = v7139 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v7140 : Result<std_path_PathBuf, std_io_Error> = v7128 |> Error
                                                                                                                                                                let _v7131 = v7140 
                                                                                                                                                                #endif
                                                                                                                                                                let v7141 : Result<std_path_PathBuf, std_io_Error> = _v7131 
                                                                                                                                                                v7141
                                                                                                                                                            | US8_0(v7014) -> (* Ok *)
                                                                                                                                                                let v7015 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v7016 : string = "$0.display()"
                                                                                                                                                                let v7017 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7014 v7016 
                                                                                                                                                                let _v7015 = v7017 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v7018 : string = "$0.display()"
                                                                                                                                                                let v7019 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7014 v7018 
                                                                                                                                                                let _v7015 = v7019 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v7020 : string = "$0.display()"
                                                                                                                                                                let v7021 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7014 v7020 
                                                                                                                                                                let _v7015 = v7021 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v7022 : std_path_Display = v7014 |> unbox<std_path_Display>
                                                                                                                                                                let _v7015 = v7022 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v7025 : std_path_Display = v7014 |> unbox<std_path_Display>
                                                                                                                                                                let _v7015 = v7025 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v7028 : std_path_Display = v7014 |> unbox<std_path_Display>
                                                                                                                                                                let _v7015 = v7028 
                                                                                                                                                                #endif
                                                                                                                                                                let v7031 : std_path_Display = _v7015 
                                                                                                                                                                let v7036 : string = v7031 |> string 
                                                                                                                                                                let v7039 : string = method26(v7036, v6376)
                                                                                                                                                                let v7040 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v7041 : string = "&*$0"
                                                                                                                                                                let v7042 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7039 v7041 
                                                                                                                                                                let _v7040 = v7042 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v7043 : string = "&*$0"
                                                                                                                                                                let v7044 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7039 v7043 
                                                                                                                                                                let _v7040 = v7044 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v7045 : string = "&*$0"
                                                                                                                                                                let v7046 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7039 v7045 
                                                                                                                                                                let _v7040 = v7046 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v7047 : Ref<Str> = v7039 |> unbox<Ref<Str>>
                                                                                                                                                                let _v7040 = v7047 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v7050 : Ref<Str> = v7039 |> unbox<Ref<Str>>
                                                                                                                                                                let _v7040 = v7050 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v7053 : Ref<Str> = v7039 |> unbox<Ref<Str>>
                                                                                                                                                                let _v7040 = v7053 
                                                                                                                                                                #endif
                                                                                                                                                                let v7056 : Ref<Str> = _v7040 
                                                                                                                                                                let v7061 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v7062 : string = "String::from($0)"
                                                                                                                                                                let v7063 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7056 v7062 
                                                                                                                                                                let _v7061 = v7063 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v7064 : string = "String::from($0)"
                                                                                                                                                                let v7065 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7056 v7064 
                                                                                                                                                                let _v7061 = v7065 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v7066 : string = "String::from($0)"
                                                                                                                                                                let v7067 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7056 v7066 
                                                                                                                                                                let _v7061 = v7067 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v7068 : std_string_String = v7056 |> unbox<std_string_String>
                                                                                                                                                                let _v7061 = v7068 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v7071 : std_string_String = v7056 |> unbox<std_string_String>
                                                                                                                                                                let _v7061 = v7071 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v7074 : std_string_String = v7056 |> unbox<std_string_String>
                                                                                                                                                                let _v7061 = v7074 
                                                                                                                                                                #endif
                                                                                                                                                                let v7077 : std_string_String = _v7061 
                                                                                                                                                                let v7082 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v7083 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                let v7084 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7077 v7083 
                                                                                                                                                                let _v7082 = v7084 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v7085 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                let v7086 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7077 v7085 
                                                                                                                                                                let _v7082 = v7086 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v7087 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                let v7088 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7077 v7087 
                                                                                                                                                                let _v7082 = v7088 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v7089 : std_path_PathBuf = v7077 |> std_path_PathBuf 
                                                                                                                                                                let _v7082 = v7089 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v7092 : std_path_PathBuf = v7077 |> std_path_PathBuf 
                                                                                                                                                                let _v7082 = v7092 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v7095 : std_path_PathBuf = v7077 |> std_path_PathBuf 
                                                                                                                                                                let _v7082 = v7095 
                                                                                                                                                                #endif
                                                                                                                                                                let v7098 : std_path_PathBuf = _v7082 
                                                                                                                                                                let v7103 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v7104 : string = "Ok($0)"
                                                                                                                                                                let v7105 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7098 v7104 
                                                                                                                                                                let _v7103 = v7105 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v7106 : string = "Ok($0)"
                                                                                                                                                                let v7107 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7098 v7106 
                                                                                                                                                                let _v7103 = v7107 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v7108 : string = "Ok($0)"
                                                                                                                                                                let v7109 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7098 v7108 
                                                                                                                                                                let _v7103 = v7109 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v7110 : Result<std_path_PathBuf, std_io_Error> = v7098 |> Ok
                                                                                                                                                                let _v7103 = v7110 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v7111 : Result<std_path_PathBuf, std_io_Error> = v7098 |> Ok
                                                                                                                                                                let _v7103 = v7111 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v7112 : Result<std_path_PathBuf, std_io_Error> = v7098 |> Ok
                                                                                                                                                                let _v7103 = v7112 
                                                                                                                                                                #endif
                                                                                                                                                                let v7113 : Result<std_path_PathBuf, std_io_Error> = _v7103 
                                                                                                                                                                v7113
                                                                                                                                                        else
                                                                                                                                                            let v7146 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v6375} / path': {v6340} / name: {v6376}"
                                                                                                                                                            let v7147 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v7148 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v7149 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7146 v7148 
                                                                                                                                                            let _v7147 = v7149 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v7150 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v7151 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7146 v7150 
                                                                                                                                                            let _v7147 = v7151 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v7152 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v7153 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7146 v7152 
                                                                                                                                                            let _v7147 = v7153 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v7154 : std_io_Error = v7146 
                                                                                                                                                            let _v7147 = v7154 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v7155 : std_io_Error = v7146 
                                                                                                                                                            let _v7147 = v7155 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v7156 : std_io_Error = v7146 
                                                                                                                                                            let _v7147 = v7156 
                                                                                                                                                            #endif
                                                                                                                                                            let v7157 : std_io_Error = _v7147 
                                                                                                                                                            let v7160 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v7161 : string = "Err($0)"
                                                                                                                                                            let v7162 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7157 v7161 
                                                                                                                                                            let _v7160 = v7162 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v7163 : string = "Err($0)"
                                                                                                                                                            let v7164 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7157 v7163 
                                                                                                                                                            let _v7160 = v7164 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v7165 : string = "Err($0)"
                                                                                                                                                            let v7166 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7157 v7165 
                                                                                                                                                            let _v7160 = v7166 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v7167 : Result<std_path_PathBuf, std_io_Error> = v7157 |> Error
                                                                                                                                                            let _v7160 = v7167 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v7168 : Result<std_path_PathBuf, std_io_Error> = v7157 |> Error
                                                                                                                                                            let _v7160 = v7168 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v7169 : Result<std_path_PathBuf, std_io_Error> = v7157 |> Error
                                                                                                                                                            let _v7160 = v7169 
                                                                                                                                                            #endif
                                                                                                                                                            let v7170 : Result<std_path_PathBuf, std_io_Error> = _v7160 
                                                                                                                                                            v7170
                                                                                                                                                    | _ ->
                                                                                                                                                        let v7174 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v6375} / path': {v6340} / name: {v6376}"
                                                                                                                                                        let v7175 : unit = ()
                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                        let v7176 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                        let v7177 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7174 v7176 
                                                                                                                                                        let _v7175 = v7177 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                        let v7178 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                        let v7179 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7174 v7178 
                                                                                                                                                        let _v7175 = v7179 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                        let v7180 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                        let v7181 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7174 v7180 
                                                                                                                                                        let _v7175 = v7181 
                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                        let v7182 : std_io_Error = v7174 
                                                                                                                                                        let _v7175 = v7182 
                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                        let v7183 : std_io_Error = v7174 
                                                                                                                                                        let _v7175 = v7183 
                                                                                                                                                        #endif
#else
                                                                                                                                                        let v7184 : std_io_Error = v7174 
                                                                                                                                                        let _v7175 = v7184 
                                                                                                                                                        #endif
                                                                                                                                                        let v7185 : std_io_Error = _v7175 
                                                                                                                                                        let v7188 : unit = ()
                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                        let v7189 : string = "Err($0)"
                                                                                                                                                        let v7190 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7185 v7189 
                                                                                                                                                        let _v7188 = v7190 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                        let v7191 : string = "Err($0)"
                                                                                                                                                        let v7192 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7185 v7191 
                                                                                                                                                        let _v7188 = v7192 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                        let v7193 : string = "Err($0)"
                                                                                                                                                        let v7194 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7185 v7193 
                                                                                                                                                        let _v7188 = v7194 
                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                        let v7195 : Result<std_path_PathBuf, std_io_Error> = v7185 |> Error
                                                                                                                                                        let _v7188 = v7195 
                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                        let v7196 : Result<std_path_PathBuf, std_io_Error> = v7185 |> Error
                                                                                                                                                        let _v7188 = v7196 
                                                                                                                                                        #endif
#else
                                                                                                                                                        let v7197 : Result<std_path_PathBuf, std_io_Error> = v7185 |> Error
                                                                                                                                                        let _v7188 = v7197 
                                                                                                                                                        #endif
                                                                                                                                                        let v7198 : Result<std_path_PathBuf, std_io_Error> = _v7188 
                                                                                                                                                        v7198
                                                                                                                                                | US8_0(v6361) -> (* Ok *)
                                                                                                                                                    let v6362 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v6363 : string = "Ok($0)"
                                                                                                                                                    let v6364 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6361 v6363 
                                                                                                                                                    let _v6362 = v6364 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v6365 : string = "Ok($0)"
                                                                                                                                                    let v6366 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6361 v6365 
                                                                                                                                                    let _v6362 = v6366 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v6367 : string = "Ok($0)"
                                                                                                                                                    let v6368 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6361 v6367 
                                                                                                                                                    let _v6362 = v6368 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v6369 : Result<std_path_PathBuf, std_io_Error> = v6361 |> Ok
                                                                                                                                                    let _v6362 = v6369 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v6370 : Result<std_path_PathBuf, std_io_Error> = v6361 |> Ok
                                                                                                                                                    let _v6362 = v6370 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v6371 : Result<std_path_PathBuf, std_io_Error> = v6361 |> Ok
                                                                                                                                                    let _v6362 = v6371 
                                                                                                                                                    #endif
                                                                                                                                                    let v6372 : Result<std_path_PathBuf, std_io_Error> = _v6362 
                                                                                                                                                    v6372
                                                                                                                                            let v7204 : (std_io_Error -> string) = method41()
                                                                                                                                            let v7205 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v7206 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v7207 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7203, v7204) v7206 
                                                                                                                                            let _v7205 = v7207 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v7208 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v7209 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7203, v7204) v7208 
                                                                                                                                            let _v7205 = v7209 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v7210 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v7211 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7203, v7204) v7210 
                                                                                                                                            let _v7205 = v7211 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v7212 : Result<std_path_PathBuf, string> = match v7203 with Ok x -> Ok x | Error x -> Error (v7204 x)
                                                                                                                                            let _v7205 = v7212 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v7213 : Result<std_path_PathBuf, string> = match v7203 with Ok x -> Ok x | Error x -> Error (v7204 x)
                                                                                                                                            let _v7205 = v7213 
                                                                                                                                            #endif
#else
                                                                                                                                            let v7214 : Result<std_path_PathBuf, string> = match v7203 with Ok x -> Ok x | Error x -> Error (v7204 x)
                                                                                                                                            let _v7205 = v7214 
                                                                                                                                            #endif
                                                                                                                                            let v7215 : Result<std_path_PathBuf, string> = _v7205 
                                                                                                                                            let v7218 : US8 = match v7215 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                                            match v7218 with
                                                                                                                                            | US8_1(v7321) -> (* Error *)
                                                                                                                                                let v7322 : string = $"file_system.read_link / error': {v7321} / error: {v6320} / name: {v6321}"
                                                                                                                                                let v7323 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v7324 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v7325 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7322 v7324 
                                                                                                                                                let _v7323 = v7325 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v7326 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v7327 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7322 v7326 
                                                                                                                                                let _v7323 = v7327 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v7328 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v7329 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7322 v7328 
                                                                                                                                                let _v7323 = v7329 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v7330 : std_io_Error = v7322 
                                                                                                                                                let _v7323 = v7330 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v7331 : std_io_Error = v7322 
                                                                                                                                                let _v7323 = v7331 
                                                                                                                                                #endif
#else
                                                                                                                                                let v7332 : std_io_Error = v7322 
                                                                                                                                                let _v7323 = v7332 
                                                                                                                                                #endif
                                                                                                                                                let v7333 : std_io_Error = _v7323 
                                                                                                                                                let v7336 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v7337 : string = "Err($0)"
                                                                                                                                                let v7338 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7333 v7337 
                                                                                                                                                let _v7336 = v7338 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v7339 : string = "Err($0)"
                                                                                                                                                let v7340 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7333 v7339 
                                                                                                                                                let _v7336 = v7340 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v7341 : string = "Err($0)"
                                                                                                                                                let v7342 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7333 v7341 
                                                                                                                                                let _v7336 = v7342 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v7343 : Result<std_path_PathBuf, std_io_Error> = v7333 |> Error
                                                                                                                                                let _v7336 = v7343 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v7344 : Result<std_path_PathBuf, std_io_Error> = v7333 |> Error
                                                                                                                                                let _v7336 = v7344 
                                                                                                                                                #endif
#else
                                                                                                                                                let v7345 : Result<std_path_PathBuf, std_io_Error> = v7333 |> Error
                                                                                                                                                let _v7336 = v7345 
                                                                                                                                                #endif
                                                                                                                                                let v7346 : Result<std_path_PathBuf, std_io_Error> = _v7336 
                                                                                                                                                v7346
                                                                                                                                            | US8_0(v7219) -> (* Ok *)
                                                                                                                                                let v7220 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v7221 : string = "$0.display()"
                                                                                                                                                let v7222 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7219 v7221 
                                                                                                                                                let _v7220 = v7222 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v7223 : string = "$0.display()"
                                                                                                                                                let v7224 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7219 v7223 
                                                                                                                                                let _v7220 = v7224 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v7225 : string = "$0.display()"
                                                                                                                                                let v7226 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7219 v7225 
                                                                                                                                                let _v7220 = v7226 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v7227 : std_path_Display = v7219 |> unbox<std_path_Display>
                                                                                                                                                let _v7220 = v7227 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v7230 : std_path_Display = v7219 |> unbox<std_path_Display>
                                                                                                                                                let _v7220 = v7230 
                                                                                                                                                #endif
#else
                                                                                                                                                let v7233 : std_path_Display = v7219 |> unbox<std_path_Display>
                                                                                                                                                let _v7220 = v7233 
                                                                                                                                                #endif
                                                                                                                                                let v7236 : std_path_Display = _v7220 
                                                                                                                                                let v7241 : string = v7236 |> string 
                                                                                                                                                let v7244 : string = method26(v7241, v6321)
                                                                                                                                                let v7245 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v7246 : string = "&*$0"
                                                                                                                                                let v7247 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7244 v7246 
                                                                                                                                                let _v7245 = v7247 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v7248 : string = "&*$0"
                                                                                                                                                let v7249 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7244 v7248 
                                                                                                                                                let _v7245 = v7249 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v7250 : string = "&*$0"
                                                                                                                                                let v7251 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7244 v7250 
                                                                                                                                                let _v7245 = v7251 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v7252 : Ref<Str> = v7244 |> unbox<Ref<Str>>
                                                                                                                                                let _v7245 = v7252 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v7255 : Ref<Str> = v7244 |> unbox<Ref<Str>>
                                                                                                                                                let _v7245 = v7255 
                                                                                                                                                #endif
#else
                                                                                                                                                let v7258 : Ref<Str> = v7244 |> unbox<Ref<Str>>
                                                                                                                                                let _v7245 = v7258 
                                                                                                                                                #endif
                                                                                                                                                let v7261 : Ref<Str> = _v7245 
                                                                                                                                                let v7266 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v7267 : string = "String::from($0)"
                                                                                                                                                let v7268 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7261 v7267 
                                                                                                                                                let _v7266 = v7268 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v7269 : string = "String::from($0)"
                                                                                                                                                let v7270 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7261 v7269 
                                                                                                                                                let _v7266 = v7270 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v7271 : string = "String::from($0)"
                                                                                                                                                let v7272 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7261 v7271 
                                                                                                                                                let _v7266 = v7272 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v7273 : std_string_String = v7261 |> unbox<std_string_String>
                                                                                                                                                let _v7266 = v7273 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v7276 : std_string_String = v7261 |> unbox<std_string_String>
                                                                                                                                                let _v7266 = v7276 
                                                                                                                                                #endif
#else
                                                                                                                                                let v7279 : std_string_String = v7261 |> unbox<std_string_String>
                                                                                                                                                let _v7266 = v7279 
                                                                                                                                                #endif
                                                                                                                                                let v7282 : std_string_String = _v7266 
                                                                                                                                                let v7287 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v7288 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                let v7289 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7282 v7288 
                                                                                                                                                let _v7287 = v7289 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v7290 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                let v7291 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7282 v7290 
                                                                                                                                                let _v7287 = v7291 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v7292 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                let v7293 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7282 v7292 
                                                                                                                                                let _v7287 = v7293 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v7294 : std_path_PathBuf = v7282 |> std_path_PathBuf 
                                                                                                                                                let _v7287 = v7294 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v7297 : std_path_PathBuf = v7282 |> std_path_PathBuf 
                                                                                                                                                let _v7287 = v7297 
                                                                                                                                                #endif
#else
                                                                                                                                                let v7300 : std_path_PathBuf = v7282 |> std_path_PathBuf 
                                                                                                                                                let _v7287 = v7300 
                                                                                                                                                #endif
                                                                                                                                                let v7303 : std_path_PathBuf = _v7287 
                                                                                                                                                let v7308 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v7309 : string = "Ok($0)"
                                                                                                                                                let v7310 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7303 v7309 
                                                                                                                                                let _v7308 = v7310 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v7311 : string = "Ok($0)"
                                                                                                                                                let v7312 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7303 v7311 
                                                                                                                                                let _v7308 = v7312 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v7313 : string = "Ok($0)"
                                                                                                                                                let v7314 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7303 v7313 
                                                                                                                                                let _v7308 = v7314 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v7315 : Result<std_path_PathBuf, std_io_Error> = v7303 |> Ok
                                                                                                                                                let _v7308 = v7315 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v7316 : Result<std_path_PathBuf, std_io_Error> = v7303 |> Ok
                                                                                                                                                let _v7308 = v7316 
                                                                                                                                                #endif
#else
                                                                                                                                                let v7317 : Result<std_path_PathBuf, std_io_Error> = v7303 |> Ok
                                                                                                                                                let _v7308 = v7317 
                                                                                                                                                #endif
                                                                                                                                                let v7318 : Result<std_path_PathBuf, std_io_Error> = _v7308 
                                                                                                                                                v7318
                                                                                                                                        else
                                                                                                                                            let v7351 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v6320} / path': {v6285} / name: {v6321}"
                                                                                                                                            let v7352 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v7353 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v7354 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7351 v7353 
                                                                                                                                            let _v7352 = v7354 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v7355 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v7356 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7351 v7355 
                                                                                                                                            let _v7352 = v7356 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v7357 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v7358 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7351 v7357 
                                                                                                                                            let _v7352 = v7358 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v7359 : std_io_Error = v7351 
                                                                                                                                            let _v7352 = v7359 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v7360 : std_io_Error = v7351 
                                                                                                                                            let _v7352 = v7360 
                                                                                                                                            #endif
#else
                                                                                                                                            let v7361 : std_io_Error = v7351 
                                                                                                                                            let _v7352 = v7361 
                                                                                                                                            #endif
                                                                                                                                            let v7362 : std_io_Error = _v7352 
                                                                                                                                            let v7365 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v7366 : string = "Err($0)"
                                                                                                                                            let v7367 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7362 v7366 
                                                                                                                                            let _v7365 = v7367 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v7368 : string = "Err($0)"
                                                                                                                                            let v7369 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7362 v7368 
                                                                                                                                            let _v7365 = v7369 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v7370 : string = "Err($0)"
                                                                                                                                            let v7371 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7362 v7370 
                                                                                                                                            let _v7365 = v7371 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v7372 : Result<std_path_PathBuf, std_io_Error> = v7362 |> Error
                                                                                                                                            let _v7365 = v7372 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v7373 : Result<std_path_PathBuf, std_io_Error> = v7362 |> Error
                                                                                                                                            let _v7365 = v7373 
                                                                                                                                            #endif
#else
                                                                                                                                            let v7374 : Result<std_path_PathBuf, std_io_Error> = v7362 |> Error
                                                                                                                                            let _v7365 = v7374 
                                                                                                                                            #endif
                                                                                                                                            let v7375 : Result<std_path_PathBuf, std_io_Error> = _v7365 
                                                                                                                                            v7375
                                                                                                                                    | _ ->
                                                                                                                                        let v7379 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v6320} / path': {v6285} / name: {v6321}"
                                                                                                                                        let v7380 : unit = ()
                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                        let v7381 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                        let v7382 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7379 v7381 
                                                                                                                                        let _v7380 = v7382 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                        let v7383 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                        let v7384 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7379 v7383 
                                                                                                                                        let _v7380 = v7384 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                        let v7385 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                        let v7386 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7379 v7385 
                                                                                                                                        let _v7380 = v7386 
                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                        let v7387 : std_io_Error = v7379 
                                                                                                                                        let _v7380 = v7387 
                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                        let v7388 : std_io_Error = v7379 
                                                                                                                                        let _v7380 = v7388 
                                                                                                                                        #endif
#else
                                                                                                                                        let v7389 : std_io_Error = v7379 
                                                                                                                                        let _v7380 = v7389 
                                                                                                                                        #endif
                                                                                                                                        let v7390 : std_io_Error = _v7380 
                                                                                                                                        let v7393 : unit = ()
                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                        let v7394 : string = "Err($0)"
                                                                                                                                        let v7395 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7390 v7394 
                                                                                                                                        let _v7393 = v7395 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                        let v7396 : string = "Err($0)"
                                                                                                                                        let v7397 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7390 v7396 
                                                                                                                                        let _v7393 = v7397 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                        let v7398 : string = "Err($0)"
                                                                                                                                        let v7399 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7390 v7398 
                                                                                                                                        let _v7393 = v7399 
                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                        let v7400 : Result<std_path_PathBuf, std_io_Error> = v7390 |> Error
                                                                                                                                        let _v7393 = v7400 
                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                        let v7401 : Result<std_path_PathBuf, std_io_Error> = v7390 |> Error
                                                                                                                                        let _v7393 = v7401 
                                                                                                                                        #endif
#else
                                                                                                                                        let v7402 : Result<std_path_PathBuf, std_io_Error> = v7390 |> Error
                                                                                                                                        let _v7393 = v7402 
                                                                                                                                        #endif
                                                                                                                                        let v7403 : Result<std_path_PathBuf, std_io_Error> = _v7393 
                                                                                                                                        v7403
                                                                                                                                | US8_0(v6306) -> (* Ok *)
                                                                                                                                    let v6307 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v6308 : string = "Ok($0)"
                                                                                                                                    let v6309 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6306 v6308 
                                                                                                                                    let _v6307 = v6309 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v6310 : string = "Ok($0)"
                                                                                                                                    let v6311 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6306 v6310 
                                                                                                                                    let _v6307 = v6311 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v6312 : string = "Ok($0)"
                                                                                                                                    let v6313 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6306 v6312 
                                                                                                                                    let _v6307 = v6313 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v6314 : Result<std_path_PathBuf, std_io_Error> = v6306 |> Ok
                                                                                                                                    let _v6307 = v6314 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v6315 : Result<std_path_PathBuf, std_io_Error> = v6306 |> Ok
                                                                                                                                    let _v6307 = v6315 
                                                                                                                                    #endif
#else
                                                                                                                                    let v6316 : Result<std_path_PathBuf, std_io_Error> = v6306 |> Ok
                                                                                                                                    let _v6307 = v6316 
                                                                                                                                    #endif
                                                                                                                                    let v6317 : Result<std_path_PathBuf, std_io_Error> = _v6307 
                                                                                                                                    v6317
                                                                                                                            let v7409 : (std_io_Error -> string) = method41()
                                                                                                                            let v7410 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v7411 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v7412 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7408, v7409) v7411 
                                                                                                                            let _v7410 = v7412 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v7413 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v7414 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7408, v7409) v7413 
                                                                                                                            let _v7410 = v7414 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v7415 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v7416 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7408, v7409) v7415 
                                                                                                                            let _v7410 = v7416 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v7417 : Result<std_path_PathBuf, string> = match v7408 with Ok x -> Ok x | Error x -> Error (v7409 x)
                                                                                                                            let _v7410 = v7417 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v7418 : Result<std_path_PathBuf, string> = match v7408 with Ok x -> Ok x | Error x -> Error (v7409 x)
                                                                                                                            let _v7410 = v7418 
                                                                                                                            #endif
#else
                                                                                                                            let v7419 : Result<std_path_PathBuf, string> = match v7408 with Ok x -> Ok x | Error x -> Error (v7409 x)
                                                                                                                            let _v7410 = v7419 
                                                                                                                            #endif
                                                                                                                            let v7420 : Result<std_path_PathBuf, string> = _v7410 
                                                                                                                            let v7423 : US8 = match v7420 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                            match v7423 with
                                                                                                                            | US8_1(v7526) -> (* Error *)
                                                                                                                                let v7527 : string = $"file_system.read_link / error': {v7526} / error: {v6265} / name: {v6266}"
                                                                                                                                let v7528 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v7529 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v7530 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7527 v7529 
                                                                                                                                let _v7528 = v7530 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v7531 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v7532 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7527 v7531 
                                                                                                                                let _v7528 = v7532 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v7533 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v7534 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7527 v7533 
                                                                                                                                let _v7528 = v7534 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v7535 : std_io_Error = v7527 
                                                                                                                                let _v7528 = v7535 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v7536 : std_io_Error = v7527 
                                                                                                                                let _v7528 = v7536 
                                                                                                                                #endif
#else
                                                                                                                                let v7537 : std_io_Error = v7527 
                                                                                                                                let _v7528 = v7537 
                                                                                                                                #endif
                                                                                                                                let v7538 : std_io_Error = _v7528 
                                                                                                                                let v7541 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v7542 : string = "Err($0)"
                                                                                                                                let v7543 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7538 v7542 
                                                                                                                                let _v7541 = v7543 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v7544 : string = "Err($0)"
                                                                                                                                let v7545 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7538 v7544 
                                                                                                                                let _v7541 = v7545 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v7546 : string = "Err($0)"
                                                                                                                                let v7547 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7538 v7546 
                                                                                                                                let _v7541 = v7547 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v7548 : Result<std_path_PathBuf, std_io_Error> = v7538 |> Error
                                                                                                                                let _v7541 = v7548 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v7549 : Result<std_path_PathBuf, std_io_Error> = v7538 |> Error
                                                                                                                                let _v7541 = v7549 
                                                                                                                                #endif
#else
                                                                                                                                let v7550 : Result<std_path_PathBuf, std_io_Error> = v7538 |> Error
                                                                                                                                let _v7541 = v7550 
                                                                                                                                #endif
                                                                                                                                let v7551 : Result<std_path_PathBuf, std_io_Error> = _v7541 
                                                                                                                                v7551
                                                                                                                            | US8_0(v7424) -> (* Ok *)
                                                                                                                                let v7425 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v7426 : string = "$0.display()"
                                                                                                                                let v7427 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7424 v7426 
                                                                                                                                let _v7425 = v7427 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v7428 : string = "$0.display()"
                                                                                                                                let v7429 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7424 v7428 
                                                                                                                                let _v7425 = v7429 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v7430 : string = "$0.display()"
                                                                                                                                let v7431 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7424 v7430 
                                                                                                                                let _v7425 = v7431 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v7432 : std_path_Display = v7424 |> unbox<std_path_Display>
                                                                                                                                let _v7425 = v7432 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v7435 : std_path_Display = v7424 |> unbox<std_path_Display>
                                                                                                                                let _v7425 = v7435 
                                                                                                                                #endif
#else
                                                                                                                                let v7438 : std_path_Display = v7424 |> unbox<std_path_Display>
                                                                                                                                let _v7425 = v7438 
                                                                                                                                #endif
                                                                                                                                let v7441 : std_path_Display = _v7425 
                                                                                                                                let v7446 : string = v7441 |> string 
                                                                                                                                let v7449 : string = method26(v7446, v6266)
                                                                                                                                let v7450 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v7451 : string = "&*$0"
                                                                                                                                let v7452 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7449 v7451 
                                                                                                                                let _v7450 = v7452 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v7453 : string = "&*$0"
                                                                                                                                let v7454 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7449 v7453 
                                                                                                                                let _v7450 = v7454 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v7455 : string = "&*$0"
                                                                                                                                let v7456 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7449 v7455 
                                                                                                                                let _v7450 = v7456 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v7457 : Ref<Str> = v7449 |> unbox<Ref<Str>>
                                                                                                                                let _v7450 = v7457 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v7460 : Ref<Str> = v7449 |> unbox<Ref<Str>>
                                                                                                                                let _v7450 = v7460 
                                                                                                                                #endif
#else
                                                                                                                                let v7463 : Ref<Str> = v7449 |> unbox<Ref<Str>>
                                                                                                                                let _v7450 = v7463 
                                                                                                                                #endif
                                                                                                                                let v7466 : Ref<Str> = _v7450 
                                                                                                                                let v7471 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v7472 : string = "String::from($0)"
                                                                                                                                let v7473 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7466 v7472 
                                                                                                                                let _v7471 = v7473 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v7474 : string = "String::from($0)"
                                                                                                                                let v7475 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7466 v7474 
                                                                                                                                let _v7471 = v7475 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v7476 : string = "String::from($0)"
                                                                                                                                let v7477 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7466 v7476 
                                                                                                                                let _v7471 = v7477 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v7478 : std_string_String = v7466 |> unbox<std_string_String>
                                                                                                                                let _v7471 = v7478 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v7481 : std_string_String = v7466 |> unbox<std_string_String>
                                                                                                                                let _v7471 = v7481 
                                                                                                                                #endif
#else
                                                                                                                                let v7484 : std_string_String = v7466 |> unbox<std_string_String>
                                                                                                                                let _v7471 = v7484 
                                                                                                                                #endif
                                                                                                                                let v7487 : std_string_String = _v7471 
                                                                                                                                let v7492 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v7493 : string = "std::path::PathBuf::from($0)"
                                                                                                                                let v7494 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7487 v7493 
                                                                                                                                let _v7492 = v7494 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v7495 : string = "std::path::PathBuf::from($0)"
                                                                                                                                let v7496 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7487 v7495 
                                                                                                                                let _v7492 = v7496 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v7497 : string = "std::path::PathBuf::from($0)"
                                                                                                                                let v7498 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7487 v7497 
                                                                                                                                let _v7492 = v7498 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v7499 : std_path_PathBuf = v7487 |> std_path_PathBuf 
                                                                                                                                let _v7492 = v7499 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v7502 : std_path_PathBuf = v7487 |> std_path_PathBuf 
                                                                                                                                let _v7492 = v7502 
                                                                                                                                #endif
#else
                                                                                                                                let v7505 : std_path_PathBuf = v7487 |> std_path_PathBuf 
                                                                                                                                let _v7492 = v7505 
                                                                                                                                #endif
                                                                                                                                let v7508 : std_path_PathBuf = _v7492 
                                                                                                                                let v7513 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v7514 : string = "Ok($0)"
                                                                                                                                let v7515 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7508 v7514 
                                                                                                                                let _v7513 = v7515 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v7516 : string = "Ok($0)"
                                                                                                                                let v7517 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7508 v7516 
                                                                                                                                let _v7513 = v7517 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v7518 : string = "Ok($0)"
                                                                                                                                let v7519 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7508 v7518 
                                                                                                                                let _v7513 = v7519 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v7520 : Result<std_path_PathBuf, std_io_Error> = v7508 |> Ok
                                                                                                                                let _v7513 = v7520 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v7521 : Result<std_path_PathBuf, std_io_Error> = v7508 |> Ok
                                                                                                                                let _v7513 = v7521 
                                                                                                                                #endif
#else
                                                                                                                                let v7522 : Result<std_path_PathBuf, std_io_Error> = v7508 |> Ok
                                                                                                                                let _v7513 = v7522 
                                                                                                                                #endif
                                                                                                                                let v7523 : Result<std_path_PathBuf, std_io_Error> = _v7513 
                                                                                                                                v7523
                                                                                                                        else
                                                                                                                            let v7556 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v6265} / path': {v6230} / name: {v6266}"
                                                                                                                            let v7557 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v7558 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v7559 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7556 v7558 
                                                                                                                            let _v7557 = v7559 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v7560 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v7561 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7556 v7560 
                                                                                                                            let _v7557 = v7561 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v7562 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v7563 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7556 v7562 
                                                                                                                            let _v7557 = v7563 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v7564 : std_io_Error = v7556 
                                                                                                                            let _v7557 = v7564 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v7565 : std_io_Error = v7556 
                                                                                                                            let _v7557 = v7565 
                                                                                                                            #endif
#else
                                                                                                                            let v7566 : std_io_Error = v7556 
                                                                                                                            let _v7557 = v7566 
                                                                                                                            #endif
                                                                                                                            let v7567 : std_io_Error = _v7557 
                                                                                                                            let v7570 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v7571 : string = "Err($0)"
                                                                                                                            let v7572 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7567 v7571 
                                                                                                                            let _v7570 = v7572 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v7573 : string = "Err($0)"
                                                                                                                            let v7574 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7567 v7573 
                                                                                                                            let _v7570 = v7574 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v7575 : string = "Err($0)"
                                                                                                                            let v7576 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7567 v7575 
                                                                                                                            let _v7570 = v7576 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v7577 : Result<std_path_PathBuf, std_io_Error> = v7567 |> Error
                                                                                                                            let _v7570 = v7577 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v7578 : Result<std_path_PathBuf, std_io_Error> = v7567 |> Error
                                                                                                                            let _v7570 = v7578 
                                                                                                                            #endif
#else
                                                                                                                            let v7579 : Result<std_path_PathBuf, std_io_Error> = v7567 |> Error
                                                                                                                            let _v7570 = v7579 
                                                                                                                            #endif
                                                                                                                            let v7580 : Result<std_path_PathBuf, std_io_Error> = _v7570 
                                                                                                                            v7580
                                                                                                                    | _ ->
                                                                                                                        let v7584 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v6265} / path': {v6230} / name: {v6266}"
                                                                                                                        let v7585 : unit = ()
                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                        let v7586 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                        let v7587 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7584 v7586 
                                                                                                                        let _v7585 = v7587 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                        let v7588 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                        let v7589 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7584 v7588 
                                                                                                                        let _v7585 = v7589 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                        let v7590 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                        let v7591 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7584 v7590 
                                                                                                                        let _v7585 = v7591 
                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                        let v7592 : std_io_Error = v7584 
                                                                                                                        let _v7585 = v7592 
                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                        let v7593 : std_io_Error = v7584 
                                                                                                                        let _v7585 = v7593 
                                                                                                                        #endif
#else
                                                                                                                        let v7594 : std_io_Error = v7584 
                                                                                                                        let _v7585 = v7594 
                                                                                                                        #endif
                                                                                                                        let v7595 : std_io_Error = _v7585 
                                                                                                                        let v7598 : unit = ()
                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                        let v7599 : string = "Err($0)"
                                                                                                                        let v7600 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7595 v7599 
                                                                                                                        let _v7598 = v7600 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                        let v7601 : string = "Err($0)"
                                                                                                                        let v7602 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7595 v7601 
                                                                                                                        let _v7598 = v7602 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                        let v7603 : string = "Err($0)"
                                                                                                                        let v7604 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7595 v7603 
                                                                                                                        let _v7598 = v7604 
                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                        let v7605 : Result<std_path_PathBuf, std_io_Error> = v7595 |> Error
                                                                                                                        let _v7598 = v7605 
                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                        let v7606 : Result<std_path_PathBuf, std_io_Error> = v7595 |> Error
                                                                                                                        let _v7598 = v7606 
                                                                                                                        #endif
#else
                                                                                                                        let v7607 : Result<std_path_PathBuf, std_io_Error> = v7595 |> Error
                                                                                                                        let _v7598 = v7607 
                                                                                                                        #endif
                                                                                                                        let v7608 : Result<std_path_PathBuf, std_io_Error> = _v7598 
                                                                                                                        v7608
                                                                                                                | US8_0(v6251) -> (* Ok *)
                                                                                                                    let v6252 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v6253 : string = "Ok($0)"
                                                                                                                    let v6254 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6251 v6253 
                                                                                                                    let _v6252 = v6254 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v6255 : string = "Ok($0)"
                                                                                                                    let v6256 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6251 v6255 
                                                                                                                    let _v6252 = v6256 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v6257 : string = "Ok($0)"
                                                                                                                    let v6258 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6251 v6257 
                                                                                                                    let _v6252 = v6258 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v6259 : Result<std_path_PathBuf, std_io_Error> = v6251 |> Ok
                                                                                                                    let _v6252 = v6259 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v6260 : Result<std_path_PathBuf, std_io_Error> = v6251 |> Ok
                                                                                                                    let _v6252 = v6260 
                                                                                                                    #endif
#else
                                                                                                                    let v6261 : Result<std_path_PathBuf, std_io_Error> = v6251 |> Ok
                                                                                                                    let _v6252 = v6261 
                                                                                                                    #endif
                                                                                                                    let v6262 : Result<std_path_PathBuf, std_io_Error> = _v6252 
                                                                                                                    v6262
                                                                                                            let v7614 : (std_io_Error -> string) = method41()
                                                                                                            let v7615 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v7616 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v7617 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7613, v7614) v7616 
                                                                                                            let _v7615 = v7617 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v7618 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v7619 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7613, v7614) v7618 
                                                                                                            let _v7615 = v7619 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v7620 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v7621 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7613, v7614) v7620 
                                                                                                            let _v7615 = v7621 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v7622 : Result<std_path_PathBuf, string> = match v7613 with Ok x -> Ok x | Error x -> Error (v7614 x)
                                                                                                            let _v7615 = v7622 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v7623 : Result<std_path_PathBuf, string> = match v7613 with Ok x -> Ok x | Error x -> Error (v7614 x)
                                                                                                            let _v7615 = v7623 
                                                                                                            #endif
#else
                                                                                                            let v7624 : Result<std_path_PathBuf, string> = match v7613 with Ok x -> Ok x | Error x -> Error (v7614 x)
                                                                                                            let _v7615 = v7624 
                                                                                                            #endif
                                                                                                            let v7625 : Result<std_path_PathBuf, string> = _v7615 
                                                                                                            let v7628 : US8 = match v7625 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                            match v7628 with
                                                                                                            | US8_1(v7731) -> (* Error *)
                                                                                                                let v7732 : string = $"file_system.read_link / error': {v7731} / error: {v6210} / name: {v6211}"
                                                                                                                let v7733 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v7734 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v7735 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7732 v7734 
                                                                                                                let _v7733 = v7735 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v7736 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v7737 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7732 v7736 
                                                                                                                let _v7733 = v7737 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v7738 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v7739 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7732 v7738 
                                                                                                                let _v7733 = v7739 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v7740 : std_io_Error = v7732 
                                                                                                                let _v7733 = v7740 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v7741 : std_io_Error = v7732 
                                                                                                                let _v7733 = v7741 
                                                                                                                #endif
#else
                                                                                                                let v7742 : std_io_Error = v7732 
                                                                                                                let _v7733 = v7742 
                                                                                                                #endif
                                                                                                                let v7743 : std_io_Error = _v7733 
                                                                                                                let v7746 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v7747 : string = "Err($0)"
                                                                                                                let v7748 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7743 v7747 
                                                                                                                let _v7746 = v7748 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v7749 : string = "Err($0)"
                                                                                                                let v7750 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7743 v7749 
                                                                                                                let _v7746 = v7750 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v7751 : string = "Err($0)"
                                                                                                                let v7752 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7743 v7751 
                                                                                                                let _v7746 = v7752 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v7753 : Result<std_path_PathBuf, std_io_Error> = v7743 |> Error
                                                                                                                let _v7746 = v7753 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v7754 : Result<std_path_PathBuf, std_io_Error> = v7743 |> Error
                                                                                                                let _v7746 = v7754 
                                                                                                                #endif
#else
                                                                                                                let v7755 : Result<std_path_PathBuf, std_io_Error> = v7743 |> Error
                                                                                                                let _v7746 = v7755 
                                                                                                                #endif
                                                                                                                let v7756 : Result<std_path_PathBuf, std_io_Error> = _v7746 
                                                                                                                v7756
                                                                                                            | US8_0(v7629) -> (* Ok *)
                                                                                                                let v7630 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v7631 : string = "$0.display()"
                                                                                                                let v7632 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7629 v7631 
                                                                                                                let _v7630 = v7632 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v7633 : string = "$0.display()"
                                                                                                                let v7634 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7629 v7633 
                                                                                                                let _v7630 = v7634 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v7635 : string = "$0.display()"
                                                                                                                let v7636 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7629 v7635 
                                                                                                                let _v7630 = v7636 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v7637 : std_path_Display = v7629 |> unbox<std_path_Display>
                                                                                                                let _v7630 = v7637 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v7640 : std_path_Display = v7629 |> unbox<std_path_Display>
                                                                                                                let _v7630 = v7640 
                                                                                                                #endif
#else
                                                                                                                let v7643 : std_path_Display = v7629 |> unbox<std_path_Display>
                                                                                                                let _v7630 = v7643 
                                                                                                                #endif
                                                                                                                let v7646 : std_path_Display = _v7630 
                                                                                                                let v7651 : string = v7646 |> string 
                                                                                                                let v7654 : string = method26(v7651, v6211)
                                                                                                                let v7655 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v7656 : string = "&*$0"
                                                                                                                let v7657 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7654 v7656 
                                                                                                                let _v7655 = v7657 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v7658 : string = "&*$0"
                                                                                                                let v7659 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7654 v7658 
                                                                                                                let _v7655 = v7659 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v7660 : string = "&*$0"
                                                                                                                let v7661 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7654 v7660 
                                                                                                                let _v7655 = v7661 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v7662 : Ref<Str> = v7654 |> unbox<Ref<Str>>
                                                                                                                let _v7655 = v7662 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v7665 : Ref<Str> = v7654 |> unbox<Ref<Str>>
                                                                                                                let _v7655 = v7665 
                                                                                                                #endif
#else
                                                                                                                let v7668 : Ref<Str> = v7654 |> unbox<Ref<Str>>
                                                                                                                let _v7655 = v7668 
                                                                                                                #endif
                                                                                                                let v7671 : Ref<Str> = _v7655 
                                                                                                                let v7676 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v7677 : string = "String::from($0)"
                                                                                                                let v7678 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7671 v7677 
                                                                                                                let _v7676 = v7678 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v7679 : string = "String::from($0)"
                                                                                                                let v7680 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7671 v7679 
                                                                                                                let _v7676 = v7680 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v7681 : string = "String::from($0)"
                                                                                                                let v7682 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7671 v7681 
                                                                                                                let _v7676 = v7682 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v7683 : std_string_String = v7671 |> unbox<std_string_String>
                                                                                                                let _v7676 = v7683 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v7686 : std_string_String = v7671 |> unbox<std_string_String>
                                                                                                                let _v7676 = v7686 
                                                                                                                #endif
#else
                                                                                                                let v7689 : std_string_String = v7671 |> unbox<std_string_String>
                                                                                                                let _v7676 = v7689 
                                                                                                                #endif
                                                                                                                let v7692 : std_string_String = _v7676 
                                                                                                                let v7697 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v7698 : string = "std::path::PathBuf::from($0)"
                                                                                                                let v7699 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7692 v7698 
                                                                                                                let _v7697 = v7699 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v7700 : string = "std::path::PathBuf::from($0)"
                                                                                                                let v7701 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7692 v7700 
                                                                                                                let _v7697 = v7701 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v7702 : string = "std::path::PathBuf::from($0)"
                                                                                                                let v7703 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7692 v7702 
                                                                                                                let _v7697 = v7703 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v7704 : std_path_PathBuf = v7692 |> std_path_PathBuf 
                                                                                                                let _v7697 = v7704 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v7707 : std_path_PathBuf = v7692 |> std_path_PathBuf 
                                                                                                                let _v7697 = v7707 
                                                                                                                #endif
#else
                                                                                                                let v7710 : std_path_PathBuf = v7692 |> std_path_PathBuf 
                                                                                                                let _v7697 = v7710 
                                                                                                                #endif
                                                                                                                let v7713 : std_path_PathBuf = _v7697 
                                                                                                                let v7718 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v7719 : string = "Ok($0)"
                                                                                                                let v7720 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7713 v7719 
                                                                                                                let _v7718 = v7720 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v7721 : string = "Ok($0)"
                                                                                                                let v7722 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7713 v7721 
                                                                                                                let _v7718 = v7722 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v7723 : string = "Ok($0)"
                                                                                                                let v7724 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7713 v7723 
                                                                                                                let _v7718 = v7724 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v7725 : Result<std_path_PathBuf, std_io_Error> = v7713 |> Ok
                                                                                                                let _v7718 = v7725 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v7726 : Result<std_path_PathBuf, std_io_Error> = v7713 |> Ok
                                                                                                                let _v7718 = v7726 
                                                                                                                #endif
#else
                                                                                                                let v7727 : Result<std_path_PathBuf, std_io_Error> = v7713 |> Ok
                                                                                                                let _v7718 = v7727 
                                                                                                                #endif
                                                                                                                let v7728 : Result<std_path_PathBuf, std_io_Error> = _v7718 
                                                                                                                v7728
                                                                                                        else
                                                                                                            let v7761 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v6210} / path': {v6175} / name: {v6211}"
                                                                                                            let v7762 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v7763 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v7764 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7761 v7763 
                                                                                                            let _v7762 = v7764 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v7765 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v7766 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7761 v7765 
                                                                                                            let _v7762 = v7766 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v7767 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v7768 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7761 v7767 
                                                                                                            let _v7762 = v7768 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v7769 : std_io_Error = v7761 
                                                                                                            let _v7762 = v7769 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v7770 : std_io_Error = v7761 
                                                                                                            let _v7762 = v7770 
                                                                                                            #endif
#else
                                                                                                            let v7771 : std_io_Error = v7761 
                                                                                                            let _v7762 = v7771 
                                                                                                            #endif
                                                                                                            let v7772 : std_io_Error = _v7762 
                                                                                                            let v7775 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v7776 : string = "Err($0)"
                                                                                                            let v7777 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7772 v7776 
                                                                                                            let _v7775 = v7777 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v7778 : string = "Err($0)"
                                                                                                            let v7779 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7772 v7778 
                                                                                                            let _v7775 = v7779 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v7780 : string = "Err($0)"
                                                                                                            let v7781 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7772 v7780 
                                                                                                            let _v7775 = v7781 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v7782 : Result<std_path_PathBuf, std_io_Error> = v7772 |> Error
                                                                                                            let _v7775 = v7782 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v7783 : Result<std_path_PathBuf, std_io_Error> = v7772 |> Error
                                                                                                            let _v7775 = v7783 
                                                                                                            #endif
#else
                                                                                                            let v7784 : Result<std_path_PathBuf, std_io_Error> = v7772 |> Error
                                                                                                            let _v7775 = v7784 
                                                                                                            #endif
                                                                                                            let v7785 : Result<std_path_PathBuf, std_io_Error> = _v7775 
                                                                                                            v7785
                                                                                                    | _ ->
                                                                                                        let v7789 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v6210} / path': {v6175} / name: {v6211}"
                                                                                                        let v7790 : unit = ()
                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                        let v7791 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                        let v7792 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7789 v7791 
                                                                                                        let _v7790 = v7792 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                        let v7793 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                        let v7794 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7789 v7793 
                                                                                                        let _v7790 = v7794 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                        let v7795 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                        let v7796 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7789 v7795 
                                                                                                        let _v7790 = v7796 
                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                        let v7797 : std_io_Error = v7789 
                                                                                                        let _v7790 = v7797 
                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                        let v7798 : std_io_Error = v7789 
                                                                                                        let _v7790 = v7798 
                                                                                                        #endif
#else
                                                                                                        let v7799 : std_io_Error = v7789 
                                                                                                        let _v7790 = v7799 
                                                                                                        #endif
                                                                                                        let v7800 : std_io_Error = _v7790 
                                                                                                        let v7803 : unit = ()
                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                        let v7804 : string = "Err($0)"
                                                                                                        let v7805 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7800 v7804 
                                                                                                        let _v7803 = v7805 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                        let v7806 : string = "Err($0)"
                                                                                                        let v7807 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7800 v7806 
                                                                                                        let _v7803 = v7807 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                        let v7808 : string = "Err($0)"
                                                                                                        let v7809 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7800 v7808 
                                                                                                        let _v7803 = v7809 
                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                        let v7810 : Result<std_path_PathBuf, std_io_Error> = v7800 |> Error
                                                                                                        let _v7803 = v7810 
                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                        let v7811 : Result<std_path_PathBuf, std_io_Error> = v7800 |> Error
                                                                                                        let _v7803 = v7811 
                                                                                                        #endif
#else
                                                                                                        let v7812 : Result<std_path_PathBuf, std_io_Error> = v7800 |> Error
                                                                                                        let _v7803 = v7812 
                                                                                                        #endif
                                                                                                        let v7813 : Result<std_path_PathBuf, std_io_Error> = _v7803 
                                                                                                        v7813
                                                                                                | US8_0(v6196) -> (* Ok *)
                                                                                                    let v6197 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v6198 : string = "Ok($0)"
                                                                                                    let v6199 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6196 v6198 
                                                                                                    let _v6197 = v6199 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v6200 : string = "Ok($0)"
                                                                                                    let v6201 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6196 v6200 
                                                                                                    let _v6197 = v6201 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v6202 : string = "Ok($0)"
                                                                                                    let v6203 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6196 v6202 
                                                                                                    let _v6197 = v6203 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v6204 : Result<std_path_PathBuf, std_io_Error> = v6196 |> Ok
                                                                                                    let _v6197 = v6204 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v6205 : Result<std_path_PathBuf, std_io_Error> = v6196 |> Ok
                                                                                                    let _v6197 = v6205 
                                                                                                    #endif
#else
                                                                                                    let v6206 : Result<std_path_PathBuf, std_io_Error> = v6196 |> Ok
                                                                                                    let _v6197 = v6206 
                                                                                                    #endif
                                                                                                    let v6207 : Result<std_path_PathBuf, std_io_Error> = _v6197 
                                                                                                    v6207
                                                                                            let v7819 : (std_io_Error -> string) = method41()
                                                                                            let v7820 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v7821 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v7822 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7818, v7819) v7821 
                                                                                            let _v7820 = v7822 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v7823 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v7824 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7818, v7819) v7823 
                                                                                            let _v7820 = v7824 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v7825 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v7826 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7818, v7819) v7825 
                                                                                            let _v7820 = v7826 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v7827 : Result<std_path_PathBuf, string> = match v7818 with Ok x -> Ok x | Error x -> Error (v7819 x)
                                                                                            let _v7820 = v7827 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v7828 : Result<std_path_PathBuf, string> = match v7818 with Ok x -> Ok x | Error x -> Error (v7819 x)
                                                                                            let _v7820 = v7828 
                                                                                            #endif
#else
                                                                                            let v7829 : Result<std_path_PathBuf, string> = match v7818 with Ok x -> Ok x | Error x -> Error (v7819 x)
                                                                                            let _v7820 = v7829 
                                                                                            #endif
                                                                                            let v7830 : Result<std_path_PathBuf, string> = _v7820 
                                                                                            let v7833 : US8 = match v7830 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                            match v7833 with
                                                                                            | US8_1(v7936) -> (* Error *)
                                                                                                let v7937 : string = $"file_system.read_link / error': {v7936} / error: {v6155} / name: {v6156}"
                                                                                                let v7938 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v7939 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v7940 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7937 v7939 
                                                                                                let _v7938 = v7940 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v7941 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v7942 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7937 v7941 
                                                                                                let _v7938 = v7942 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v7943 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v7944 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7937 v7943 
                                                                                                let _v7938 = v7944 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v7945 : std_io_Error = v7937 
                                                                                                let _v7938 = v7945 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v7946 : std_io_Error = v7937 
                                                                                                let _v7938 = v7946 
                                                                                                #endif
#else
                                                                                                let v7947 : std_io_Error = v7937 
                                                                                                let _v7938 = v7947 
                                                                                                #endif
                                                                                                let v7948 : std_io_Error = _v7938 
                                                                                                let v7951 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v7952 : string = "Err($0)"
                                                                                                let v7953 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7948 v7952 
                                                                                                let _v7951 = v7953 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v7954 : string = "Err($0)"
                                                                                                let v7955 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7948 v7954 
                                                                                                let _v7951 = v7955 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v7956 : string = "Err($0)"
                                                                                                let v7957 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7948 v7956 
                                                                                                let _v7951 = v7957 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v7958 : Result<std_path_PathBuf, std_io_Error> = v7948 |> Error
                                                                                                let _v7951 = v7958 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v7959 : Result<std_path_PathBuf, std_io_Error> = v7948 |> Error
                                                                                                let _v7951 = v7959 
                                                                                                #endif
#else
                                                                                                let v7960 : Result<std_path_PathBuf, std_io_Error> = v7948 |> Error
                                                                                                let _v7951 = v7960 
                                                                                                #endif
                                                                                                let v7961 : Result<std_path_PathBuf, std_io_Error> = _v7951 
                                                                                                v7961
                                                                                            | US8_0(v7834) -> (* Ok *)
                                                                                                let v7835 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v7836 : string = "$0.display()"
                                                                                                let v7837 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7834 v7836 
                                                                                                let _v7835 = v7837 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v7838 : string = "$0.display()"
                                                                                                let v7839 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7834 v7838 
                                                                                                let _v7835 = v7839 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v7840 : string = "$0.display()"
                                                                                                let v7841 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7834 v7840 
                                                                                                let _v7835 = v7841 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v7842 : std_path_Display = v7834 |> unbox<std_path_Display>
                                                                                                let _v7835 = v7842 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v7845 : std_path_Display = v7834 |> unbox<std_path_Display>
                                                                                                let _v7835 = v7845 
                                                                                                #endif
#else
                                                                                                let v7848 : std_path_Display = v7834 |> unbox<std_path_Display>
                                                                                                let _v7835 = v7848 
                                                                                                #endif
                                                                                                let v7851 : std_path_Display = _v7835 
                                                                                                let v7856 : string = v7851 |> string 
                                                                                                let v7859 : string = method26(v7856, v6156)
                                                                                                let v7860 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v7861 : string = "&*$0"
                                                                                                let v7862 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7859 v7861 
                                                                                                let _v7860 = v7862 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v7863 : string = "&*$0"
                                                                                                let v7864 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7859 v7863 
                                                                                                let _v7860 = v7864 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v7865 : string = "&*$0"
                                                                                                let v7866 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7859 v7865 
                                                                                                let _v7860 = v7866 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v7867 : Ref<Str> = v7859 |> unbox<Ref<Str>>
                                                                                                let _v7860 = v7867 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v7870 : Ref<Str> = v7859 |> unbox<Ref<Str>>
                                                                                                let _v7860 = v7870 
                                                                                                #endif
#else
                                                                                                let v7873 : Ref<Str> = v7859 |> unbox<Ref<Str>>
                                                                                                let _v7860 = v7873 
                                                                                                #endif
                                                                                                let v7876 : Ref<Str> = _v7860 
                                                                                                let v7881 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v7882 : string = "String::from($0)"
                                                                                                let v7883 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7876 v7882 
                                                                                                let _v7881 = v7883 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v7884 : string = "String::from($0)"
                                                                                                let v7885 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7876 v7884 
                                                                                                let _v7881 = v7885 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v7886 : string = "String::from($0)"
                                                                                                let v7887 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7876 v7886 
                                                                                                let _v7881 = v7887 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v7888 : std_string_String = v7876 |> unbox<std_string_String>
                                                                                                let _v7881 = v7888 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v7891 : std_string_String = v7876 |> unbox<std_string_String>
                                                                                                let _v7881 = v7891 
                                                                                                #endif
#else
                                                                                                let v7894 : std_string_String = v7876 |> unbox<std_string_String>
                                                                                                let _v7881 = v7894 
                                                                                                #endif
                                                                                                let v7897 : std_string_String = _v7881 
                                                                                                let v7902 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v7903 : string = "std::path::PathBuf::from($0)"
                                                                                                let v7904 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7897 v7903 
                                                                                                let _v7902 = v7904 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v7905 : string = "std::path::PathBuf::from($0)"
                                                                                                let v7906 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7897 v7905 
                                                                                                let _v7902 = v7906 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v7907 : string = "std::path::PathBuf::from($0)"
                                                                                                let v7908 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7897 v7907 
                                                                                                let _v7902 = v7908 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v7909 : std_path_PathBuf = v7897 |> std_path_PathBuf 
                                                                                                let _v7902 = v7909 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v7912 : std_path_PathBuf = v7897 |> std_path_PathBuf 
                                                                                                let _v7902 = v7912 
                                                                                                #endif
#else
                                                                                                let v7915 : std_path_PathBuf = v7897 |> std_path_PathBuf 
                                                                                                let _v7902 = v7915 
                                                                                                #endif
                                                                                                let v7918 : std_path_PathBuf = _v7902 
                                                                                                let v7923 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v7924 : string = "Ok($0)"
                                                                                                let v7925 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7918 v7924 
                                                                                                let _v7923 = v7925 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v7926 : string = "Ok($0)"
                                                                                                let v7927 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7918 v7926 
                                                                                                let _v7923 = v7927 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v7928 : string = "Ok($0)"
                                                                                                let v7929 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7918 v7928 
                                                                                                let _v7923 = v7929 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v7930 : Result<std_path_PathBuf, std_io_Error> = v7918 |> Ok
                                                                                                let _v7923 = v7930 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v7931 : Result<std_path_PathBuf, std_io_Error> = v7918 |> Ok
                                                                                                let _v7923 = v7931 
                                                                                                #endif
#else
                                                                                                let v7932 : Result<std_path_PathBuf, std_io_Error> = v7918 |> Ok
                                                                                                let _v7923 = v7932 
                                                                                                #endif
                                                                                                let v7933 : Result<std_path_PathBuf, std_io_Error> = _v7923 
                                                                                                v7933
                                                                                        else
                                                                                            let v7966 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v6155} / path': {v6120} / name: {v6156}"
                                                                                            let v7967 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v7968 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v7969 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7966 v7968 
                                                                                            let _v7967 = v7969 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v7970 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v7971 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7966 v7970 
                                                                                            let _v7967 = v7971 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v7972 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v7973 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7966 v7972 
                                                                                            let _v7967 = v7973 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v7974 : std_io_Error = v7966 
                                                                                            let _v7967 = v7974 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v7975 : std_io_Error = v7966 
                                                                                            let _v7967 = v7975 
                                                                                            #endif
#else
                                                                                            let v7976 : std_io_Error = v7966 
                                                                                            let _v7967 = v7976 
                                                                                            #endif
                                                                                            let v7977 : std_io_Error = _v7967 
                                                                                            let v7980 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v7981 : string = "Err($0)"
                                                                                            let v7982 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7977 v7981 
                                                                                            let _v7980 = v7982 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v7983 : string = "Err($0)"
                                                                                            let v7984 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7977 v7983 
                                                                                            let _v7980 = v7984 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v7985 : string = "Err($0)"
                                                                                            let v7986 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7977 v7985 
                                                                                            let _v7980 = v7986 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v7987 : Result<std_path_PathBuf, std_io_Error> = v7977 |> Error
                                                                                            let _v7980 = v7987 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v7988 : Result<std_path_PathBuf, std_io_Error> = v7977 |> Error
                                                                                            let _v7980 = v7988 
                                                                                            #endif
#else
                                                                                            let v7989 : Result<std_path_PathBuf, std_io_Error> = v7977 |> Error
                                                                                            let _v7980 = v7989 
                                                                                            #endif
                                                                                            let v7990 : Result<std_path_PathBuf, std_io_Error> = _v7980 
                                                                                            v7990
                                                                                    | _ ->
                                                                                        let v7994 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v6155} / path': {v6120} / name: {v6156}"
                                                                                        let v7995 : unit = ()
                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                        let v7996 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                        let v7997 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7994 v7996 
                                                                                        let _v7995 = v7997 
                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                        let v7998 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                        let v7999 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7994 v7998 
                                                                                        let _v7995 = v7999 
                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                        let v8000 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                        let v8001 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7994 v8000 
                                                                                        let _v7995 = v8001 
                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                        let v8002 : std_io_Error = v7994 
                                                                                        let _v7995 = v8002 
                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                        let v8003 : std_io_Error = v7994 
                                                                                        let _v7995 = v8003 
                                                                                        #endif
#else
                                                                                        let v8004 : std_io_Error = v7994 
                                                                                        let _v7995 = v8004 
                                                                                        #endif
                                                                                        let v8005 : std_io_Error = _v7995 
                                                                                        let v8008 : unit = ()
                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                        let v8009 : string = "Err($0)"
                                                                                        let v8010 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8005 v8009 
                                                                                        let _v8008 = v8010 
                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                        let v8011 : string = "Err($0)"
                                                                                        let v8012 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8005 v8011 
                                                                                        let _v8008 = v8012 
                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                        let v8013 : string = "Err($0)"
                                                                                        let v8014 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8005 v8013 
                                                                                        let _v8008 = v8014 
                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                        let v8015 : Result<std_path_PathBuf, std_io_Error> = v8005 |> Error
                                                                                        let _v8008 = v8015 
                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                        let v8016 : Result<std_path_PathBuf, std_io_Error> = v8005 |> Error
                                                                                        let _v8008 = v8016 
                                                                                        #endif
#else
                                                                                        let v8017 : Result<std_path_PathBuf, std_io_Error> = v8005 |> Error
                                                                                        let _v8008 = v8017 
                                                                                        #endif
                                                                                        let v8018 : Result<std_path_PathBuf, std_io_Error> = _v8008 
                                                                                        v8018
                                                                                | US8_0(v6141) -> (* Ok *)
                                                                                    let v6142 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v6143 : string = "Ok($0)"
                                                                                    let v6144 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6141 v6143 
                                                                                    let _v6142 = v6144 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v6145 : string = "Ok($0)"
                                                                                    let v6146 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6141 v6145 
                                                                                    let _v6142 = v6146 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v6147 : string = "Ok($0)"
                                                                                    let v6148 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6141 v6147 
                                                                                    let _v6142 = v6148 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v6149 : Result<std_path_PathBuf, std_io_Error> = v6141 |> Ok
                                                                                    let _v6142 = v6149 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v6150 : Result<std_path_PathBuf, std_io_Error> = v6141 |> Ok
                                                                                    let _v6142 = v6150 
                                                                                    #endif
#else
                                                                                    let v6151 : Result<std_path_PathBuf, std_io_Error> = v6141 |> Ok
                                                                                    let _v6142 = v6151 
                                                                                    #endif
                                                                                    let v6152 : Result<std_path_PathBuf, std_io_Error> = _v6142 
                                                                                    v6152
                                                                            let v8024 : (std_io_Error -> string) = method41()
                                                                            let v8025 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v8026 : string = "$0.map_err(|x| $1(x))"
                                                                            let v8027 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8023, v8024) v8026 
                                                                            let _v8025 = v8027 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v8028 : string = "$0.map_err(|x| $1(x))"
                                                                            let v8029 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8023, v8024) v8028 
                                                                            let _v8025 = v8029 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v8030 : string = "$0.map_err(|x| $1(x))"
                                                                            let v8031 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8023, v8024) v8030 
                                                                            let _v8025 = v8031 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v8032 : Result<std_path_PathBuf, string> = match v8023 with Ok x -> Ok x | Error x -> Error (v8024 x)
                                                                            let _v8025 = v8032 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v8033 : Result<std_path_PathBuf, string> = match v8023 with Ok x -> Ok x | Error x -> Error (v8024 x)
                                                                            let _v8025 = v8033 
                                                                            #endif
#else
                                                                            let v8034 : Result<std_path_PathBuf, string> = match v8023 with Ok x -> Ok x | Error x -> Error (v8024 x)
                                                                            let _v8025 = v8034 
                                                                            #endif
                                                                            let v8035 : Result<std_path_PathBuf, string> = _v8025 
                                                                            let v8038 : US8 = match v8035 with Ok x -> v5917 x | Error x -> v5918 x
                                                                            match v8038 with
                                                                            | US8_1(v8141) -> (* Error *)
                                                                                let v8142 : string = $"file_system.read_link / error': {v8141} / error: {v6100} / name: {v6101}"
                                                                                let v8143 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v8144 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v8145 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8142 v8144 
                                                                                let _v8143 = v8145 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v8146 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v8147 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8142 v8146 
                                                                                let _v8143 = v8147 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v8148 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v8149 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8142 v8148 
                                                                                let _v8143 = v8149 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v8150 : std_io_Error = v8142 
                                                                                let _v8143 = v8150 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v8151 : std_io_Error = v8142 
                                                                                let _v8143 = v8151 
                                                                                #endif
#else
                                                                                let v8152 : std_io_Error = v8142 
                                                                                let _v8143 = v8152 
                                                                                #endif
                                                                                let v8153 : std_io_Error = _v8143 
                                                                                let v8156 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v8157 : string = "Err($0)"
                                                                                let v8158 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8153 v8157 
                                                                                let _v8156 = v8158 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v8159 : string = "Err($0)"
                                                                                let v8160 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8153 v8159 
                                                                                let _v8156 = v8160 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v8161 : string = "Err($0)"
                                                                                let v8162 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8153 v8161 
                                                                                let _v8156 = v8162 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v8163 : Result<std_path_PathBuf, std_io_Error> = v8153 |> Error
                                                                                let _v8156 = v8163 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v8164 : Result<std_path_PathBuf, std_io_Error> = v8153 |> Error
                                                                                let _v8156 = v8164 
                                                                                #endif
#else
                                                                                let v8165 : Result<std_path_PathBuf, std_io_Error> = v8153 |> Error
                                                                                let _v8156 = v8165 
                                                                                #endif
                                                                                let v8166 : Result<std_path_PathBuf, std_io_Error> = _v8156 
                                                                                v8166
                                                                            | US8_0(v8039) -> (* Ok *)
                                                                                let v8040 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v8041 : string = "$0.display()"
                                                                                let v8042 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8039 v8041 
                                                                                let _v8040 = v8042 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v8043 : string = "$0.display()"
                                                                                let v8044 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8039 v8043 
                                                                                let _v8040 = v8044 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v8045 : string = "$0.display()"
                                                                                let v8046 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8039 v8045 
                                                                                let _v8040 = v8046 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v8047 : std_path_Display = v8039 |> unbox<std_path_Display>
                                                                                let _v8040 = v8047 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v8050 : std_path_Display = v8039 |> unbox<std_path_Display>
                                                                                let _v8040 = v8050 
                                                                                #endif
#else
                                                                                let v8053 : std_path_Display = v8039 |> unbox<std_path_Display>
                                                                                let _v8040 = v8053 
                                                                                #endif
                                                                                let v8056 : std_path_Display = _v8040 
                                                                                let v8061 : string = v8056 |> string 
                                                                                let v8064 : string = method26(v8061, v6101)
                                                                                let v8065 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v8066 : string = "&*$0"
                                                                                let v8067 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8064 v8066 
                                                                                let _v8065 = v8067 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v8068 : string = "&*$0"
                                                                                let v8069 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8064 v8068 
                                                                                let _v8065 = v8069 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v8070 : string = "&*$0"
                                                                                let v8071 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8064 v8070 
                                                                                let _v8065 = v8071 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v8072 : Ref<Str> = v8064 |> unbox<Ref<Str>>
                                                                                let _v8065 = v8072 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v8075 : Ref<Str> = v8064 |> unbox<Ref<Str>>
                                                                                let _v8065 = v8075 
                                                                                #endif
#else
                                                                                let v8078 : Ref<Str> = v8064 |> unbox<Ref<Str>>
                                                                                let _v8065 = v8078 
                                                                                #endif
                                                                                let v8081 : Ref<Str> = _v8065 
                                                                                let v8086 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v8087 : string = "String::from($0)"
                                                                                let v8088 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8081 v8087 
                                                                                let _v8086 = v8088 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v8089 : string = "String::from($0)"
                                                                                let v8090 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8081 v8089 
                                                                                let _v8086 = v8090 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v8091 : string = "String::from($0)"
                                                                                let v8092 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8081 v8091 
                                                                                let _v8086 = v8092 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v8093 : std_string_String = v8081 |> unbox<std_string_String>
                                                                                let _v8086 = v8093 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v8096 : std_string_String = v8081 |> unbox<std_string_String>
                                                                                let _v8086 = v8096 
                                                                                #endif
#else
                                                                                let v8099 : std_string_String = v8081 |> unbox<std_string_String>
                                                                                let _v8086 = v8099 
                                                                                #endif
                                                                                let v8102 : std_string_String = _v8086 
                                                                                let v8107 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v8108 : string = "std::path::PathBuf::from($0)"
                                                                                let v8109 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8102 v8108 
                                                                                let _v8107 = v8109 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v8110 : string = "std::path::PathBuf::from($0)"
                                                                                let v8111 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8102 v8110 
                                                                                let _v8107 = v8111 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v8112 : string = "std::path::PathBuf::from($0)"
                                                                                let v8113 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8102 v8112 
                                                                                let _v8107 = v8113 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v8114 : std_path_PathBuf = v8102 |> std_path_PathBuf 
                                                                                let _v8107 = v8114 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v8117 : std_path_PathBuf = v8102 |> std_path_PathBuf 
                                                                                let _v8107 = v8117 
                                                                                #endif
#else
                                                                                let v8120 : std_path_PathBuf = v8102 |> std_path_PathBuf 
                                                                                let _v8107 = v8120 
                                                                                #endif
                                                                                let v8123 : std_path_PathBuf = _v8107 
                                                                                let v8128 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v8129 : string = "Ok($0)"
                                                                                let v8130 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8123 v8129 
                                                                                let _v8128 = v8130 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v8131 : string = "Ok($0)"
                                                                                let v8132 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8123 v8131 
                                                                                let _v8128 = v8132 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v8133 : string = "Ok($0)"
                                                                                let v8134 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8123 v8133 
                                                                                let _v8128 = v8134 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v8135 : Result<std_path_PathBuf, std_io_Error> = v8123 |> Ok
                                                                                let _v8128 = v8135 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v8136 : Result<std_path_PathBuf, std_io_Error> = v8123 |> Ok
                                                                                let _v8128 = v8136 
                                                                                #endif
#else
                                                                                let v8137 : Result<std_path_PathBuf, std_io_Error> = v8123 |> Ok
                                                                                let _v8128 = v8137 
                                                                                #endif
                                                                                let v8138 : Result<std_path_PathBuf, std_io_Error> = _v8128 
                                                                                v8138
                                                                        else
                                                                            let v8171 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v6100} / path': {v6065} / name: {v6101}"
                                                                            let v8172 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v8173 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v8174 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8171 v8173 
                                                                            let _v8172 = v8174 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v8175 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v8176 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8171 v8175 
                                                                            let _v8172 = v8176 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v8177 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v8178 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8171 v8177 
                                                                            let _v8172 = v8178 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v8179 : std_io_Error = v8171 
                                                                            let _v8172 = v8179 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v8180 : std_io_Error = v8171 
                                                                            let _v8172 = v8180 
                                                                            #endif
#else
                                                                            let v8181 : std_io_Error = v8171 
                                                                            let _v8172 = v8181 
                                                                            #endif
                                                                            let v8182 : std_io_Error = _v8172 
                                                                            let v8185 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v8186 : string = "Err($0)"
                                                                            let v8187 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8182 v8186 
                                                                            let _v8185 = v8187 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v8188 : string = "Err($0)"
                                                                            let v8189 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8182 v8188 
                                                                            let _v8185 = v8189 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v8190 : string = "Err($0)"
                                                                            let v8191 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8182 v8190 
                                                                            let _v8185 = v8191 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v8192 : Result<std_path_PathBuf, std_io_Error> = v8182 |> Error
                                                                            let _v8185 = v8192 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v8193 : Result<std_path_PathBuf, std_io_Error> = v8182 |> Error
                                                                            let _v8185 = v8193 
                                                                            #endif
#else
                                                                            let v8194 : Result<std_path_PathBuf, std_io_Error> = v8182 |> Error
                                                                            let _v8185 = v8194 
                                                                            #endif
                                                                            let v8195 : Result<std_path_PathBuf, std_io_Error> = _v8185 
                                                                            v8195
                                                                    | _ ->
                                                                        let v8199 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v6100} / path': {v6065} / name: {v6101}"
                                                                        let v8200 : unit = ()
                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                        let v8201 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                        let v8202 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8199 v8201 
                                                                        let _v8200 = v8202 
                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                        let v8203 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                        let v8204 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8199 v8203 
                                                                        let _v8200 = v8204 
                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                        let v8205 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                        let v8206 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8199 v8205 
                                                                        let _v8200 = v8206 
                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                        let v8207 : std_io_Error = v8199 
                                                                        let _v8200 = v8207 
                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                        let v8208 : std_io_Error = v8199 
                                                                        let _v8200 = v8208 
                                                                        #endif
#else
                                                                        let v8209 : std_io_Error = v8199 
                                                                        let _v8200 = v8209 
                                                                        #endif
                                                                        let v8210 : std_io_Error = _v8200 
                                                                        let v8213 : unit = ()
                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                        let v8214 : string = "Err($0)"
                                                                        let v8215 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8210 v8214 
                                                                        let _v8213 = v8215 
                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                        let v8216 : string = "Err($0)"
                                                                        let v8217 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8210 v8216 
                                                                        let _v8213 = v8217 
                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                        let v8218 : string = "Err($0)"
                                                                        let v8219 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8210 v8218 
                                                                        let _v8213 = v8219 
                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                        let v8220 : Result<std_path_PathBuf, std_io_Error> = v8210 |> Error
                                                                        let _v8213 = v8220 
                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                        let v8221 : Result<std_path_PathBuf, std_io_Error> = v8210 |> Error
                                                                        let _v8213 = v8221 
                                                                        #endif
#else
                                                                        let v8222 : Result<std_path_PathBuf, std_io_Error> = v8210 |> Error
                                                                        let _v8213 = v8222 
                                                                        #endif
                                                                        let v8223 : Result<std_path_PathBuf, std_io_Error> = _v8213 
                                                                        v8223
                                                                | US8_0(v6086) -> (* Ok *)
                                                                    let v6087 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v6088 : string = "Ok($0)"
                                                                    let v6089 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6086 v6088 
                                                                    let _v6087 = v6089 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v6090 : string = "Ok($0)"
                                                                    let v6091 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6086 v6090 
                                                                    let _v6087 = v6091 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v6092 : string = "Ok($0)"
                                                                    let v6093 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6086 v6092 
                                                                    let _v6087 = v6093 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v6094 : Result<std_path_PathBuf, std_io_Error> = v6086 |> Ok
                                                                    let _v6087 = v6094 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v6095 : Result<std_path_PathBuf, std_io_Error> = v6086 |> Ok
                                                                    let _v6087 = v6095 
                                                                    #endif
#else
                                                                    let v6096 : Result<std_path_PathBuf, std_io_Error> = v6086 |> Ok
                                                                    let _v6087 = v6096 
                                                                    #endif
                                                                    let v6097 : Result<std_path_PathBuf, std_io_Error> = _v6087 
                                                                    v6097
                                                            let v8229 : (std_io_Error -> string) = method41()
                                                            let v8230 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v8231 : string = "$0.map_err(|x| $1(x))"
                                                            let v8232 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8228, v8229) v8231 
                                                            let _v8230 = v8232 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v8233 : string = "$0.map_err(|x| $1(x))"
                                                            let v8234 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8228, v8229) v8233 
                                                            let _v8230 = v8234 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v8235 : string = "$0.map_err(|x| $1(x))"
                                                            let v8236 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8228, v8229) v8235 
                                                            let _v8230 = v8236 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v8237 : Result<std_path_PathBuf, string> = match v8228 with Ok x -> Ok x | Error x -> Error (v8229 x)
                                                            let _v8230 = v8237 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v8238 : Result<std_path_PathBuf, string> = match v8228 with Ok x -> Ok x | Error x -> Error (v8229 x)
                                                            let _v8230 = v8238 
                                                            #endif
#else
                                                            let v8239 : Result<std_path_PathBuf, string> = match v8228 with Ok x -> Ok x | Error x -> Error (v8229 x)
                                                            let _v8230 = v8239 
                                                            #endif
                                                            let v8240 : Result<std_path_PathBuf, string> = _v8230 
                                                            let v8243 : US8 = match v8240 with Ok x -> v5917 x | Error x -> v5918 x
                                                            match v8243 with
                                                            | US8_1(v8346) -> (* Error *)
                                                                let v8347 : string = $"file_system.read_link / error': {v8346} / error: {v6045} / name: {v6046}"
                                                                let v8348 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v8349 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v8350 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8347 v8349 
                                                                let _v8348 = v8350 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v8351 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v8352 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8347 v8351 
                                                                let _v8348 = v8352 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v8353 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v8354 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8347 v8353 
                                                                let _v8348 = v8354 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v8355 : std_io_Error = v8347 
                                                                let _v8348 = v8355 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v8356 : std_io_Error = v8347 
                                                                let _v8348 = v8356 
                                                                #endif
#else
                                                                let v8357 : std_io_Error = v8347 
                                                                let _v8348 = v8357 
                                                                #endif
                                                                let v8358 : std_io_Error = _v8348 
                                                                let v8361 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v8362 : string = "Err($0)"
                                                                let v8363 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8358 v8362 
                                                                let _v8361 = v8363 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v8364 : string = "Err($0)"
                                                                let v8365 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8358 v8364 
                                                                let _v8361 = v8365 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v8366 : string = "Err($0)"
                                                                let v8367 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8358 v8366 
                                                                let _v8361 = v8367 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v8368 : Result<std_path_PathBuf, std_io_Error> = v8358 |> Error
                                                                let _v8361 = v8368 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v8369 : Result<std_path_PathBuf, std_io_Error> = v8358 |> Error
                                                                let _v8361 = v8369 
                                                                #endif
#else
                                                                let v8370 : Result<std_path_PathBuf, std_io_Error> = v8358 |> Error
                                                                let _v8361 = v8370 
                                                                #endif
                                                                let v8371 : Result<std_path_PathBuf, std_io_Error> = _v8361 
                                                                v8371
                                                            | US8_0(v8244) -> (* Ok *)
                                                                let v8245 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v8246 : string = "$0.display()"
                                                                let v8247 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8244 v8246 
                                                                let _v8245 = v8247 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v8248 : string = "$0.display()"
                                                                let v8249 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8244 v8248 
                                                                let _v8245 = v8249 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v8250 : string = "$0.display()"
                                                                let v8251 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8244 v8250 
                                                                let _v8245 = v8251 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v8252 : std_path_Display = v8244 |> unbox<std_path_Display>
                                                                let _v8245 = v8252 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v8255 : std_path_Display = v8244 |> unbox<std_path_Display>
                                                                let _v8245 = v8255 
                                                                #endif
#else
                                                                let v8258 : std_path_Display = v8244 |> unbox<std_path_Display>
                                                                let _v8245 = v8258 
                                                                #endif
                                                                let v8261 : std_path_Display = _v8245 
                                                                let v8266 : string = v8261 |> string 
                                                                let v8269 : string = method26(v8266, v6046)
                                                                let v8270 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v8271 : string = "&*$0"
                                                                let v8272 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8269 v8271 
                                                                let _v8270 = v8272 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v8273 : string = "&*$0"
                                                                let v8274 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8269 v8273 
                                                                let _v8270 = v8274 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v8275 : string = "&*$0"
                                                                let v8276 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8269 v8275 
                                                                let _v8270 = v8276 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v8277 : Ref<Str> = v8269 |> unbox<Ref<Str>>
                                                                let _v8270 = v8277 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v8280 : Ref<Str> = v8269 |> unbox<Ref<Str>>
                                                                let _v8270 = v8280 
                                                                #endif
#else
                                                                let v8283 : Ref<Str> = v8269 |> unbox<Ref<Str>>
                                                                let _v8270 = v8283 
                                                                #endif
                                                                let v8286 : Ref<Str> = _v8270 
                                                                let v8291 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v8292 : string = "String::from($0)"
                                                                let v8293 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8286 v8292 
                                                                let _v8291 = v8293 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v8294 : string = "String::from($0)"
                                                                let v8295 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8286 v8294 
                                                                let _v8291 = v8295 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v8296 : string = "String::from($0)"
                                                                let v8297 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8286 v8296 
                                                                let _v8291 = v8297 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v8298 : std_string_String = v8286 |> unbox<std_string_String>
                                                                let _v8291 = v8298 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v8301 : std_string_String = v8286 |> unbox<std_string_String>
                                                                let _v8291 = v8301 
                                                                #endif
#else
                                                                let v8304 : std_string_String = v8286 |> unbox<std_string_String>
                                                                let _v8291 = v8304 
                                                                #endif
                                                                let v8307 : std_string_String = _v8291 
                                                                let v8312 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v8313 : string = "std::path::PathBuf::from($0)"
                                                                let v8314 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8307 v8313 
                                                                let _v8312 = v8314 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v8315 : string = "std::path::PathBuf::from($0)"
                                                                let v8316 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8307 v8315 
                                                                let _v8312 = v8316 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v8317 : string = "std::path::PathBuf::from($0)"
                                                                let v8318 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8307 v8317 
                                                                let _v8312 = v8318 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v8319 : std_path_PathBuf = v8307 |> std_path_PathBuf 
                                                                let _v8312 = v8319 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v8322 : std_path_PathBuf = v8307 |> std_path_PathBuf 
                                                                let _v8312 = v8322 
                                                                #endif
#else
                                                                let v8325 : std_path_PathBuf = v8307 |> std_path_PathBuf 
                                                                let _v8312 = v8325 
                                                                #endif
                                                                let v8328 : std_path_PathBuf = _v8312 
                                                                let v8333 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v8334 : string = "Ok($0)"
                                                                let v8335 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8328 v8334 
                                                                let _v8333 = v8335 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v8336 : string = "Ok($0)"
                                                                let v8337 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8328 v8336 
                                                                let _v8333 = v8337 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v8338 : string = "Ok($0)"
                                                                let v8339 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8328 v8338 
                                                                let _v8333 = v8339 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v8340 : Result<std_path_PathBuf, std_io_Error> = v8328 |> Ok
                                                                let _v8333 = v8340 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v8341 : Result<std_path_PathBuf, std_io_Error> = v8328 |> Ok
                                                                let _v8333 = v8341 
                                                                #endif
#else
                                                                let v8342 : Result<std_path_PathBuf, std_io_Error> = v8328 |> Ok
                                                                let _v8333 = v8342 
                                                                #endif
                                                                let v8343 : Result<std_path_PathBuf, std_io_Error> = _v8333 
                                                                v8343
                                                        else
                                                            let v8376 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v6045} / path': {v6010} / name: {v6046}"
                                                            let v8377 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v8378 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v8379 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8376 v8378 
                                                            let _v8377 = v8379 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v8380 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v8381 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8376 v8380 
                                                            let _v8377 = v8381 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v8382 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v8383 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8376 v8382 
                                                            let _v8377 = v8383 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v8384 : std_io_Error = v8376 
                                                            let _v8377 = v8384 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v8385 : std_io_Error = v8376 
                                                            let _v8377 = v8385 
                                                            #endif
#else
                                                            let v8386 : std_io_Error = v8376 
                                                            let _v8377 = v8386 
                                                            #endif
                                                            let v8387 : std_io_Error = _v8377 
                                                            let v8390 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v8391 : string = "Err($0)"
                                                            let v8392 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8387 v8391 
                                                            let _v8390 = v8392 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v8393 : string = "Err($0)"
                                                            let v8394 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8387 v8393 
                                                            let _v8390 = v8394 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v8395 : string = "Err($0)"
                                                            let v8396 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8387 v8395 
                                                            let _v8390 = v8396 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v8397 : Result<std_path_PathBuf, std_io_Error> = v8387 |> Error
                                                            let _v8390 = v8397 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v8398 : Result<std_path_PathBuf, std_io_Error> = v8387 |> Error
                                                            let _v8390 = v8398 
                                                            #endif
#else
                                                            let v8399 : Result<std_path_PathBuf, std_io_Error> = v8387 |> Error
                                                            let _v8390 = v8399 
                                                            #endif
                                                            let v8400 : Result<std_path_PathBuf, std_io_Error> = _v8390 
                                                            v8400
                                                    | _ ->
                                                        let v8404 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v6045} / path': {v6010} / name: {v6046}"
                                                        let v8405 : unit = ()
                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                        let v8406 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                        let v8407 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8404 v8406 
                                                        let _v8405 = v8407 
                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                        let v8408 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                        let v8409 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8404 v8408 
                                                        let _v8405 = v8409 
                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                        let v8410 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                        let v8411 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8404 v8410 
                                                        let _v8405 = v8411 
                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                        let v8412 : std_io_Error = v8404 
                                                        let _v8405 = v8412 
                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                        let v8413 : std_io_Error = v8404 
                                                        let _v8405 = v8413 
                                                        #endif
#else
                                                        let v8414 : std_io_Error = v8404 
                                                        let _v8405 = v8414 
                                                        #endif
                                                        let v8415 : std_io_Error = _v8405 
                                                        let v8418 : unit = ()
                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                        let v8419 : string = "Err($0)"
                                                        let v8420 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8415 v8419 
                                                        let _v8418 = v8420 
                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                        let v8421 : string = "Err($0)"
                                                        let v8422 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8415 v8421 
                                                        let _v8418 = v8422 
                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                        let v8423 : string = "Err($0)"
                                                        let v8424 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8415 v8423 
                                                        let _v8418 = v8424 
                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                        let v8425 : Result<std_path_PathBuf, std_io_Error> = v8415 |> Error
                                                        let _v8418 = v8425 
                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                        let v8426 : Result<std_path_PathBuf, std_io_Error> = v8415 |> Error
                                                        let _v8418 = v8426 
                                                        #endif
#else
                                                        let v8427 : Result<std_path_PathBuf, std_io_Error> = v8415 |> Error
                                                        let _v8418 = v8427 
                                                        #endif
                                                        let v8428 : Result<std_path_PathBuf, std_io_Error> = _v8418 
                                                        v8428
                                                | US8_0(v6031) -> (* Ok *)
                                                    let v6032 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v6033 : string = "Ok($0)"
                                                    let v6034 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6031 v6033 
                                                    let _v6032 = v6034 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v6035 : string = "Ok($0)"
                                                    let v6036 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6031 v6035 
                                                    let _v6032 = v6036 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v6037 : string = "Ok($0)"
                                                    let v6038 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6031 v6037 
                                                    let _v6032 = v6038 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v6039 : Result<std_path_PathBuf, std_io_Error> = v6031 |> Ok
                                                    let _v6032 = v6039 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v6040 : Result<std_path_PathBuf, std_io_Error> = v6031 |> Ok
                                                    let _v6032 = v6040 
                                                    #endif
#else
                                                    let v6041 : Result<std_path_PathBuf, std_io_Error> = v6031 |> Ok
                                                    let _v6032 = v6041 
                                                    #endif
                                                    let v6042 : Result<std_path_PathBuf, std_io_Error> = _v6032 
                                                    v6042
                                            let v8434 : (std_io_Error -> string) = method41()
                                            let v8435 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v8436 : string = "$0.map_err(|x| $1(x))"
                                            let v8437 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8433, v8434) v8436 
                                            let _v8435 = v8437 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v8438 : string = "$0.map_err(|x| $1(x))"
                                            let v8439 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8433, v8434) v8438 
                                            let _v8435 = v8439 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v8440 : string = "$0.map_err(|x| $1(x))"
                                            let v8441 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8433, v8434) v8440 
                                            let _v8435 = v8441 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v8442 : Result<std_path_PathBuf, string> = match v8433 with Ok x -> Ok x | Error x -> Error (v8434 x)
                                            let _v8435 = v8442 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v8443 : Result<std_path_PathBuf, string> = match v8433 with Ok x -> Ok x | Error x -> Error (v8434 x)
                                            let _v8435 = v8443 
                                            #endif
#else
                                            let v8444 : Result<std_path_PathBuf, string> = match v8433 with Ok x -> Ok x | Error x -> Error (v8434 x)
                                            let _v8435 = v8444 
                                            #endif
                                            let v8445 : Result<std_path_PathBuf, string> = _v8435 
                                            let v8448 : US8 = match v8445 with Ok x -> v5917 x | Error x -> v5918 x
                                            match v8448 with
                                            | US8_1(v8551) -> (* Error *)
                                                let v8552 : string = $"file_system.read_link / error': {v8551} / error: {v5990} / name: {v5991}"
                                                let v8553 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v8554 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v8555 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8552 v8554 
                                                let _v8553 = v8555 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v8556 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v8557 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8552 v8556 
                                                let _v8553 = v8557 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v8558 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v8559 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8552 v8558 
                                                let _v8553 = v8559 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v8560 : std_io_Error = v8552 
                                                let _v8553 = v8560 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v8561 : std_io_Error = v8552 
                                                let _v8553 = v8561 
                                                #endif
#else
                                                let v8562 : std_io_Error = v8552 
                                                let _v8553 = v8562 
                                                #endif
                                                let v8563 : std_io_Error = _v8553 
                                                let v8566 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v8567 : string = "Err($0)"
                                                let v8568 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8563 v8567 
                                                let _v8566 = v8568 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v8569 : string = "Err($0)"
                                                let v8570 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8563 v8569 
                                                let _v8566 = v8570 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v8571 : string = "Err($0)"
                                                let v8572 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8563 v8571 
                                                let _v8566 = v8572 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v8573 : Result<std_path_PathBuf, std_io_Error> = v8563 |> Error
                                                let _v8566 = v8573 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v8574 : Result<std_path_PathBuf, std_io_Error> = v8563 |> Error
                                                let _v8566 = v8574 
                                                #endif
#else
                                                let v8575 : Result<std_path_PathBuf, std_io_Error> = v8563 |> Error
                                                let _v8566 = v8575 
                                                #endif
                                                let v8576 : Result<std_path_PathBuf, std_io_Error> = _v8566 
                                                v8576
                                            | US8_0(v8449) -> (* Ok *)
                                                let v8450 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v8451 : string = "$0.display()"
                                                let v8452 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8449 v8451 
                                                let _v8450 = v8452 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v8453 : string = "$0.display()"
                                                let v8454 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8449 v8453 
                                                let _v8450 = v8454 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v8455 : string = "$0.display()"
                                                let v8456 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8449 v8455 
                                                let _v8450 = v8456 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v8457 : std_path_Display = v8449 |> unbox<std_path_Display>
                                                let _v8450 = v8457 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v8460 : std_path_Display = v8449 |> unbox<std_path_Display>
                                                let _v8450 = v8460 
                                                #endif
#else
                                                let v8463 : std_path_Display = v8449 |> unbox<std_path_Display>
                                                let _v8450 = v8463 
                                                #endif
                                                let v8466 : std_path_Display = _v8450 
                                                let v8471 : string = v8466 |> string 
                                                let v8474 : string = method26(v8471, v5991)
                                                let v8475 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v8476 : string = "&*$0"
                                                let v8477 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8474 v8476 
                                                let _v8475 = v8477 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v8478 : string = "&*$0"
                                                let v8479 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8474 v8478 
                                                let _v8475 = v8479 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v8480 : string = "&*$0"
                                                let v8481 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8474 v8480 
                                                let _v8475 = v8481 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v8482 : Ref<Str> = v8474 |> unbox<Ref<Str>>
                                                let _v8475 = v8482 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v8485 : Ref<Str> = v8474 |> unbox<Ref<Str>>
                                                let _v8475 = v8485 
                                                #endif
#else
                                                let v8488 : Ref<Str> = v8474 |> unbox<Ref<Str>>
                                                let _v8475 = v8488 
                                                #endif
                                                let v8491 : Ref<Str> = _v8475 
                                                let v8496 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v8497 : string = "String::from($0)"
                                                let v8498 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8491 v8497 
                                                let _v8496 = v8498 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v8499 : string = "String::from($0)"
                                                let v8500 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8491 v8499 
                                                let _v8496 = v8500 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v8501 : string = "String::from($0)"
                                                let v8502 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8491 v8501 
                                                let _v8496 = v8502 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v8503 : std_string_String = v8491 |> unbox<std_string_String>
                                                let _v8496 = v8503 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v8506 : std_string_String = v8491 |> unbox<std_string_String>
                                                let _v8496 = v8506 
                                                #endif
#else
                                                let v8509 : std_string_String = v8491 |> unbox<std_string_String>
                                                let _v8496 = v8509 
                                                #endif
                                                let v8512 : std_string_String = _v8496 
                                                let v8517 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v8518 : string = "std::path::PathBuf::from($0)"
                                                let v8519 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8512 v8518 
                                                let _v8517 = v8519 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v8520 : string = "std::path::PathBuf::from($0)"
                                                let v8521 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8512 v8520 
                                                let _v8517 = v8521 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v8522 : string = "std::path::PathBuf::from($0)"
                                                let v8523 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8512 v8522 
                                                let _v8517 = v8523 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v8524 : std_path_PathBuf = v8512 |> std_path_PathBuf 
                                                let _v8517 = v8524 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v8527 : std_path_PathBuf = v8512 |> std_path_PathBuf 
                                                let _v8517 = v8527 
                                                #endif
#else
                                                let v8530 : std_path_PathBuf = v8512 |> std_path_PathBuf 
                                                let _v8517 = v8530 
                                                #endif
                                                let v8533 : std_path_PathBuf = _v8517 
                                                let v8538 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v8539 : string = "Ok($0)"
                                                let v8540 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8533 v8539 
                                                let _v8538 = v8540 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v8541 : string = "Ok($0)"
                                                let v8542 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8533 v8541 
                                                let _v8538 = v8542 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v8543 : string = "Ok($0)"
                                                let v8544 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8533 v8543 
                                                let _v8538 = v8544 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v8545 : Result<std_path_PathBuf, std_io_Error> = v8533 |> Ok
                                                let _v8538 = v8545 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v8546 : Result<std_path_PathBuf, std_io_Error> = v8533 |> Ok
                                                let _v8538 = v8546 
                                                #endif
#else
                                                let v8547 : Result<std_path_PathBuf, std_io_Error> = v8533 |> Ok
                                                let _v8538 = v8547 
                                                #endif
                                                let v8548 : Result<std_path_PathBuf, std_io_Error> = _v8538 
                                                v8548
                                        else
                                            let v8581 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v5990} / path': {v5954} / name: {v5991}"
                                            let v8582 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v8583 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v8584 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8581 v8583 
                                            let _v8582 = v8584 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v8585 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v8586 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8581 v8585 
                                            let _v8582 = v8586 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v8587 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v8588 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8581 v8587 
                                            let _v8582 = v8588 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v8589 : std_io_Error = v8581 
                                            let _v8582 = v8589 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v8590 : std_io_Error = v8581 
                                            let _v8582 = v8590 
                                            #endif
#else
                                            let v8591 : std_io_Error = v8581 
                                            let _v8582 = v8591 
                                            #endif
                                            let v8592 : std_io_Error = _v8582 
                                            let v8595 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v8596 : string = "Err($0)"
                                            let v8597 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8592 v8596 
                                            let _v8595 = v8597 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v8598 : string = "Err($0)"
                                            let v8599 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8592 v8598 
                                            let _v8595 = v8599 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v8600 : string = "Err($0)"
                                            let v8601 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8592 v8600 
                                            let _v8595 = v8601 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v8602 : Result<std_path_PathBuf, std_io_Error> = v8592 |> Error
                                            let _v8595 = v8602 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v8603 : Result<std_path_PathBuf, std_io_Error> = v8592 |> Error
                                            let _v8595 = v8603 
                                            #endif
#else
                                            let v8604 : Result<std_path_PathBuf, std_io_Error> = v8592 |> Error
                                            let _v8595 = v8604 
                                            #endif
                                            let v8605 : Result<std_path_PathBuf, std_io_Error> = _v8595 
                                            v8605
                                    | _ ->
                                        let v8609 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v5990} / path': {v5954} / name: {v5991}"
                                        let v8610 : unit = ()
                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                        let v8611 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                        let v8612 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8609 v8611 
                                        let _v8610 = v8612 
                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                        let v8613 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                        let v8614 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8609 v8613 
                                        let _v8610 = v8614 
                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                        let v8615 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                        let v8616 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8609 v8615 
                                        let _v8610 = v8616 
                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                        let v8617 : std_io_Error = v8609 
                                        let _v8610 = v8617 
                                        #endif
#if FABLE_COMPILER_PYTHON
                                        let v8618 : std_io_Error = v8609 
                                        let _v8610 = v8618 
                                        #endif
#else
                                        let v8619 : std_io_Error = v8609 
                                        let _v8610 = v8619 
                                        #endif
                                        let v8620 : std_io_Error = _v8610 
                                        let v8623 : unit = ()
                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                        let v8624 : string = "Err($0)"
                                        let v8625 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8620 v8624 
                                        let _v8623 = v8625 
                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                        let v8626 : string = "Err($0)"
                                        let v8627 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8620 v8626 
                                        let _v8623 = v8627 
                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                        let v8628 : string = "Err($0)"
                                        let v8629 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8620 v8628 
                                        let _v8623 = v8629 
                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                        let v8630 : Result<std_path_PathBuf, std_io_Error> = v8620 |> Error
                                        let _v8623 = v8630 
                                        #endif
#if FABLE_COMPILER_PYTHON
                                        let v8631 : Result<std_path_PathBuf, std_io_Error> = v8620 |> Error
                                        let _v8623 = v8631 
                                        #endif
#else
                                        let v8632 : Result<std_path_PathBuf, std_io_Error> = v8620 |> Error
                                        let _v8623 = v8632 
                                        #endif
                                        let v8633 : Result<std_path_PathBuf, std_io_Error> = _v8623 
                                        v8633
                                | US8_0(v5976) -> (* Ok *)
                                    let v5977 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v5978 : string = "Ok($0)"
                                    let v5979 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5976 v5978 
                                    let _v5977 = v5979 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v5980 : string = "Ok($0)"
                                    let v5981 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5976 v5980 
                                    let _v5977 = v5981 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v5982 : string = "Ok($0)"
                                    let v5983 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5976 v5982 
                                    let _v5977 = v5983 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v5984 : Result<std_path_PathBuf, std_io_Error> = v5976 |> Ok
                                    let _v5977 = v5984 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v5985 : Result<std_path_PathBuf, std_io_Error> = v5976 |> Ok
                                    let _v5977 = v5985 
                                    #endif
#else
                                    let v5986 : Result<std_path_PathBuf, std_io_Error> = v5976 |> Ok
                                    let _v5977 = v5986 
                                    #endif
                                    let v5987 : Result<std_path_PathBuf, std_io_Error> = _v5977 
                                    v5987
                            let v8639 : (std_io_Error -> string) = method41()
                            let v8640 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v8641 : string = "$0.map_err(|x| $1(x))"
                            let v8642 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8638, v8639) v8641 
                            let _v8640 = v8642 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v8643 : string = "$0.map_err(|x| $1(x))"
                            let v8644 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8638, v8639) v8643 
                            let _v8640 = v8644 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v8645 : string = "$0.map_err(|x| $1(x))"
                            let v8646 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8638, v8639) v8645 
                            let _v8640 = v8646 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v8647 : Result<std_path_PathBuf, string> = match v8638 with Ok x -> Ok x | Error x -> Error (v8639 x)
                            let _v8640 = v8647 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v8648 : Result<std_path_PathBuf, string> = match v8638 with Ok x -> Ok x | Error x -> Error (v8639 x)
                            let _v8640 = v8648 
                            #endif
#else
                            let v8649 : Result<std_path_PathBuf, string> = match v8638 with Ok x -> Ok x | Error x -> Error (v8639 x)
                            let _v8640 = v8649 
                            #endif
                            let v8650 : Result<std_path_PathBuf, string> = _v8640 
                            let v8653 : US8 = match v8650 with Ok x -> v5917 x | Error x -> v5918 x
                            match v8653 with
                            | US8_1(v8756) -> (* Error *)
                                let v8757 : string = $"file_system.read_link / error': {v8756} / error: {v5934} / name: {v5935}"
                                let v8758 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v8759 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v8760 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8757 v8759 
                                let _v8758 = v8760 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v8761 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v8762 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8757 v8761 
                                let _v8758 = v8762 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v8763 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v8764 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8757 v8763 
                                let _v8758 = v8764 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v8765 : std_io_Error = v8757 
                                let _v8758 = v8765 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v8766 : std_io_Error = v8757 
                                let _v8758 = v8766 
                                #endif
#else
                                let v8767 : std_io_Error = v8757 
                                let _v8758 = v8767 
                                #endif
                                let v8768 : std_io_Error = _v8758 
                                let v8771 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v8772 : string = "Err($0)"
                                let v8773 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8768 v8772 
                                let _v8771 = v8773 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v8774 : string = "Err($0)"
                                let v8775 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8768 v8774 
                                let _v8771 = v8775 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v8776 : string = "Err($0)"
                                let v8777 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8768 v8776 
                                let _v8771 = v8777 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v8778 : Result<std_path_PathBuf, std_io_Error> = v8768 |> Error
                                let _v8771 = v8778 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v8779 : Result<std_path_PathBuf, std_io_Error> = v8768 |> Error
                                let _v8771 = v8779 
                                #endif
#else
                                let v8780 : Result<std_path_PathBuf, std_io_Error> = v8768 |> Error
                                let _v8771 = v8780 
                                #endif
                                let v8781 : Result<std_path_PathBuf, std_io_Error> = _v8771 
                                v8781
                            | US8_0(v8654) -> (* Ok *)
                                let v8655 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v8656 : string = "$0.display()"
                                let v8657 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8654 v8656 
                                let _v8655 = v8657 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v8658 : string = "$0.display()"
                                let v8659 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8654 v8658 
                                let _v8655 = v8659 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v8660 : string = "$0.display()"
                                let v8661 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8654 v8660 
                                let _v8655 = v8661 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v8662 : std_path_Display = v8654 |> unbox<std_path_Display>
                                let _v8655 = v8662 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v8665 : std_path_Display = v8654 |> unbox<std_path_Display>
                                let _v8655 = v8665 
                                #endif
#else
                                let v8668 : std_path_Display = v8654 |> unbox<std_path_Display>
                                let _v8655 = v8668 
                                #endif
                                let v8671 : std_path_Display = _v8655 
                                let v8676 : string = v8671 |> string 
                                let v8679 : string = method26(v8676, v5935)
                                let v8680 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v8681 : string = "&*$0"
                                let v8682 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8679 v8681 
                                let _v8680 = v8682 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v8683 : string = "&*$0"
                                let v8684 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8679 v8683 
                                let _v8680 = v8684 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v8685 : string = "&*$0"
                                let v8686 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8679 v8685 
                                let _v8680 = v8686 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v8687 : Ref<Str> = v8679 |> unbox<Ref<Str>>
                                let _v8680 = v8687 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v8690 : Ref<Str> = v8679 |> unbox<Ref<Str>>
                                let _v8680 = v8690 
                                #endif
#else
                                let v8693 : Ref<Str> = v8679 |> unbox<Ref<Str>>
                                let _v8680 = v8693 
                                #endif
                                let v8696 : Ref<Str> = _v8680 
                                let v8701 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v8702 : string = "String::from($0)"
                                let v8703 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8696 v8702 
                                let _v8701 = v8703 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v8704 : string = "String::from($0)"
                                let v8705 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8696 v8704 
                                let _v8701 = v8705 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v8706 : string = "String::from($0)"
                                let v8707 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8696 v8706 
                                let _v8701 = v8707 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v8708 : std_string_String = v8696 |> unbox<std_string_String>
                                let _v8701 = v8708 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v8711 : std_string_String = v8696 |> unbox<std_string_String>
                                let _v8701 = v8711 
                                #endif
#else
                                let v8714 : std_string_String = v8696 |> unbox<std_string_String>
                                let _v8701 = v8714 
                                #endif
                                let v8717 : std_string_String = _v8701 
                                let v8722 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v8723 : string = "std::path::PathBuf::from($0)"
                                let v8724 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8717 v8723 
                                let _v8722 = v8724 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v8725 : string = "std::path::PathBuf::from($0)"
                                let v8726 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8717 v8725 
                                let _v8722 = v8726 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v8727 : string = "std::path::PathBuf::from($0)"
                                let v8728 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8717 v8727 
                                let _v8722 = v8728 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v8729 : std_path_PathBuf = v8717 |> std_path_PathBuf 
                                let _v8722 = v8729 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v8732 : std_path_PathBuf = v8717 |> std_path_PathBuf 
                                let _v8722 = v8732 
                                #endif
#else
                                let v8735 : std_path_PathBuf = v8717 |> std_path_PathBuf 
                                let _v8722 = v8735 
                                #endif
                                let v8738 : std_path_PathBuf = _v8722 
                                let v8743 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v8744 : string = "Ok($0)"
                                let v8745 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8738 v8744 
                                let _v8743 = v8745 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v8746 : string = "Ok($0)"
                                let v8747 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8738 v8746 
                                let _v8743 = v8747 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v8748 : string = "Ok($0)"
                                let v8749 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8738 v8748 
                                let _v8743 = v8749 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v8750 : Result<std_path_PathBuf, std_io_Error> = v8738 |> Ok
                                let _v8743 = v8750 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v8751 : Result<std_path_PathBuf, std_io_Error> = v8738 |> Ok
                                let _v8743 = v8751 
                                #endif
#else
                                let v8752 : Result<std_path_PathBuf, std_io_Error> = v8738 |> Ok
                                let _v8743 = v8752 
                                #endif
                                let v8753 : Result<std_path_PathBuf, std_io_Error> = _v8743 
                                v8753
                        else
                            let v8786 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v5934} / path': {v0} / name: {v5935}"
                            let v8787 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v8788 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v8789 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8786 v8788 
                            let _v8787 = v8789 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v8790 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v8791 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8786 v8790 
                            let _v8787 = v8791 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v8792 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v8793 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8786 v8792 
                            let _v8787 = v8793 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v8794 : std_io_Error = v8786 
                            let _v8787 = v8794 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v8795 : std_io_Error = v8786 
                            let _v8787 = v8795 
                            #endif
#else
                            let v8796 : std_io_Error = v8786 
                            let _v8787 = v8796 
                            #endif
                            let v8797 : std_io_Error = _v8787 
                            let v8800 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v8801 : string = "Err($0)"
                            let v8802 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8797 v8801 
                            let _v8800 = v8802 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v8803 : string = "Err($0)"
                            let v8804 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8797 v8803 
                            let _v8800 = v8804 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v8805 : string = "Err($0)"
                            let v8806 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8797 v8805 
                            let _v8800 = v8806 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v8807 : Result<std_path_PathBuf, std_io_Error> = v8797 |> Error
                            let _v8800 = v8807 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v8808 : Result<std_path_PathBuf, std_io_Error> = v8797 |> Error
                            let _v8800 = v8808 
                            #endif
#else
                            let v8809 : Result<std_path_PathBuf, std_io_Error> = v8797 |> Error
                            let _v8800 = v8809 
                            #endif
                            let v8810 : Result<std_path_PathBuf, std_io_Error> = _v8800 
                            v8810
                    | _ ->
                        let v8814 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v5934} / path': {v0} / name: {v5935}"
                        let v8815 : unit = ()
                        
#if FABLE_COMPILER || WASM || CONTRACT
                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                        let v8816 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                        let v8817 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8814 v8816 
                        let _v8815 = v8817 
                        #endif
#if FABLE_COMPILER_RUST && WASM
                        let v8818 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                        let v8819 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8814 v8818 
                        let _v8815 = v8819 
                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                        let v8820 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                        let v8821 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8814 v8820 
                        let _v8815 = v8821 
                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                        let v8822 : std_io_Error = v8814 
                        let _v8815 = v8822 
                        #endif
#if FABLE_COMPILER_PYTHON
                        let v8823 : std_io_Error = v8814 
                        let _v8815 = v8823 
                        #endif
#else
                        let v8824 : std_io_Error = v8814 
                        let _v8815 = v8824 
                        #endif
                        let v8825 : std_io_Error = _v8815 
                        let v8828 : unit = ()
                        
#if FABLE_COMPILER || WASM || CONTRACT
                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                        let v8829 : string = "Err($0)"
                        let v8830 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8825 v8829 
                        let _v8828 = v8830 
                        #endif
#if FABLE_COMPILER_RUST && WASM
                        let v8831 : string = "Err($0)"
                        let v8832 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8825 v8831 
                        let _v8828 = v8832 
                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                        let v8833 : string = "Err($0)"
                        let v8834 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8825 v8833 
                        let _v8828 = v8834 
                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                        let v8835 : Result<std_path_PathBuf, std_io_Error> = v8825 |> Error
                        let _v8828 = v8835 
                        #endif
#if FABLE_COMPILER_PYTHON
                        let v8836 : Result<std_path_PathBuf, std_io_Error> = v8825 |> Error
                        let _v8828 = v8836 
                        #endif
#else
                        let v8837 : Result<std_path_PathBuf, std_io_Error> = v8825 |> Error
                        let _v8828 = v8837 
                        #endif
                        let v8838 : Result<std_path_PathBuf, std_io_Error> = _v8828 
                        v8838
                | US8_0(v5920) -> (* Ok *)
                    let v5921 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v5922 : string = "Ok($0)"
                    let v5923 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5920 v5922 
                    let _v5921 = v5923 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v5924 : string = "Ok($0)"
                    let v5925 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5920 v5924 
                    let _v5921 = v5925 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v5926 : string = "Ok($0)"
                    let v5927 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5920 v5926 
                    let _v5921 = v5927 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v5928 : Result<std_path_PathBuf, std_io_Error> = v5920 |> Ok
                    let _v5921 = v5928 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v5929 : Result<std_path_PathBuf, std_io_Error> = v5920 |> Ok
                    let _v5921 = v5929 
                    #endif
#else
                    let v5930 : Result<std_path_PathBuf, std_io_Error> = v5920 |> Ok
                    let _v5921 = v5930 
                    #endif
                    let v5931 : Result<std_path_PathBuf, std_io_Error> = _v5921 
                    v5931
        let _v3 = v8844 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v8845 : Result<std_path_PathBuf, std_io_Error> = null |> unbox<Result<std_path_PathBuf, std_io_Error>>
        let _v3 = v8845 
        #endif
#if FABLE_COMPILER_PYTHON
        let v8848 : Result<std_path_PathBuf, std_io_Error> = Unchecked.defaultof<_>
        let _v3 = v8848 
        #endif
#else
        let v8849 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
        let v8850 : System.IO.DirectoryInfo = v8849 v0
        let v8851 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v8852 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
        let _v8851 = v8852 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v8855 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
        let _v8851 = v8855 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v8858 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
        let _v8851 = v8858 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v8861 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
        let _v8851 = v8861 
        #endif
#if FABLE_COMPILER_PYTHON
        let v8864 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
        let _v8851 = v8864 
        #endif
#else
        let v8867 : System.IO.FileAttributes = v8850.Attributes
        let _v8851 = v8867 
        #endif
        let v8868 : System.IO.FileAttributes = _v8851 
        let v8873 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v8874 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
        let _v8873 = v8874 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v8877 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
        let _v8873 = v8877 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v8880 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
        let _v8873 = v8880 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v8883 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
        let _v8873 = v8883 
        #endif
#if FABLE_COMPILER_PYTHON
        let v8886 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
        let _v8873 = v8886 
        #endif
#else
        let v8889 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
        let _v8873 = v8889 
        #endif
        let v8890 : System.IO.FileAttributes = _v8873 
        let v8895 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v8896 : bool = null |> unbox<bool>
        let _v8895 = v8896 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v8899 : bool = null |> unbox<bool>
        let _v8895 = v8899 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v8902 : bool = null |> unbox<bool>
        let _v8895 = v8902 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v8905 : bool = null |> unbox<bool>
        let _v8895 = v8905 
        #endif
#if FABLE_COMPILER_PYTHON
        let v8908 : bool = null |> unbox<bool>
        let _v8895 = v8908 
        #endif
#else
        let v8911 : bool = v8868.HasFlag v8890 
        let _v8895 = v8911 
        #endif
        let v8912 : bool = _v8895 
        let v13131 : Result<std_path_PathBuf, std_io_Error> =
            if v8912 then
                let v8917 : unit = ()
                
#if FABLE_COMPILER || WASM || CONTRACT
                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                let v8918 : file_info = null |> unbox<file_info>
                let _v8917 = v8918 
                #endif
#if FABLE_COMPILER_RUST && WASM
                let v8921 : file_info = null |> unbox<file_info>
                let _v8917 = v8921 
                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                let v8924 : file_info = null |> unbox<file_info>
                let _v8917 = v8924 
                #endif
#if FABLE_COMPILER_TYPESCRIPT
                let v8927 : file_info = null |> unbox<file_info>
                let _v8917 = v8927 
                #endif
#if FABLE_COMPILER_PYTHON
                let v8930 : file_info = null |> unbox<file_info>
                let _v8917 = v8930 
                #endif
#else
                let v8933 : (string -> file_info) = file_info 
                let v8934 : file_info = v8933 v0
                let _v8917 = v8934 
                #endif
                let v8935 : file_info = _v8917 
                let v8940 : unit = ()
                
#if FABLE_COMPILER || WASM || CONTRACT
                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                let v8941 : string = null |> unbox<string>
                let _v8940 = v8941 
                #endif
#if FABLE_COMPILER_RUST && WASM
                let v8944 : string = null |> unbox<string>
                let _v8940 = v8944 
                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                let v8947 : string = null |> unbox<string>
                let _v8940 = v8947 
                #endif
#if FABLE_COMPILER_TYPESCRIPT
                let v8950 : string = null |> unbox<string>
                let _v8940 = v8950 
                #endif
#if FABLE_COMPILER_PYTHON
                let v8953 : string = null |> unbox<string>
                let _v8940 = v8953 
                #endif
#else
                let v8956 : string = v8935.LinkTarget
                let _v8940 = v8956 
                #endif
                let v8957 : string = _v8940 
                let v8962 : std_path_PathBuf = v8957 |> std_path_PathBuf 
                let v8965 : unit = ()
                
#if FABLE_COMPILER || WASM || CONTRACT
                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                let v8966 : string = "Ok($0)"
                let v8967 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8962 v8966 
                let _v8965 = v8967 
                #endif
#if FABLE_COMPILER_RUST && WASM
                let v8968 : string = "Ok($0)"
                let v8969 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8962 v8968 
                let _v8965 = v8969 
                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                let v8970 : string = "Ok($0)"
                let v8971 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8962 v8970 
                let _v8965 = v8971 
                #endif
#if FABLE_COMPILER_TYPESCRIPT
                let v8972 : Result<std_path_PathBuf, std_io_Error> = v8962 |> Ok
                let _v8965 = v8972 
                #endif
#if FABLE_COMPILER_PYTHON
                let v8973 : Result<std_path_PathBuf, std_io_Error> = v8962 |> Ok
                let _v8965 = v8973 
                #endif
#else
                let v8974 : Result<std_path_PathBuf, std_io_Error> = v8962 |> Ok
                let _v8965 = v8974 
                #endif
                let v8975 : Result<std_path_PathBuf, std_io_Error> = _v8965 
                v8975
            else
                let v8978 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v0} / result: {v8912} / path': {v0} / n: {0uy}"
                let v8979 : unit = ()
                
#if FABLE_COMPILER || WASM || CONTRACT
                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                let v8980 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                let v8981 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8978 v8980 
                let _v8979 = v8981 
                #endif
#if FABLE_COMPILER_RUST && WASM
                let v8982 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                let v8983 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8978 v8982 
                let _v8979 = v8983 
                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                let v8984 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                let v8985 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8978 v8984 
                let _v8979 = v8985 
                #endif
#if FABLE_COMPILER_TYPESCRIPT
                let v8986 : std_io_Error = v8978 
                let _v8979 = v8986 
                #endif
#if FABLE_COMPILER_PYTHON
                let v8987 : std_io_Error = v8978 
                let _v8979 = v8987 
                #endif
#else
                let v8988 : std_io_Error = v8978 
                let _v8979 = v8988 
                #endif
                let v8989 : std_io_Error = _v8979 
                let v8992 : string = method43(v0)
                let v8993 : string option = method32(v0)
                let v8994 : (string -> US1) = method5()
                let v8995 : US1 option = v8993 |> Option.map v8994 
                let v9006 : US1 = US1_1
                let v9007 : US1 = v8995 |> Option.defaultValue v9006 
                match v9007 with
                | US1_0(v9011) -> (* Some *)
                    let v9012 : string = ""
                    let v9013 : bool = v0 <> v9012 
                    if v9013 then
                        let v9016 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                        let v9017 : System.IO.DirectoryInfo = v9016 v9011
                        let v9018 : unit = ()
                        
#if FABLE_COMPILER || WASM || CONTRACT
                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                        let v9019 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                        let _v9018 = v9019 
                        #endif
#if FABLE_COMPILER_RUST && WASM
                        let v9022 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                        let _v9018 = v9022 
                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                        let v9025 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                        let _v9018 = v9025 
                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                        let v9028 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                        let _v9018 = v9028 
                        #endif
#if FABLE_COMPILER_PYTHON
                        let v9031 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                        let _v9018 = v9031 
                        #endif
#else
                        let v9034 : System.IO.FileAttributes = v9017.Attributes
                        let _v9018 = v9034 
                        #endif
                        let v9035 : System.IO.FileAttributes = _v9018 
                        let v9040 : unit = ()
                        
#if FABLE_COMPILER || WASM || CONTRACT
                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                        let v9041 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                        let _v9040 = v9041 
                        #endif
#if FABLE_COMPILER_RUST && WASM
                        let v9044 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                        let _v9040 = v9044 
                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                        let v9047 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                        let _v9040 = v9047 
                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                        let v9050 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                        let _v9040 = v9050 
                        #endif
#if FABLE_COMPILER_PYTHON
                        let v9053 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                        let _v9040 = v9053 
                        #endif
#else
                        let v9056 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                        let _v9040 = v9056 
                        #endif
                        let v9057 : System.IO.FileAttributes = _v9040 
                        let v9062 : unit = ()
                        
#if FABLE_COMPILER || WASM || CONTRACT
                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                        let v9063 : bool = null |> unbox<bool>
                        let _v9062 = v9063 
                        #endif
#if FABLE_COMPILER_RUST && WASM
                        let v9066 : bool = null |> unbox<bool>
                        let _v9062 = v9066 
                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                        let v9069 : bool = null |> unbox<bool>
                        let _v9062 = v9069 
                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                        let v9072 : bool = null |> unbox<bool>
                        let _v9062 = v9072 
                        #endif
#if FABLE_COMPILER_PYTHON
                        let v9075 : bool = null |> unbox<bool>
                        let _v9062 = v9075 
                        #endif
#else
                        let v9078 : bool = v9035.HasFlag v9057 
                        let _v9062 = v9078 
                        #endif
                        let v9079 : bool = _v9062 
                        let v12925 : Result<std_path_PathBuf, std_io_Error> =
                            if v9079 then
                                let v9084 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v9085 : file_info = null |> unbox<file_info>
                                let _v9084 = v9085 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v9088 : file_info = null |> unbox<file_info>
                                let _v9084 = v9088 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v9091 : file_info = null |> unbox<file_info>
                                let _v9084 = v9091 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v9094 : file_info = null |> unbox<file_info>
                                let _v9084 = v9094 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v9097 : file_info = null |> unbox<file_info>
                                let _v9084 = v9097 
                                #endif
#else
                                let v9100 : (string -> file_info) = file_info 
                                let v9101 : file_info = v9100 v9011
                                let _v9084 = v9101 
                                #endif
                                let v9102 : file_info = _v9084 
                                let v9107 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v9108 : string = null |> unbox<string>
                                let _v9107 = v9108 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v9111 : string = null |> unbox<string>
                                let _v9107 = v9111 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v9114 : string = null |> unbox<string>
                                let _v9107 = v9114 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v9117 : string = null |> unbox<string>
                                let _v9107 = v9117 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v9120 : string = null |> unbox<string>
                                let _v9107 = v9120 
                                #endif
#else
                                let v9123 : string = v9102.LinkTarget
                                let _v9107 = v9123 
                                #endif
                                let v9124 : string = _v9107 
                                let v9129 : std_path_PathBuf = v9124 |> std_path_PathBuf 
                                let v9132 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v9133 : string = "Ok($0)"
                                let v9134 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9129 v9133 
                                let _v9132 = v9134 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v9135 : string = "Ok($0)"
                                let v9136 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9129 v9135 
                                let _v9132 = v9136 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v9137 : string = "Ok($0)"
                                let v9138 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9129 v9137 
                                let _v9132 = v9138 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v9139 : Result<std_path_PathBuf, std_io_Error> = v9129 |> Ok
                                let _v9132 = v9139 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v9140 : Result<std_path_PathBuf, std_io_Error> = v9129 |> Ok
                                let _v9132 = v9140 
                                #endif
#else
                                let v9141 : Result<std_path_PathBuf, std_io_Error> = v9129 |> Ok
                                let _v9132 = v9141 
                                #endif
                                let v9142 : Result<std_path_PathBuf, std_io_Error> = _v9132 
                                v9142
                            else
                                let v9145 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v0} / result: {v9079} / path': {v9011} / n: {1uy}"
                                let v9146 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v9147 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v9148 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9145 v9147 
                                let _v9146 = v9148 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v9149 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v9150 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9145 v9149 
                                let _v9146 = v9150 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v9151 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v9152 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9145 v9151 
                                let _v9146 = v9152 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v9153 : std_io_Error = v9145 
                                let _v9146 = v9153 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v9154 : std_io_Error = v9145 
                                let _v9146 = v9154 
                                #endif
#else
                                let v9155 : std_io_Error = v9145 
                                let _v9146 = v9155 
                                #endif
                                let v9156 : std_io_Error = _v9146 
                                let v9159 : string = method43(v9011)
                                let v9160 : string option = method32(v9011)
                                let v9161 : (string -> US1) = method5()
                                let v9162 : US1 option = v9160 |> Option.map v9161 
                                let v9173 : US1 = US1_1
                                let v9174 : US1 = v9162 |> Option.defaultValue v9173 
                                match v9174 with
                                | US1_0(v9178) -> (* Some *)
                                    let v9179 : bool = v9011 <> v9012 
                                    if v9179 then
                                        let v9182 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                        let v9183 : System.IO.DirectoryInfo = v9182 v9178
                                        let v9184 : unit = ()
                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                        let v9185 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                        let _v9184 = v9185 
                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                        let v9188 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                        let _v9184 = v9188 
                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                        let v9191 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                        let _v9184 = v9191 
                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                        let v9194 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                        let _v9184 = v9194 
                                        #endif
#if FABLE_COMPILER_PYTHON
                                        let v9197 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                        let _v9184 = v9197 
                                        #endif
#else
                                        let v9200 : System.IO.FileAttributes = v9183.Attributes
                                        let _v9184 = v9200 
                                        #endif
                                        let v9201 : System.IO.FileAttributes = _v9184 
                                        let v9206 : unit = ()
                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                        let v9207 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                        let _v9206 = v9207 
                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                        let v9210 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                        let _v9206 = v9210 
                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                        let v9213 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                        let _v9206 = v9213 
                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                        let v9216 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                        let _v9206 = v9216 
                                        #endif
#if FABLE_COMPILER_PYTHON
                                        let v9219 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                        let _v9206 = v9219 
                                        #endif
#else
                                        let v9222 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                        let _v9206 = v9222 
                                        #endif
                                        let v9223 : System.IO.FileAttributes = _v9206 
                                        let v9228 : unit = ()
                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                        let v9229 : bool = null |> unbox<bool>
                                        let _v9228 = v9229 
                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                        let v9232 : bool = null |> unbox<bool>
                                        let _v9228 = v9232 
                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                        let v9235 : bool = null |> unbox<bool>
                                        let _v9228 = v9235 
                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                        let v9238 : bool = null |> unbox<bool>
                                        let _v9228 = v9238 
                                        #endif
#if FABLE_COMPILER_PYTHON
                                        let v9241 : bool = null |> unbox<bool>
                                        let _v9228 = v9241 
                                        #endif
#else
                                        let v9244 : bool = v9201.HasFlag v9223 
                                        let _v9228 = v9244 
                                        #endif
                                        let v9245 : bool = _v9228 
                                        let v12719 : Result<std_path_PathBuf, std_io_Error> =
                                            if v9245 then
                                                let v9250 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v9251 : file_info = null |> unbox<file_info>
                                                let _v9250 = v9251 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v9254 : file_info = null |> unbox<file_info>
                                                let _v9250 = v9254 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v9257 : file_info = null |> unbox<file_info>
                                                let _v9250 = v9257 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v9260 : file_info = null |> unbox<file_info>
                                                let _v9250 = v9260 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v9263 : file_info = null |> unbox<file_info>
                                                let _v9250 = v9263 
                                                #endif
#else
                                                let v9266 : (string -> file_info) = file_info 
                                                let v9267 : file_info = v9266 v9178
                                                let _v9250 = v9267 
                                                #endif
                                                let v9268 : file_info = _v9250 
                                                let v9273 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v9274 : string = null |> unbox<string>
                                                let _v9273 = v9274 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v9277 : string = null |> unbox<string>
                                                let _v9273 = v9277 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v9280 : string = null |> unbox<string>
                                                let _v9273 = v9280 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v9283 : string = null |> unbox<string>
                                                let _v9273 = v9283 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v9286 : string = null |> unbox<string>
                                                let _v9273 = v9286 
                                                #endif
#else
                                                let v9289 : string = v9268.LinkTarget
                                                let _v9273 = v9289 
                                                #endif
                                                let v9290 : string = _v9273 
                                                let v9295 : std_path_PathBuf = v9290 |> std_path_PathBuf 
                                                let v9298 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v9299 : string = "Ok($0)"
                                                let v9300 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9295 v9299 
                                                let _v9298 = v9300 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v9301 : string = "Ok($0)"
                                                let v9302 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9295 v9301 
                                                let _v9298 = v9302 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v9303 : string = "Ok($0)"
                                                let v9304 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9295 v9303 
                                                let _v9298 = v9304 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v9305 : Result<std_path_PathBuf, std_io_Error> = v9295 |> Ok
                                                let _v9298 = v9305 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v9306 : Result<std_path_PathBuf, std_io_Error> = v9295 |> Ok
                                                let _v9298 = v9306 
                                                #endif
#else
                                                let v9307 : Result<std_path_PathBuf, std_io_Error> = v9295 |> Ok
                                                let _v9298 = v9307 
                                                #endif
                                                let v9308 : Result<std_path_PathBuf, std_io_Error> = _v9298 
                                                v9308
                                            else
                                                let v9311 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v0} / result: {v9245} / path': {v9178} / n: {2uy}"
                                                let v9312 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v9313 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v9314 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9311 v9313 
                                                let _v9312 = v9314 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v9315 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v9316 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9311 v9315 
                                                let _v9312 = v9316 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v9317 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v9318 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9311 v9317 
                                                let _v9312 = v9318 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v9319 : std_io_Error = v9311 
                                                let _v9312 = v9319 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v9320 : std_io_Error = v9311 
                                                let _v9312 = v9320 
                                                #endif
#else
                                                let v9321 : std_io_Error = v9311 
                                                let _v9312 = v9321 
                                                #endif
                                                let v9322 : std_io_Error = _v9312 
                                                let v9325 : string = method43(v9178)
                                                let v9326 : string option = method32(v9178)
                                                let v9327 : (string -> US1) = method5()
                                                let v9328 : US1 option = v9326 |> Option.map v9327 
                                                let v9339 : US1 = US1_1
                                                let v9340 : US1 = v9328 |> Option.defaultValue v9339 
                                                match v9340 with
                                                | US1_0(v9344) -> (* Some *)
                                                    let v9345 : bool = v9178 <> v9012 
                                                    if v9345 then
                                                        let v9348 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                                        let v9349 : System.IO.DirectoryInfo = v9348 v9344
                                                        let v9350 : unit = ()
                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                        let v9351 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                        let _v9350 = v9351 
                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                        let v9354 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                        let _v9350 = v9354 
                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                        let v9357 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                        let _v9350 = v9357 
                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                        let v9360 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                        let _v9350 = v9360 
                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                        let v9363 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                        let _v9350 = v9363 
                                                        #endif
#else
                                                        let v9366 : System.IO.FileAttributes = v9349.Attributes
                                                        let _v9350 = v9366 
                                                        #endif
                                                        let v9367 : System.IO.FileAttributes = _v9350 
                                                        let v9372 : unit = ()
                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                        let v9373 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                        let _v9372 = v9373 
                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                        let v9376 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                        let _v9372 = v9376 
                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                        let v9379 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                        let _v9372 = v9379 
                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                        let v9382 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                        let _v9372 = v9382 
                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                        let v9385 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                        let _v9372 = v9385 
                                                        #endif
#else
                                                        let v9388 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                                        let _v9372 = v9388 
                                                        #endif
                                                        let v9389 : System.IO.FileAttributes = _v9372 
                                                        let v9394 : unit = ()
                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                        let v9395 : bool = null |> unbox<bool>
                                                        let _v9394 = v9395 
                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                        let v9398 : bool = null |> unbox<bool>
                                                        let _v9394 = v9398 
                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                        let v9401 : bool = null |> unbox<bool>
                                                        let _v9394 = v9401 
                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                        let v9404 : bool = null |> unbox<bool>
                                                        let _v9394 = v9404 
                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                        let v9407 : bool = null |> unbox<bool>
                                                        let _v9394 = v9407 
                                                        #endif
#else
                                                        let v9410 : bool = v9367.HasFlag v9389 
                                                        let _v9394 = v9410 
                                                        #endif
                                                        let v9411 : bool = _v9394 
                                                        let v12513 : Result<std_path_PathBuf, std_io_Error> =
                                                            if v9411 then
                                                                let v9416 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v9417 : file_info = null |> unbox<file_info>
                                                                let _v9416 = v9417 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v9420 : file_info = null |> unbox<file_info>
                                                                let _v9416 = v9420 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v9423 : file_info = null |> unbox<file_info>
                                                                let _v9416 = v9423 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v9426 : file_info = null |> unbox<file_info>
                                                                let _v9416 = v9426 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v9429 : file_info = null |> unbox<file_info>
                                                                let _v9416 = v9429 
                                                                #endif
#else
                                                                let v9432 : (string -> file_info) = file_info 
                                                                let v9433 : file_info = v9432 v9344
                                                                let _v9416 = v9433 
                                                                #endif
                                                                let v9434 : file_info = _v9416 
                                                                let v9439 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v9440 : string = null |> unbox<string>
                                                                let _v9439 = v9440 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v9443 : string = null |> unbox<string>
                                                                let _v9439 = v9443 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v9446 : string = null |> unbox<string>
                                                                let _v9439 = v9446 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v9449 : string = null |> unbox<string>
                                                                let _v9439 = v9449 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v9452 : string = null |> unbox<string>
                                                                let _v9439 = v9452 
                                                                #endif
#else
                                                                let v9455 : string = v9434.LinkTarget
                                                                let _v9439 = v9455 
                                                                #endif
                                                                let v9456 : string = _v9439 
                                                                let v9461 : std_path_PathBuf = v9456 |> std_path_PathBuf 
                                                                let v9464 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v9465 : string = "Ok($0)"
                                                                let v9466 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9461 v9465 
                                                                let _v9464 = v9466 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v9467 : string = "Ok($0)"
                                                                let v9468 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9461 v9467 
                                                                let _v9464 = v9468 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v9469 : string = "Ok($0)"
                                                                let v9470 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9461 v9469 
                                                                let _v9464 = v9470 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v9471 : Result<std_path_PathBuf, std_io_Error> = v9461 |> Ok
                                                                let _v9464 = v9471 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v9472 : Result<std_path_PathBuf, std_io_Error> = v9461 |> Ok
                                                                let _v9464 = v9472 
                                                                #endif
#else
                                                                let v9473 : Result<std_path_PathBuf, std_io_Error> = v9461 |> Ok
                                                                let _v9464 = v9473 
                                                                #endif
                                                                let v9474 : Result<std_path_PathBuf, std_io_Error> = _v9464 
                                                                v9474
                                                            else
                                                                let v9477 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v0} / result: {v9411} / path': {v9344} / n: {3uy}"
                                                                let v9478 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v9479 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v9480 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9477 v9479 
                                                                let _v9478 = v9480 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v9481 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v9482 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9477 v9481 
                                                                let _v9478 = v9482 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v9483 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v9484 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9477 v9483 
                                                                let _v9478 = v9484 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v9485 : std_io_Error = v9477 
                                                                let _v9478 = v9485 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v9486 : std_io_Error = v9477 
                                                                let _v9478 = v9486 
                                                                #endif
#else
                                                                let v9487 : std_io_Error = v9477 
                                                                let _v9478 = v9487 
                                                                #endif
                                                                let v9488 : std_io_Error = _v9478 
                                                                let v9491 : string = method43(v9344)
                                                                let v9492 : string option = method32(v9344)
                                                                let v9493 : (string -> US1) = method5()
                                                                let v9494 : US1 option = v9492 |> Option.map v9493 
                                                                let v9505 : US1 = US1_1
                                                                let v9506 : US1 = v9494 |> Option.defaultValue v9505 
                                                                match v9506 with
                                                                | US1_0(v9510) -> (* Some *)
                                                                    let v9511 : bool = v9344 <> v9012 
                                                                    if v9511 then
                                                                        let v9514 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                                                        let v9515 : System.IO.DirectoryInfo = v9514 v9510
                                                                        let v9516 : unit = ()
                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                        let v9517 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                        let _v9516 = v9517 
                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                        let v9520 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                        let _v9516 = v9520 
                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                        let v9523 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                        let _v9516 = v9523 
                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                        let v9526 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                        let _v9516 = v9526 
                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                        let v9529 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                        let _v9516 = v9529 
                                                                        #endif
#else
                                                                        let v9532 : System.IO.FileAttributes = v9515.Attributes
                                                                        let _v9516 = v9532 
                                                                        #endif
                                                                        let v9533 : System.IO.FileAttributes = _v9516 
                                                                        let v9538 : unit = ()
                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                        let v9539 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                        let _v9538 = v9539 
                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                        let v9542 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                        let _v9538 = v9542 
                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                        let v9545 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                        let _v9538 = v9545 
                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                        let v9548 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                        let _v9538 = v9548 
                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                        let v9551 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                        let _v9538 = v9551 
                                                                        #endif
#else
                                                                        let v9554 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                                                        let _v9538 = v9554 
                                                                        #endif
                                                                        let v9555 : System.IO.FileAttributes = _v9538 
                                                                        let v9560 : unit = ()
                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                        let v9561 : bool = null |> unbox<bool>
                                                                        let _v9560 = v9561 
                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                        let v9564 : bool = null |> unbox<bool>
                                                                        let _v9560 = v9564 
                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                        let v9567 : bool = null |> unbox<bool>
                                                                        let _v9560 = v9567 
                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                        let v9570 : bool = null |> unbox<bool>
                                                                        let _v9560 = v9570 
                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                        let v9573 : bool = null |> unbox<bool>
                                                                        let _v9560 = v9573 
                                                                        #endif
#else
                                                                        let v9576 : bool = v9533.HasFlag v9555 
                                                                        let _v9560 = v9576 
                                                                        #endif
                                                                        let v9577 : bool = _v9560 
                                                                        let v12307 : Result<std_path_PathBuf, std_io_Error> =
                                                                            if v9577 then
                                                                                let v9582 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v9583 : file_info = null |> unbox<file_info>
                                                                                let _v9582 = v9583 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v9586 : file_info = null |> unbox<file_info>
                                                                                let _v9582 = v9586 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v9589 : file_info = null |> unbox<file_info>
                                                                                let _v9582 = v9589 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v9592 : file_info = null |> unbox<file_info>
                                                                                let _v9582 = v9592 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v9595 : file_info = null |> unbox<file_info>
                                                                                let _v9582 = v9595 
                                                                                #endif
#else
                                                                                let v9598 : (string -> file_info) = file_info 
                                                                                let v9599 : file_info = v9598 v9510
                                                                                let _v9582 = v9599 
                                                                                #endif
                                                                                let v9600 : file_info = _v9582 
                                                                                let v9605 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v9606 : string = null |> unbox<string>
                                                                                let _v9605 = v9606 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v9609 : string = null |> unbox<string>
                                                                                let _v9605 = v9609 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v9612 : string = null |> unbox<string>
                                                                                let _v9605 = v9612 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v9615 : string = null |> unbox<string>
                                                                                let _v9605 = v9615 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v9618 : string = null |> unbox<string>
                                                                                let _v9605 = v9618 
                                                                                #endif
#else
                                                                                let v9621 : string = v9600.LinkTarget
                                                                                let _v9605 = v9621 
                                                                                #endif
                                                                                let v9622 : string = _v9605 
                                                                                let v9627 : std_path_PathBuf = v9622 |> std_path_PathBuf 
                                                                                let v9630 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v9631 : string = "Ok($0)"
                                                                                let v9632 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9627 v9631 
                                                                                let _v9630 = v9632 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v9633 : string = "Ok($0)"
                                                                                let v9634 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9627 v9633 
                                                                                let _v9630 = v9634 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v9635 : string = "Ok($0)"
                                                                                let v9636 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9627 v9635 
                                                                                let _v9630 = v9636 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v9637 : Result<std_path_PathBuf, std_io_Error> = v9627 |> Ok
                                                                                let _v9630 = v9637 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v9638 : Result<std_path_PathBuf, std_io_Error> = v9627 |> Ok
                                                                                let _v9630 = v9638 
                                                                                #endif
#else
                                                                                let v9639 : Result<std_path_PathBuf, std_io_Error> = v9627 |> Ok
                                                                                let _v9630 = v9639 
                                                                                #endif
                                                                                let v9640 : Result<std_path_PathBuf, std_io_Error> = _v9630 
                                                                                v9640
                                                                            else
                                                                                let v9643 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v0} / result: {v9577} / path': {v9510} / n: {4uy}"
                                                                                let v9644 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v9645 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v9646 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9643 v9645 
                                                                                let _v9644 = v9646 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v9647 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v9648 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9643 v9647 
                                                                                let _v9644 = v9648 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v9649 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v9650 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9643 v9649 
                                                                                let _v9644 = v9650 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v9651 : std_io_Error = v9643 
                                                                                let _v9644 = v9651 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v9652 : std_io_Error = v9643 
                                                                                let _v9644 = v9652 
                                                                                #endif
#else
                                                                                let v9653 : std_io_Error = v9643 
                                                                                let _v9644 = v9653 
                                                                                #endif
                                                                                let v9654 : std_io_Error = _v9644 
                                                                                let v9657 : string = method43(v9510)
                                                                                let v9658 : string option = method32(v9510)
                                                                                let v9659 : (string -> US1) = method5()
                                                                                let v9660 : US1 option = v9658 |> Option.map v9659 
                                                                                let v9671 : US1 = US1_1
                                                                                let v9672 : US1 = v9660 |> Option.defaultValue v9671 
                                                                                match v9672 with
                                                                                | US1_0(v9676) -> (* Some *)
                                                                                    let v9677 : bool = v9510 <> v9012 
                                                                                    if v9677 then
                                                                                        let v9680 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                                                                        let v9681 : System.IO.DirectoryInfo = v9680 v9676
                                                                                        let v9682 : unit = ()
                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                        let v9683 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                        let _v9682 = v9683 
                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                        let v9686 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                        let _v9682 = v9686 
                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                        let v9689 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                        let _v9682 = v9689 
                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                        let v9692 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                        let _v9682 = v9692 
                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                        let v9695 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                        let _v9682 = v9695 
                                                                                        #endif
#else
                                                                                        let v9698 : System.IO.FileAttributes = v9681.Attributes
                                                                                        let _v9682 = v9698 
                                                                                        #endif
                                                                                        let v9699 : System.IO.FileAttributes = _v9682 
                                                                                        let v9704 : unit = ()
                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                        let v9705 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                        let _v9704 = v9705 
                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                        let v9708 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                        let _v9704 = v9708 
                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                        let v9711 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                        let _v9704 = v9711 
                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                        let v9714 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                        let _v9704 = v9714 
                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                        let v9717 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                        let _v9704 = v9717 
                                                                                        #endif
#else
                                                                                        let v9720 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                                                                        let _v9704 = v9720 
                                                                                        #endif
                                                                                        let v9721 : System.IO.FileAttributes = _v9704 
                                                                                        let v9726 : unit = ()
                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                        let v9727 : bool = null |> unbox<bool>
                                                                                        let _v9726 = v9727 
                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                        let v9730 : bool = null |> unbox<bool>
                                                                                        let _v9726 = v9730 
                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                        let v9733 : bool = null |> unbox<bool>
                                                                                        let _v9726 = v9733 
                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                        let v9736 : bool = null |> unbox<bool>
                                                                                        let _v9726 = v9736 
                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                        let v9739 : bool = null |> unbox<bool>
                                                                                        let _v9726 = v9739 
                                                                                        #endif
#else
                                                                                        let v9742 : bool = v9699.HasFlag v9721 
                                                                                        let _v9726 = v9742 
                                                                                        #endif
                                                                                        let v9743 : bool = _v9726 
                                                                                        let v12101 : Result<std_path_PathBuf, std_io_Error> =
                                                                                            if v9743 then
                                                                                                let v9748 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v9749 : file_info = null |> unbox<file_info>
                                                                                                let _v9748 = v9749 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v9752 : file_info = null |> unbox<file_info>
                                                                                                let _v9748 = v9752 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v9755 : file_info = null |> unbox<file_info>
                                                                                                let _v9748 = v9755 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v9758 : file_info = null |> unbox<file_info>
                                                                                                let _v9748 = v9758 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v9761 : file_info = null |> unbox<file_info>
                                                                                                let _v9748 = v9761 
                                                                                                #endif
#else
                                                                                                let v9764 : (string -> file_info) = file_info 
                                                                                                let v9765 : file_info = v9764 v9676
                                                                                                let _v9748 = v9765 
                                                                                                #endif
                                                                                                let v9766 : file_info = _v9748 
                                                                                                let v9771 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v9772 : string = null |> unbox<string>
                                                                                                let _v9771 = v9772 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v9775 : string = null |> unbox<string>
                                                                                                let _v9771 = v9775 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v9778 : string = null |> unbox<string>
                                                                                                let _v9771 = v9778 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v9781 : string = null |> unbox<string>
                                                                                                let _v9771 = v9781 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v9784 : string = null |> unbox<string>
                                                                                                let _v9771 = v9784 
                                                                                                #endif
#else
                                                                                                let v9787 : string = v9766.LinkTarget
                                                                                                let _v9771 = v9787 
                                                                                                #endif
                                                                                                let v9788 : string = _v9771 
                                                                                                let v9793 : std_path_PathBuf = v9788 |> std_path_PathBuf 
                                                                                                let v9796 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v9797 : string = "Ok($0)"
                                                                                                let v9798 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9793 v9797 
                                                                                                let _v9796 = v9798 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v9799 : string = "Ok($0)"
                                                                                                let v9800 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9793 v9799 
                                                                                                let _v9796 = v9800 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v9801 : string = "Ok($0)"
                                                                                                let v9802 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9793 v9801 
                                                                                                let _v9796 = v9802 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v9803 : Result<std_path_PathBuf, std_io_Error> = v9793 |> Ok
                                                                                                let _v9796 = v9803 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v9804 : Result<std_path_PathBuf, std_io_Error> = v9793 |> Ok
                                                                                                let _v9796 = v9804 
                                                                                                #endif
#else
                                                                                                let v9805 : Result<std_path_PathBuf, std_io_Error> = v9793 |> Ok
                                                                                                let _v9796 = v9805 
                                                                                                #endif
                                                                                                let v9806 : Result<std_path_PathBuf, std_io_Error> = _v9796 
                                                                                                v9806
                                                                                            else
                                                                                                let v9809 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v0} / result: {v9743} / path': {v9676} / n: {5uy}"
                                                                                                let v9810 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v9811 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v9812 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9809 v9811 
                                                                                                let _v9810 = v9812 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v9813 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v9814 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9809 v9813 
                                                                                                let _v9810 = v9814 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v9815 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v9816 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9809 v9815 
                                                                                                let _v9810 = v9816 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v9817 : std_io_Error = v9809 
                                                                                                let _v9810 = v9817 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v9818 : std_io_Error = v9809 
                                                                                                let _v9810 = v9818 
                                                                                                #endif
#else
                                                                                                let v9819 : std_io_Error = v9809 
                                                                                                let _v9810 = v9819 
                                                                                                #endif
                                                                                                let v9820 : std_io_Error = _v9810 
                                                                                                let v9823 : string = method43(v9676)
                                                                                                let v9824 : string option = method32(v9676)
                                                                                                let v9825 : (string -> US1) = method5()
                                                                                                let v9826 : US1 option = v9824 |> Option.map v9825 
                                                                                                let v9837 : US1 = US1_1
                                                                                                let v9838 : US1 = v9826 |> Option.defaultValue v9837 
                                                                                                match v9838 with
                                                                                                | US1_0(v9842) -> (* Some *)
                                                                                                    let v9843 : bool = v9676 <> v9012 
                                                                                                    if v9843 then
                                                                                                        let v9846 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                                                                                        let v9847 : System.IO.DirectoryInfo = v9846 v9842
                                                                                                        let v9848 : unit = ()
                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                        let v9849 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                        let _v9848 = v9849 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                        let v9852 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                        let _v9848 = v9852 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                        let v9855 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                        let _v9848 = v9855 
                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                        let v9858 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                        let _v9848 = v9858 
                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                        let v9861 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                        let _v9848 = v9861 
                                                                                                        #endif
#else
                                                                                                        let v9864 : System.IO.FileAttributes = v9847.Attributes
                                                                                                        let _v9848 = v9864 
                                                                                                        #endif
                                                                                                        let v9865 : System.IO.FileAttributes = _v9848 
                                                                                                        let v9870 : unit = ()
                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                        let v9871 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                        let _v9870 = v9871 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                        let v9874 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                        let _v9870 = v9874 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                        let v9877 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                        let _v9870 = v9877 
                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                        let v9880 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                        let _v9870 = v9880 
                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                        let v9883 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                        let _v9870 = v9883 
                                                                                                        #endif
#else
                                                                                                        let v9886 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                                                                                        let _v9870 = v9886 
                                                                                                        #endif
                                                                                                        let v9887 : System.IO.FileAttributes = _v9870 
                                                                                                        let v9892 : unit = ()
                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                        let v9893 : bool = null |> unbox<bool>
                                                                                                        let _v9892 = v9893 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                        let v9896 : bool = null |> unbox<bool>
                                                                                                        let _v9892 = v9896 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                        let v9899 : bool = null |> unbox<bool>
                                                                                                        let _v9892 = v9899 
                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                        let v9902 : bool = null |> unbox<bool>
                                                                                                        let _v9892 = v9902 
                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                        let v9905 : bool = null |> unbox<bool>
                                                                                                        let _v9892 = v9905 
                                                                                                        #endif
#else
                                                                                                        let v9908 : bool = v9865.HasFlag v9887 
                                                                                                        let _v9892 = v9908 
                                                                                                        #endif
                                                                                                        let v9909 : bool = _v9892 
                                                                                                        let v11895 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                            if v9909 then
                                                                                                                let v9914 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v9915 : file_info = null |> unbox<file_info>
                                                                                                                let _v9914 = v9915 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v9918 : file_info = null |> unbox<file_info>
                                                                                                                let _v9914 = v9918 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v9921 : file_info = null |> unbox<file_info>
                                                                                                                let _v9914 = v9921 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v9924 : file_info = null |> unbox<file_info>
                                                                                                                let _v9914 = v9924 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v9927 : file_info = null |> unbox<file_info>
                                                                                                                let _v9914 = v9927 
                                                                                                                #endif
#else
                                                                                                                let v9930 : (string -> file_info) = file_info 
                                                                                                                let v9931 : file_info = v9930 v9842
                                                                                                                let _v9914 = v9931 
                                                                                                                #endif
                                                                                                                let v9932 : file_info = _v9914 
                                                                                                                let v9937 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v9938 : string = null |> unbox<string>
                                                                                                                let _v9937 = v9938 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v9941 : string = null |> unbox<string>
                                                                                                                let _v9937 = v9941 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v9944 : string = null |> unbox<string>
                                                                                                                let _v9937 = v9944 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v9947 : string = null |> unbox<string>
                                                                                                                let _v9937 = v9947 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v9950 : string = null |> unbox<string>
                                                                                                                let _v9937 = v9950 
                                                                                                                #endif
#else
                                                                                                                let v9953 : string = v9932.LinkTarget
                                                                                                                let _v9937 = v9953 
                                                                                                                #endif
                                                                                                                let v9954 : string = _v9937 
                                                                                                                let v9959 : std_path_PathBuf = v9954 |> std_path_PathBuf 
                                                                                                                let v9962 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v9963 : string = "Ok($0)"
                                                                                                                let v9964 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9959 v9963 
                                                                                                                let _v9962 = v9964 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v9965 : string = "Ok($0)"
                                                                                                                let v9966 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9959 v9965 
                                                                                                                let _v9962 = v9966 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v9967 : string = "Ok($0)"
                                                                                                                let v9968 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9959 v9967 
                                                                                                                let _v9962 = v9968 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v9969 : Result<std_path_PathBuf, std_io_Error> = v9959 |> Ok
                                                                                                                let _v9962 = v9969 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v9970 : Result<std_path_PathBuf, std_io_Error> = v9959 |> Ok
                                                                                                                let _v9962 = v9970 
                                                                                                                #endif
#else
                                                                                                                let v9971 : Result<std_path_PathBuf, std_io_Error> = v9959 |> Ok
                                                                                                                let _v9962 = v9971 
                                                                                                                #endif
                                                                                                                let v9972 : Result<std_path_PathBuf, std_io_Error> = _v9962 
                                                                                                                v9972
                                                                                                            else
                                                                                                                let v9975 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v0} / result: {v9909} / path': {v9842} / n: {6uy}"
                                                                                                                let v9976 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v9977 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v9978 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9975 v9977 
                                                                                                                let _v9976 = v9978 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v9979 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v9980 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9975 v9979 
                                                                                                                let _v9976 = v9980 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v9981 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v9982 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9975 v9981 
                                                                                                                let _v9976 = v9982 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v9983 : std_io_Error = v9975 
                                                                                                                let _v9976 = v9983 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v9984 : std_io_Error = v9975 
                                                                                                                let _v9976 = v9984 
                                                                                                                #endif
#else
                                                                                                                let v9985 : std_io_Error = v9975 
                                                                                                                let _v9976 = v9985 
                                                                                                                #endif
                                                                                                                let v9986 : std_io_Error = _v9976 
                                                                                                                let v9989 : string = method43(v9842)
                                                                                                                let v9990 : string option = method32(v9842)
                                                                                                                let v9991 : (string -> US1) = method5()
                                                                                                                let v9992 : US1 option = v9990 |> Option.map v9991 
                                                                                                                let v10003 : US1 = US1_1
                                                                                                                let v10004 : US1 = v9992 |> Option.defaultValue v10003 
                                                                                                                match v10004 with
                                                                                                                | US1_0(v10008) -> (* Some *)
                                                                                                                    let v10009 : bool = v9842 <> v9012 
                                                                                                                    if v10009 then
                                                                                                                        let v10012 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                                                                                                        let v10013 : System.IO.DirectoryInfo = v10012 v10008
                                                                                                                        let v10014 : unit = ()
                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                        let v10015 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                        let _v10014 = v10015 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                        let v10018 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                        let _v10014 = v10018 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                        let v10021 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                        let _v10014 = v10021 
                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                        let v10024 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                        let _v10014 = v10024 
                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                        let v10027 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                        let _v10014 = v10027 
                                                                                                                        #endif
#else
                                                                                                                        let v10030 : System.IO.FileAttributes = v10013.Attributes
                                                                                                                        let _v10014 = v10030 
                                                                                                                        #endif
                                                                                                                        let v10031 : System.IO.FileAttributes = _v10014 
                                                                                                                        let v10036 : unit = ()
                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                        let v10037 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                        let _v10036 = v10037 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                        let v10040 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                        let _v10036 = v10040 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                        let v10043 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                        let _v10036 = v10043 
                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                        let v10046 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                        let _v10036 = v10046 
                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                        let v10049 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                        let _v10036 = v10049 
                                                                                                                        #endif
#else
                                                                                                                        let v10052 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                                                                                                        let _v10036 = v10052 
                                                                                                                        #endif
                                                                                                                        let v10053 : System.IO.FileAttributes = _v10036 
                                                                                                                        let v10058 : unit = ()
                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                        let v10059 : bool = null |> unbox<bool>
                                                                                                                        let _v10058 = v10059 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                        let v10062 : bool = null |> unbox<bool>
                                                                                                                        let _v10058 = v10062 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                        let v10065 : bool = null |> unbox<bool>
                                                                                                                        let _v10058 = v10065 
                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                        let v10068 : bool = null |> unbox<bool>
                                                                                                                        let _v10058 = v10068 
                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                        let v10071 : bool = null |> unbox<bool>
                                                                                                                        let _v10058 = v10071 
                                                                                                                        #endif
#else
                                                                                                                        let v10074 : bool = v10031.HasFlag v10053 
                                                                                                                        let _v10058 = v10074 
                                                                                                                        #endif
                                                                                                                        let v10075 : bool = _v10058 
                                                                                                                        let v11689 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                            if v10075 then
                                                                                                                                let v10080 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v10081 : file_info = null |> unbox<file_info>
                                                                                                                                let _v10080 = v10081 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v10084 : file_info = null |> unbox<file_info>
                                                                                                                                let _v10080 = v10084 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v10087 : file_info = null |> unbox<file_info>
                                                                                                                                let _v10080 = v10087 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v10090 : file_info = null |> unbox<file_info>
                                                                                                                                let _v10080 = v10090 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v10093 : file_info = null |> unbox<file_info>
                                                                                                                                let _v10080 = v10093 
                                                                                                                                #endif
#else
                                                                                                                                let v10096 : (string -> file_info) = file_info 
                                                                                                                                let v10097 : file_info = v10096 v10008
                                                                                                                                let _v10080 = v10097 
                                                                                                                                #endif
                                                                                                                                let v10098 : file_info = _v10080 
                                                                                                                                let v10103 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v10104 : string = null |> unbox<string>
                                                                                                                                let _v10103 = v10104 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v10107 : string = null |> unbox<string>
                                                                                                                                let _v10103 = v10107 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v10110 : string = null |> unbox<string>
                                                                                                                                let _v10103 = v10110 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v10113 : string = null |> unbox<string>
                                                                                                                                let _v10103 = v10113 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v10116 : string = null |> unbox<string>
                                                                                                                                let _v10103 = v10116 
                                                                                                                                #endif
#else
                                                                                                                                let v10119 : string = v10098.LinkTarget
                                                                                                                                let _v10103 = v10119 
                                                                                                                                #endif
                                                                                                                                let v10120 : string = _v10103 
                                                                                                                                let v10125 : std_path_PathBuf = v10120 |> std_path_PathBuf 
                                                                                                                                let v10128 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v10129 : string = "Ok($0)"
                                                                                                                                let v10130 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10125 v10129 
                                                                                                                                let _v10128 = v10130 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v10131 : string = "Ok($0)"
                                                                                                                                let v10132 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10125 v10131 
                                                                                                                                let _v10128 = v10132 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v10133 : string = "Ok($0)"
                                                                                                                                let v10134 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10125 v10133 
                                                                                                                                let _v10128 = v10134 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v10135 : Result<std_path_PathBuf, std_io_Error> = v10125 |> Ok
                                                                                                                                let _v10128 = v10135 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v10136 : Result<std_path_PathBuf, std_io_Error> = v10125 |> Ok
                                                                                                                                let _v10128 = v10136 
                                                                                                                                #endif
#else
                                                                                                                                let v10137 : Result<std_path_PathBuf, std_io_Error> = v10125 |> Ok
                                                                                                                                let _v10128 = v10137 
                                                                                                                                #endif
                                                                                                                                let v10138 : Result<std_path_PathBuf, std_io_Error> = _v10128 
                                                                                                                                v10138
                                                                                                                            else
                                                                                                                                let v10141 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v0} / result: {v10075} / path': {v10008} / n: {7uy}"
                                                                                                                                let v10142 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v10143 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v10144 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10141 v10143 
                                                                                                                                let _v10142 = v10144 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v10145 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v10146 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10141 v10145 
                                                                                                                                let _v10142 = v10146 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v10147 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v10148 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10141 v10147 
                                                                                                                                let _v10142 = v10148 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v10149 : std_io_Error = v10141 
                                                                                                                                let _v10142 = v10149 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v10150 : std_io_Error = v10141 
                                                                                                                                let _v10142 = v10150 
                                                                                                                                #endif
#else
                                                                                                                                let v10151 : std_io_Error = v10141 
                                                                                                                                let _v10142 = v10151 
                                                                                                                                #endif
                                                                                                                                let v10152 : std_io_Error = _v10142 
                                                                                                                                let v10155 : string = method43(v10008)
                                                                                                                                let v10156 : string option = method32(v10008)
                                                                                                                                let v10157 : (string -> US1) = method5()
                                                                                                                                let v10158 : US1 option = v10156 |> Option.map v10157 
                                                                                                                                let v10169 : US1 = US1_1
                                                                                                                                let v10170 : US1 = v10158 |> Option.defaultValue v10169 
                                                                                                                                match v10170 with
                                                                                                                                | US1_0(v10174) -> (* Some *)
                                                                                                                                    let v10175 : bool = v10008 <> v9012 
                                                                                                                                    if v10175 then
                                                                                                                                        let v10178 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                                                                                                                        let v10179 : System.IO.DirectoryInfo = v10178 v10174
                                                                                                                                        let v10180 : unit = ()
                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                        let v10181 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                        let _v10180 = v10181 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                        let v10184 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                        let _v10180 = v10184 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                        let v10187 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                        let _v10180 = v10187 
                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                        let v10190 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                        let _v10180 = v10190 
                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                        let v10193 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                        let _v10180 = v10193 
                                                                                                                                        #endif
#else
                                                                                                                                        let v10196 : System.IO.FileAttributes = v10179.Attributes
                                                                                                                                        let _v10180 = v10196 
                                                                                                                                        #endif
                                                                                                                                        let v10197 : System.IO.FileAttributes = _v10180 
                                                                                                                                        let v10202 : unit = ()
                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                        let v10203 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                        let _v10202 = v10203 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                        let v10206 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                        let _v10202 = v10206 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                        let v10209 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                        let _v10202 = v10209 
                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                        let v10212 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                        let _v10202 = v10212 
                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                        let v10215 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                        let _v10202 = v10215 
                                                                                                                                        #endif
#else
                                                                                                                                        let v10218 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                                                                                                                        let _v10202 = v10218 
                                                                                                                                        #endif
                                                                                                                                        let v10219 : System.IO.FileAttributes = _v10202 
                                                                                                                                        let v10224 : unit = ()
                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                        let v10225 : bool = null |> unbox<bool>
                                                                                                                                        let _v10224 = v10225 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                        let v10228 : bool = null |> unbox<bool>
                                                                                                                                        let _v10224 = v10228 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                        let v10231 : bool = null |> unbox<bool>
                                                                                                                                        let _v10224 = v10231 
                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                        let v10234 : bool = null |> unbox<bool>
                                                                                                                                        let _v10224 = v10234 
                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                        let v10237 : bool = null |> unbox<bool>
                                                                                                                                        let _v10224 = v10237 
                                                                                                                                        #endif
#else
                                                                                                                                        let v10240 : bool = v10197.HasFlag v10219 
                                                                                                                                        let _v10224 = v10240 
                                                                                                                                        #endif
                                                                                                                                        let v10241 : bool = _v10224 
                                                                                                                                        let v11483 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                            if v10241 then
                                                                                                                                                let v10246 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v10247 : file_info = null |> unbox<file_info>
                                                                                                                                                let _v10246 = v10247 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v10250 : file_info = null |> unbox<file_info>
                                                                                                                                                let _v10246 = v10250 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v10253 : file_info = null |> unbox<file_info>
                                                                                                                                                let _v10246 = v10253 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v10256 : file_info = null |> unbox<file_info>
                                                                                                                                                let _v10246 = v10256 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v10259 : file_info = null |> unbox<file_info>
                                                                                                                                                let _v10246 = v10259 
                                                                                                                                                #endif
#else
                                                                                                                                                let v10262 : (string -> file_info) = file_info 
                                                                                                                                                let v10263 : file_info = v10262 v10174
                                                                                                                                                let _v10246 = v10263 
                                                                                                                                                #endif
                                                                                                                                                let v10264 : file_info = _v10246 
                                                                                                                                                let v10269 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v10270 : string = null |> unbox<string>
                                                                                                                                                let _v10269 = v10270 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v10273 : string = null |> unbox<string>
                                                                                                                                                let _v10269 = v10273 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v10276 : string = null |> unbox<string>
                                                                                                                                                let _v10269 = v10276 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v10279 : string = null |> unbox<string>
                                                                                                                                                let _v10269 = v10279 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v10282 : string = null |> unbox<string>
                                                                                                                                                let _v10269 = v10282 
                                                                                                                                                #endif
#else
                                                                                                                                                let v10285 : string = v10264.LinkTarget
                                                                                                                                                let _v10269 = v10285 
                                                                                                                                                #endif
                                                                                                                                                let v10286 : string = _v10269 
                                                                                                                                                let v10291 : std_path_PathBuf = v10286 |> std_path_PathBuf 
                                                                                                                                                let v10294 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v10295 : string = "Ok($0)"
                                                                                                                                                let v10296 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10291 v10295 
                                                                                                                                                let _v10294 = v10296 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v10297 : string = "Ok($0)"
                                                                                                                                                let v10298 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10291 v10297 
                                                                                                                                                let _v10294 = v10298 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v10299 : string = "Ok($0)"
                                                                                                                                                let v10300 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10291 v10299 
                                                                                                                                                let _v10294 = v10300 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v10301 : Result<std_path_PathBuf, std_io_Error> = v10291 |> Ok
                                                                                                                                                let _v10294 = v10301 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v10302 : Result<std_path_PathBuf, std_io_Error> = v10291 |> Ok
                                                                                                                                                let _v10294 = v10302 
                                                                                                                                                #endif
#else
                                                                                                                                                let v10303 : Result<std_path_PathBuf, std_io_Error> = v10291 |> Ok
                                                                                                                                                let _v10294 = v10303 
                                                                                                                                                #endif
                                                                                                                                                let v10304 : Result<std_path_PathBuf, std_io_Error> = _v10294 
                                                                                                                                                v10304
                                                                                                                                            else
                                                                                                                                                let v10307 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v0} / result: {v10241} / path': {v10174} / n: {8uy}"
                                                                                                                                                let v10308 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v10309 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v10310 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10307 v10309 
                                                                                                                                                let _v10308 = v10310 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v10311 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v10312 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10307 v10311 
                                                                                                                                                let _v10308 = v10312 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v10313 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v10314 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10307 v10313 
                                                                                                                                                let _v10308 = v10314 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v10315 : std_io_Error = v10307 
                                                                                                                                                let _v10308 = v10315 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v10316 : std_io_Error = v10307 
                                                                                                                                                let _v10308 = v10316 
                                                                                                                                                #endif
#else
                                                                                                                                                let v10317 : std_io_Error = v10307 
                                                                                                                                                let _v10308 = v10317 
                                                                                                                                                #endif
                                                                                                                                                let v10318 : std_io_Error = _v10308 
                                                                                                                                                let v10321 : string = method43(v10174)
                                                                                                                                                let v10322 : string option = method32(v10174)
                                                                                                                                                let v10323 : (string -> US1) = method5()
                                                                                                                                                let v10324 : US1 option = v10322 |> Option.map v10323 
                                                                                                                                                let v10335 : US1 = US1_1
                                                                                                                                                let v10336 : US1 = v10324 |> Option.defaultValue v10335 
                                                                                                                                                match v10336 with
                                                                                                                                                | US1_0(v10340) -> (* Some *)
                                                                                                                                                    let v10341 : bool = v10174 <> v9012 
                                                                                                                                                    if v10341 then
                                                                                                                                                        let v10344 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                                                                                                                                        let v10345 : System.IO.DirectoryInfo = v10344 v10340
                                                                                                                                                        let v10346 : unit = ()
                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                        let v10347 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                        let _v10346 = v10347 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                        let v10350 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                        let _v10346 = v10350 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                        let v10353 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                        let _v10346 = v10353 
                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                        let v10356 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                        let _v10346 = v10356 
                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                        let v10359 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                        let _v10346 = v10359 
                                                                                                                                                        #endif
#else
                                                                                                                                                        let v10362 : System.IO.FileAttributes = v10345.Attributes
                                                                                                                                                        let _v10346 = v10362 
                                                                                                                                                        #endif
                                                                                                                                                        let v10363 : System.IO.FileAttributes = _v10346 
                                                                                                                                                        let v10368 : unit = ()
                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                        let v10369 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                        let _v10368 = v10369 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                        let v10372 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                        let _v10368 = v10372 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                        let v10375 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                        let _v10368 = v10375 
                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                        let v10378 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                        let _v10368 = v10378 
                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                        let v10381 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                        let _v10368 = v10381 
                                                                                                                                                        #endif
#else
                                                                                                                                                        let v10384 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                                                                                                                                        let _v10368 = v10384 
                                                                                                                                                        #endif
                                                                                                                                                        let v10385 : System.IO.FileAttributes = _v10368 
                                                                                                                                                        let v10390 : unit = ()
                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                        let v10391 : bool = null |> unbox<bool>
                                                                                                                                                        let _v10390 = v10391 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                        let v10394 : bool = null |> unbox<bool>
                                                                                                                                                        let _v10390 = v10394 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                        let v10397 : bool = null |> unbox<bool>
                                                                                                                                                        let _v10390 = v10397 
                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                        let v10400 : bool = null |> unbox<bool>
                                                                                                                                                        let _v10390 = v10400 
                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                        let v10403 : bool = null |> unbox<bool>
                                                                                                                                                        let _v10390 = v10403 
                                                                                                                                                        #endif
#else
                                                                                                                                                        let v10406 : bool = v10363.HasFlag v10385 
                                                                                                                                                        let _v10390 = v10406 
                                                                                                                                                        #endif
                                                                                                                                                        let v10407 : bool = _v10390 
                                                                                                                                                        let v11277 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                            if v10407 then
                                                                                                                                                                let v10412 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v10413 : file_info = null |> unbox<file_info>
                                                                                                                                                                let _v10412 = v10413 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v10416 : file_info = null |> unbox<file_info>
                                                                                                                                                                let _v10412 = v10416 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v10419 : file_info = null |> unbox<file_info>
                                                                                                                                                                let _v10412 = v10419 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v10422 : file_info = null |> unbox<file_info>
                                                                                                                                                                let _v10412 = v10422 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v10425 : file_info = null |> unbox<file_info>
                                                                                                                                                                let _v10412 = v10425 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v10428 : (string -> file_info) = file_info 
                                                                                                                                                                let v10429 : file_info = v10428 v10340
                                                                                                                                                                let _v10412 = v10429 
                                                                                                                                                                #endif
                                                                                                                                                                let v10430 : file_info = _v10412 
                                                                                                                                                                let v10435 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v10436 : string = null |> unbox<string>
                                                                                                                                                                let _v10435 = v10436 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v10439 : string = null |> unbox<string>
                                                                                                                                                                let _v10435 = v10439 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v10442 : string = null |> unbox<string>
                                                                                                                                                                let _v10435 = v10442 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v10445 : string = null |> unbox<string>
                                                                                                                                                                let _v10435 = v10445 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v10448 : string = null |> unbox<string>
                                                                                                                                                                let _v10435 = v10448 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v10451 : string = v10430.LinkTarget
                                                                                                                                                                let _v10435 = v10451 
                                                                                                                                                                #endif
                                                                                                                                                                let v10452 : string = _v10435 
                                                                                                                                                                let v10457 : std_path_PathBuf = v10452 |> std_path_PathBuf 
                                                                                                                                                                let v10460 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v10461 : string = "Ok($0)"
                                                                                                                                                                let v10462 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10457 v10461 
                                                                                                                                                                let _v10460 = v10462 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v10463 : string = "Ok($0)"
                                                                                                                                                                let v10464 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10457 v10463 
                                                                                                                                                                let _v10460 = v10464 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v10465 : string = "Ok($0)"
                                                                                                                                                                let v10466 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10457 v10465 
                                                                                                                                                                let _v10460 = v10466 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v10467 : Result<std_path_PathBuf, std_io_Error> = v10457 |> Ok
                                                                                                                                                                let _v10460 = v10467 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v10468 : Result<std_path_PathBuf, std_io_Error> = v10457 |> Ok
                                                                                                                                                                let _v10460 = v10468 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v10469 : Result<std_path_PathBuf, std_io_Error> = v10457 |> Ok
                                                                                                                                                                let _v10460 = v10469 
                                                                                                                                                                #endif
                                                                                                                                                                let v10470 : Result<std_path_PathBuf, std_io_Error> = _v10460 
                                                                                                                                                                v10470
                                                                                                                                                            else
                                                                                                                                                                let v10473 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v0} / result: {v10407} / path': {v10340} / n: {9uy}"
                                                                                                                                                                let v10474 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v10475 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v10476 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10473 v10475 
                                                                                                                                                                let _v10474 = v10476 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v10477 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v10478 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10473 v10477 
                                                                                                                                                                let _v10474 = v10478 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v10479 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v10480 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10473 v10479 
                                                                                                                                                                let _v10474 = v10480 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v10481 : std_io_Error = v10473 
                                                                                                                                                                let _v10474 = v10481 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v10482 : std_io_Error = v10473 
                                                                                                                                                                let _v10474 = v10482 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v10483 : std_io_Error = v10473 
                                                                                                                                                                let _v10474 = v10483 
                                                                                                                                                                #endif
                                                                                                                                                                let v10484 : std_io_Error = _v10474 
                                                                                                                                                                let v10487 : string = method43(v10340)
                                                                                                                                                                let v10488 : string option = method32(v10340)
                                                                                                                                                                let v10489 : (string -> US1) = method5()
                                                                                                                                                                let v10490 : US1 option = v10488 |> Option.map v10489 
                                                                                                                                                                let v10501 : US1 = US1_1
                                                                                                                                                                let v10502 : US1 = v10490 |> Option.defaultValue v10501 
                                                                                                                                                                match v10502 with
                                                                                                                                                                | US1_0(v10506) -> (* Some *)
                                                                                                                                                                    let v10507 : bool = v10340 <> v9012 
                                                                                                                                                                    if v10507 then
                                                                                                                                                                        let v10510 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                                                                                                                                                        let v10511 : System.IO.DirectoryInfo = v10510 v10506
                                                                                                                                                                        let v10512 : unit = ()
                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                        let v10513 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                        let _v10512 = v10513 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                        let v10516 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                        let _v10512 = v10516 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                        let v10519 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                        let _v10512 = v10519 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                        let v10522 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                        let _v10512 = v10522 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                        let v10525 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                        let _v10512 = v10525 
                                                                                                                                                                        #endif
#else
                                                                                                                                                                        let v10528 : System.IO.FileAttributes = v10511.Attributes
                                                                                                                                                                        let _v10512 = v10528 
                                                                                                                                                                        #endif
                                                                                                                                                                        let v10529 : System.IO.FileAttributes = _v10512 
                                                                                                                                                                        let v10534 : unit = ()
                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                        let v10535 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                        let _v10534 = v10535 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                        let v10538 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                        let _v10534 = v10538 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                        let v10541 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                        let _v10534 = v10541 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                        let v10544 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                        let _v10534 = v10544 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                        let v10547 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                        let _v10534 = v10547 
                                                                                                                                                                        #endif
#else
                                                                                                                                                                        let v10550 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                                                                                                                                                        let _v10534 = v10550 
                                                                                                                                                                        #endif
                                                                                                                                                                        let v10551 : System.IO.FileAttributes = _v10534 
                                                                                                                                                                        let v10556 : unit = ()
                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                        let v10557 : bool = null |> unbox<bool>
                                                                                                                                                                        let _v10556 = v10557 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                        let v10560 : bool = null |> unbox<bool>
                                                                                                                                                                        let _v10556 = v10560 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                        let v10563 : bool = null |> unbox<bool>
                                                                                                                                                                        let _v10556 = v10563 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                        let v10566 : bool = null |> unbox<bool>
                                                                                                                                                                        let _v10556 = v10566 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                        let v10569 : bool = null |> unbox<bool>
                                                                                                                                                                        let _v10556 = v10569 
                                                                                                                                                                        #endif
#else
                                                                                                                                                                        let v10572 : bool = v10529.HasFlag v10551 
                                                                                                                                                                        let _v10556 = v10572 
                                                                                                                                                                        #endif
                                                                                                                                                                        let v10573 : bool = _v10556 
                                                                                                                                                                        let v11071 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                            if v10573 then
                                                                                                                                                                                let v10578 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v10579 : file_info = null |> unbox<file_info>
                                                                                                                                                                                let _v10578 = v10579 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v10582 : file_info = null |> unbox<file_info>
                                                                                                                                                                                let _v10578 = v10582 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v10585 : file_info = null |> unbox<file_info>
                                                                                                                                                                                let _v10578 = v10585 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v10588 : file_info = null |> unbox<file_info>
                                                                                                                                                                                let _v10578 = v10588 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v10591 : file_info = null |> unbox<file_info>
                                                                                                                                                                                let _v10578 = v10591 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v10594 : (string -> file_info) = file_info 
                                                                                                                                                                                let v10595 : file_info = v10594 v10506
                                                                                                                                                                                let _v10578 = v10595 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v10596 : file_info = _v10578 
                                                                                                                                                                                let v10601 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v10602 : string = null |> unbox<string>
                                                                                                                                                                                let _v10601 = v10602 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v10605 : string = null |> unbox<string>
                                                                                                                                                                                let _v10601 = v10605 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v10608 : string = null |> unbox<string>
                                                                                                                                                                                let _v10601 = v10608 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v10611 : string = null |> unbox<string>
                                                                                                                                                                                let _v10601 = v10611 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v10614 : string = null |> unbox<string>
                                                                                                                                                                                let _v10601 = v10614 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v10617 : string = v10596.LinkTarget
                                                                                                                                                                                let _v10601 = v10617 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v10618 : string = _v10601 
                                                                                                                                                                                let v10623 : std_path_PathBuf = v10618 |> std_path_PathBuf 
                                                                                                                                                                                let v10626 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v10627 : string = "Ok($0)"
                                                                                                                                                                                let v10628 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10623 v10627 
                                                                                                                                                                                let _v10626 = v10628 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v10629 : string = "Ok($0)"
                                                                                                                                                                                let v10630 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10623 v10629 
                                                                                                                                                                                let _v10626 = v10630 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v10631 : string = "Ok($0)"
                                                                                                                                                                                let v10632 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10623 v10631 
                                                                                                                                                                                let _v10626 = v10632 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v10633 : Result<std_path_PathBuf, std_io_Error> = v10623 |> Ok
                                                                                                                                                                                let _v10626 = v10633 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v10634 : Result<std_path_PathBuf, std_io_Error> = v10623 |> Ok
                                                                                                                                                                                let _v10626 = v10634 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v10635 : Result<std_path_PathBuf, std_io_Error> = v10623 |> Ok
                                                                                                                                                                                let _v10626 = v10635 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v10636 : Result<std_path_PathBuf, std_io_Error> = _v10626 
                                                                                                                                                                                v10636
                                                                                                                                                                            else
                                                                                                                                                                                let v10639 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v0} / result: {v10573} / path': {v10506} / n: {10uy}"
                                                                                                                                                                                let v10640 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v10641 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v10642 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10639 v10641 
                                                                                                                                                                                let _v10640 = v10642 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v10643 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v10644 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10639 v10643 
                                                                                                                                                                                let _v10640 = v10644 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v10645 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v10646 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10639 v10645 
                                                                                                                                                                                let _v10640 = v10646 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v10647 : std_io_Error = v10639 
                                                                                                                                                                                let _v10640 = v10647 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v10648 : std_io_Error = v10639 
                                                                                                                                                                                let _v10640 = v10648 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v10649 : std_io_Error = v10639 
                                                                                                                                                                                let _v10640 = v10649 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v10650 : std_io_Error = _v10640 
                                                                                                                                                                                let v10653 : string = method43(v10506)
                                                                                                                                                                                let v10654 : string option = method32(v10506)
                                                                                                                                                                                let v10655 : (string -> US1) = method5()
                                                                                                                                                                                let v10656 : US1 option = v10654 |> Option.map v10655 
                                                                                                                                                                                let v10667 : US1 = US1_1
                                                                                                                                                                                let v10668 : US1 = v10656 |> Option.defaultValue v10667 
                                                                                                                                                                                match v10668 with
                                                                                                                                                                                | US1_0(v10672) -> (* Some *)
                                                                                                                                                                                    let v10673 : bool = v10506 <> v9012 
                                                                                                                                                                                    if v10673 then
                                                                                                                                                                                        let v10676 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                                                                                                                                                                        let v10677 : System.IO.DirectoryInfo = v10676 v10672
                                                                                                                                                                                        let v10678 : unit = ()
                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                        let v10679 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                        let _v10678 = v10679 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                        let v10682 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                        let _v10678 = v10682 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                        let v10685 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                        let _v10678 = v10685 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                        let v10688 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                        let _v10678 = v10688 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                        let v10691 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                        let _v10678 = v10691 
                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                        let v10694 : System.IO.FileAttributes = v10677.Attributes
                                                                                                                                                                                        let _v10678 = v10694 
                                                                                                                                                                                        #endif
                                                                                                                                                                                        let v10695 : System.IO.FileAttributes = _v10678 
                                                                                                                                                                                        let v10700 : unit = ()
                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                        let v10701 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                        let _v10700 = v10701 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                        let v10704 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                        let _v10700 = v10704 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                        let v10707 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                        let _v10700 = v10707 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                        let v10710 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                        let _v10700 = v10710 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                        let v10713 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                        let _v10700 = v10713 
                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                        let v10716 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                                                                                                                                                                        let _v10700 = v10716 
                                                                                                                                                                                        #endif
                                                                                                                                                                                        let v10717 : System.IO.FileAttributes = _v10700 
                                                                                                                                                                                        let v10722 : unit = ()
                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                        let v10723 : bool = null |> unbox<bool>
                                                                                                                                                                                        let _v10722 = v10723 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                        let v10726 : bool = null |> unbox<bool>
                                                                                                                                                                                        let _v10722 = v10726 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                        let v10729 : bool = null |> unbox<bool>
                                                                                                                                                                                        let _v10722 = v10729 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                        let v10732 : bool = null |> unbox<bool>
                                                                                                                                                                                        let _v10722 = v10732 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                        let v10735 : bool = null |> unbox<bool>
                                                                                                                                                                                        let _v10722 = v10735 
                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                        let v10738 : bool = v10695.HasFlag v10717 
                                                                                                                                                                                        let _v10722 = v10738 
                                                                                                                                                                                        #endif
                                                                                                                                                                                        let v10739 : bool = _v10722 
                                                                                                                                                                                        let v10865 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                            if v10739 then
                                                                                                                                                                                                let v10744 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v10745 : file_info = null |> unbox<file_info>
                                                                                                                                                                                                let _v10744 = v10745 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v10748 : file_info = null |> unbox<file_info>
                                                                                                                                                                                                let _v10744 = v10748 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v10751 : file_info = null |> unbox<file_info>
                                                                                                                                                                                                let _v10744 = v10751 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v10754 : file_info = null |> unbox<file_info>
                                                                                                                                                                                                let _v10744 = v10754 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v10757 : file_info = null |> unbox<file_info>
                                                                                                                                                                                                let _v10744 = v10757 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v10760 : (string -> file_info) = file_info 
                                                                                                                                                                                                let v10761 : file_info = v10760 v10672
                                                                                                                                                                                                let _v10744 = v10761 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v10762 : file_info = _v10744 
                                                                                                                                                                                                let v10767 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v10768 : string = null |> unbox<string>
                                                                                                                                                                                                let _v10767 = v10768 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v10771 : string = null |> unbox<string>
                                                                                                                                                                                                let _v10767 = v10771 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v10774 : string = null |> unbox<string>
                                                                                                                                                                                                let _v10767 = v10774 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v10777 : string = null |> unbox<string>
                                                                                                                                                                                                let _v10767 = v10777 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v10780 : string = null |> unbox<string>
                                                                                                                                                                                                let _v10767 = v10780 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v10783 : string = v10762.LinkTarget
                                                                                                                                                                                                let _v10767 = v10783 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v10784 : string = _v10767 
                                                                                                                                                                                                let v10789 : std_path_PathBuf = v10784 |> std_path_PathBuf 
                                                                                                                                                                                                let v10792 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v10793 : string = "Ok($0)"
                                                                                                                                                                                                let v10794 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10789 v10793 
                                                                                                                                                                                                let _v10792 = v10794 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v10795 : string = "Ok($0)"
                                                                                                                                                                                                let v10796 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10789 v10795 
                                                                                                                                                                                                let _v10792 = v10796 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v10797 : string = "Ok($0)"
                                                                                                                                                                                                let v10798 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10789 v10797 
                                                                                                                                                                                                let _v10792 = v10798 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v10799 : Result<std_path_PathBuf, std_io_Error> = v10789 |> Ok
                                                                                                                                                                                                let _v10792 = v10799 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v10800 : Result<std_path_PathBuf, std_io_Error> = v10789 |> Ok
                                                                                                                                                                                                let _v10792 = v10800 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v10801 : Result<std_path_PathBuf, std_io_Error> = v10789 |> Ok
                                                                                                                                                                                                let _v10792 = v10801 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v10802 : Result<std_path_PathBuf, std_io_Error> = _v10792 
                                                                                                                                                                                                v10802
                                                                                                                                                                                            else
                                                                                                                                                                                                let v10805 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v0} / result: {v10739} / path': {v10672} / n: {11uy}"
                                                                                                                                                                                                let v10806 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v10807 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v10808 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10805 v10807 
                                                                                                                                                                                                let _v10806 = v10808 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v10809 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v10810 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10805 v10809 
                                                                                                                                                                                                let _v10806 = v10810 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v10811 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v10812 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10805 v10811 
                                                                                                                                                                                                let _v10806 = v10812 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v10813 : std_io_Error = v10805 
                                                                                                                                                                                                let _v10806 = v10813 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v10814 : std_io_Error = v10805 
                                                                                                                                                                                                let _v10806 = v10814 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v10815 : std_io_Error = v10805 
                                                                                                                                                                                                let _v10806 = v10815 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v10816 : std_io_Error = _v10806 
                                                                                                                                                                                                let v10819 : string = method43(v10672)
                                                                                                                                                                                                let v10820 : string option = method32(v10672)
                                                                                                                                                                                                let v10821 : (string -> US1) = method5()
                                                                                                                                                                                                let v10822 : US1 option = v10820 |> Option.map v10821 
                                                                                                                                                                                                let v10833 : US1 = US1_1
                                                                                                                                                                                                let v10834 : US1 = v10822 |> Option.defaultValue v10833 
                                                                                                                                                                                                let v10838 : string = $"file_system.read_link / path: {v0} / n: {11uy} / path': {v10672} / name: {v10819}"
                                                                                                                                                                                                let v10839 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v10840 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v10841 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10838 v10840 
                                                                                                                                                                                                let _v10839 = v10841 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v10842 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v10843 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10838 v10842 
                                                                                                                                                                                                let _v10839 = v10843 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v10844 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v10845 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10838 v10844 
                                                                                                                                                                                                let _v10839 = v10845 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v10846 : std_io_Error = v10838 
                                                                                                                                                                                                let _v10839 = v10846 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v10847 : std_io_Error = v10838 
                                                                                                                                                                                                let _v10839 = v10847 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v10848 : std_io_Error = v10838 
                                                                                                                                                                                                let _v10839 = v10848 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v10849 : std_io_Error = _v10839 
                                                                                                                                                                                                let v10852 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v10853 : string = "Err($0)"
                                                                                                                                                                                                let v10854 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10849 v10853 
                                                                                                                                                                                                let _v10852 = v10854 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v10855 : string = "Err($0)"
                                                                                                                                                                                                let v10856 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10849 v10855 
                                                                                                                                                                                                let _v10852 = v10856 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v10857 : string = "Err($0)"
                                                                                                                                                                                                let v10858 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10849 v10857 
                                                                                                                                                                                                let _v10852 = v10858 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v10859 : Result<std_path_PathBuf, std_io_Error> = v10849 |> Error
                                                                                                                                                                                                let _v10852 = v10859 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v10860 : Result<std_path_PathBuf, std_io_Error> = v10849 |> Error
                                                                                                                                                                                                let _v10852 = v10860 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v10861 : Result<std_path_PathBuf, std_io_Error> = v10849 |> Error
                                                                                                                                                                                                let _v10852 = v10861 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v10862 : Result<std_path_PathBuf, std_io_Error> = _v10852 
                                                                                                                                                                                                v10862
                                                                                                                                                                                        let v10866 : (std_io_Error -> string) = method41()
                                                                                                                                                                                        let v10867 : unit = ()
                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                        let v10868 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                        let v10869 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v10865, v10866) v10868 
                                                                                                                                                                                        let _v10867 = v10869 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                        let v10870 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                        let v10871 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v10865, v10866) v10870 
                                                                                                                                                                                        let _v10867 = v10871 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                        let v10872 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                        let v10873 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v10865, v10866) v10872 
                                                                                                                                                                                        let _v10867 = v10873 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                        let v10874 : Result<std_path_PathBuf, string> = match v10865 with Ok x -> Ok x | Error x -> Error (v10866 x)
                                                                                                                                                                                        let _v10867 = v10874 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                        let v10875 : Result<std_path_PathBuf, string> = match v10865 with Ok x -> Ok x | Error x -> Error (v10866 x)
                                                                                                                                                                                        let _v10867 = v10875 
                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                        let v10876 : Result<std_path_PathBuf, string> = match v10865 with Ok x -> Ok x | Error x -> Error (v10866 x)
                                                                                                                                                                                        let _v10867 = v10876 
                                                                                                                                                                                        #endif
                                                                                                                                                                                        let v10877 : Result<std_path_PathBuf, string> = _v10867 
                                                                                                                                                                                        let v10880 : (std_path_PathBuf -> US8) = closure16()
                                                                                                                                                                                        let v10881 : (string -> US8) = closure17()
                                                                                                                                                                                        let v10882 : US8 = match v10877 with Ok x -> v10880 x | Error x -> v10881 x
                                                                                                                                                                                        match v10882 with
                                                                                                                                                                                        | US8_1(v10985) -> (* Error *)
                                                                                                                                                                                            let v10986 : string = $"file_system.read_link / error': {v10985} / error: {v10650} / name: {v10653}"
                                                                                                                                                                                            let v10987 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v10988 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v10989 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10986 v10988 
                                                                                                                                                                                            let _v10987 = v10989 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v10990 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v10991 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10986 v10990 
                                                                                                                                                                                            let _v10987 = v10991 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v10992 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v10993 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10986 v10992 
                                                                                                                                                                                            let _v10987 = v10993 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v10994 : std_io_Error = v10986 
                                                                                                                                                                                            let _v10987 = v10994 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v10995 : std_io_Error = v10986 
                                                                                                                                                                                            let _v10987 = v10995 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v10996 : std_io_Error = v10986 
                                                                                                                                                                                            let _v10987 = v10996 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v10997 : std_io_Error = _v10987 
                                                                                                                                                                                            let v11000 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v11001 : string = "Err($0)"
                                                                                                                                                                                            let v11002 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10997 v11001 
                                                                                                                                                                                            let _v11000 = v11002 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v11003 : string = "Err($0)"
                                                                                                                                                                                            let v11004 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10997 v11003 
                                                                                                                                                                                            let _v11000 = v11004 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v11005 : string = "Err($0)"
                                                                                                                                                                                            let v11006 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10997 v11005 
                                                                                                                                                                                            let _v11000 = v11006 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v11007 : Result<std_path_PathBuf, std_io_Error> = v10997 |> Error
                                                                                                                                                                                            let _v11000 = v11007 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v11008 : Result<std_path_PathBuf, std_io_Error> = v10997 |> Error
                                                                                                                                                                                            let _v11000 = v11008 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v11009 : Result<std_path_PathBuf, std_io_Error> = v10997 |> Error
                                                                                                                                                                                            let _v11000 = v11009 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v11010 : Result<std_path_PathBuf, std_io_Error> = _v11000 
                                                                                                                                                                                            v11010
                                                                                                                                                                                        | US8_0(v10883) -> (* Ok *)
                                                                                                                                                                                            let v10884 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v10885 : string = "$0.display()"
                                                                                                                                                                                            let v10886 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v10883 v10885 
                                                                                                                                                                                            let _v10884 = v10886 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v10887 : string = "$0.display()"
                                                                                                                                                                                            let v10888 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v10883 v10887 
                                                                                                                                                                                            let _v10884 = v10888 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v10889 : string = "$0.display()"
                                                                                                                                                                                            let v10890 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v10883 v10889 
                                                                                                                                                                                            let _v10884 = v10890 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v10891 : std_path_Display = v10883 |> unbox<std_path_Display>
                                                                                                                                                                                            let _v10884 = v10891 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v10894 : std_path_Display = v10883 |> unbox<std_path_Display>
                                                                                                                                                                                            let _v10884 = v10894 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v10897 : std_path_Display = v10883 |> unbox<std_path_Display>
                                                                                                                                                                                            let _v10884 = v10897 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v10900 : std_path_Display = _v10884 
                                                                                                                                                                                            let v10905 : string = v10900 |> string 
                                                                                                                                                                                            let v10908 : string = method26(v10905, v10653)
                                                                                                                                                                                            let v10909 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v10910 : string = "&*$0"
                                                                                                                                                                                            let v10911 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v10908 v10910 
                                                                                                                                                                                            let _v10909 = v10911 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v10912 : string = "&*$0"
                                                                                                                                                                                            let v10913 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v10908 v10912 
                                                                                                                                                                                            let _v10909 = v10913 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v10914 : string = "&*$0"
                                                                                                                                                                                            let v10915 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v10908 v10914 
                                                                                                                                                                                            let _v10909 = v10915 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v10916 : Ref<Str> = v10908 |> unbox<Ref<Str>>
                                                                                                                                                                                            let _v10909 = v10916 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v10919 : Ref<Str> = v10908 |> unbox<Ref<Str>>
                                                                                                                                                                                            let _v10909 = v10919 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v10922 : Ref<Str> = v10908 |> unbox<Ref<Str>>
                                                                                                                                                                                            let _v10909 = v10922 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v10925 : Ref<Str> = _v10909 
                                                                                                                                                                                            let v10930 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v10931 : string = "String::from($0)"
                                                                                                                                                                                            let v10932 : std_string_String = Fable.Core.RustInterop.emitRustExpr v10925 v10931 
                                                                                                                                                                                            let _v10930 = v10932 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v10933 : string = "String::from($0)"
                                                                                                                                                                                            let v10934 : std_string_String = Fable.Core.RustInterop.emitRustExpr v10925 v10933 
                                                                                                                                                                                            let _v10930 = v10934 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v10935 : string = "String::from($0)"
                                                                                                                                                                                            let v10936 : std_string_String = Fable.Core.RustInterop.emitRustExpr v10925 v10935 
                                                                                                                                                                                            let _v10930 = v10936 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v10937 : std_string_String = v10925 |> unbox<std_string_String>
                                                                                                                                                                                            let _v10930 = v10937 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v10940 : std_string_String = v10925 |> unbox<std_string_String>
                                                                                                                                                                                            let _v10930 = v10940 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v10943 : std_string_String = v10925 |> unbox<std_string_String>
                                                                                                                                                                                            let _v10930 = v10943 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v10946 : std_string_String = _v10930 
                                                                                                                                                                                            let v10951 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v10952 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                            let v10953 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v10946 v10952 
                                                                                                                                                                                            let _v10951 = v10953 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v10954 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                            let v10955 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v10946 v10954 
                                                                                                                                                                                            let _v10951 = v10955 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v10956 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                            let v10957 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v10946 v10956 
                                                                                                                                                                                            let _v10951 = v10957 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v10958 : std_path_PathBuf = v10946 |> std_path_PathBuf 
                                                                                                                                                                                            let _v10951 = v10958 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v10961 : std_path_PathBuf = v10946 |> std_path_PathBuf 
                                                                                                                                                                                            let _v10951 = v10961 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v10964 : std_path_PathBuf = v10946 |> std_path_PathBuf 
                                                                                                                                                                                            let _v10951 = v10964 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v10967 : std_path_PathBuf = _v10951 
                                                                                                                                                                                            let v10972 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v10973 : string = "Ok($0)"
                                                                                                                                                                                            let v10974 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10967 v10973 
                                                                                                                                                                                            let _v10972 = v10974 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v10975 : string = "Ok($0)"
                                                                                                                                                                                            let v10976 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10967 v10975 
                                                                                                                                                                                            let _v10972 = v10976 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v10977 : string = "Ok($0)"
                                                                                                                                                                                            let v10978 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10967 v10977 
                                                                                                                                                                                            let _v10972 = v10978 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v10979 : Result<std_path_PathBuf, std_io_Error> = v10967 |> Ok
                                                                                                                                                                                            let _v10972 = v10979 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v10980 : Result<std_path_PathBuf, std_io_Error> = v10967 |> Ok
                                                                                                                                                                                            let _v10972 = v10980 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v10981 : Result<std_path_PathBuf, std_io_Error> = v10967 |> Ok
                                                                                                                                                                                            let _v10972 = v10981 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v10982 : Result<std_path_PathBuf, std_io_Error> = _v10972 
                                                                                                                                                                                            v10982
                                                                                                                                                                                    else
                                                                                                                                                                                        let v11015 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v10650} / path': {v10506} / name: {v10653}"
                                                                                                                                                                                        let v11016 : unit = ()
                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                        let v11017 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                        let v11018 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11015 v11017 
                                                                                                                                                                                        let _v11016 = v11018 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                        let v11019 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                        let v11020 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11015 v11019 
                                                                                                                                                                                        let _v11016 = v11020 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                        let v11021 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                        let v11022 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11015 v11021 
                                                                                                                                                                                        let _v11016 = v11022 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                        let v11023 : std_io_Error = v11015 
                                                                                                                                                                                        let _v11016 = v11023 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                        let v11024 : std_io_Error = v11015 
                                                                                                                                                                                        let _v11016 = v11024 
                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                        let v11025 : std_io_Error = v11015 
                                                                                                                                                                                        let _v11016 = v11025 
                                                                                                                                                                                        #endif
                                                                                                                                                                                        let v11026 : std_io_Error = _v11016 
                                                                                                                                                                                        let v11029 : unit = ()
                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                        let v11030 : string = "Err($0)"
                                                                                                                                                                                        let v11031 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11026 v11030 
                                                                                                                                                                                        let _v11029 = v11031 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                        let v11032 : string = "Err($0)"
                                                                                                                                                                                        let v11033 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11026 v11032 
                                                                                                                                                                                        let _v11029 = v11033 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                        let v11034 : string = "Err($0)"
                                                                                                                                                                                        let v11035 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11026 v11034 
                                                                                                                                                                                        let _v11029 = v11035 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                        let v11036 : Result<std_path_PathBuf, std_io_Error> = v11026 |> Error
                                                                                                                                                                                        let _v11029 = v11036 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                        let v11037 : Result<std_path_PathBuf, std_io_Error> = v11026 |> Error
                                                                                                                                                                                        let _v11029 = v11037 
                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                        let v11038 : Result<std_path_PathBuf, std_io_Error> = v11026 |> Error
                                                                                                                                                                                        let _v11029 = v11038 
                                                                                                                                                                                        #endif
                                                                                                                                                                                        let v11039 : Result<std_path_PathBuf, std_io_Error> = _v11029 
                                                                                                                                                                                        v11039
                                                                                                                                                                                | _ ->
                                                                                                                                                                                    let v11043 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v10650} / path': {v10506} / name: {v10653}"
                                                                                                                                                                                    let v11044 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v11045 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                    let v11046 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11043 v11045 
                                                                                                                                                                                    let _v11044 = v11046 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v11047 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                    let v11048 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11043 v11047 
                                                                                                                                                                                    let _v11044 = v11048 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v11049 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                    let v11050 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11043 v11049 
                                                                                                                                                                                    let _v11044 = v11050 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v11051 : std_io_Error = v11043 
                                                                                                                                                                                    let _v11044 = v11051 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v11052 : std_io_Error = v11043 
                                                                                                                                                                                    let _v11044 = v11052 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v11053 : std_io_Error = v11043 
                                                                                                                                                                                    let _v11044 = v11053 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v11054 : std_io_Error = _v11044 
                                                                                                                                                                                    let v11057 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v11058 : string = "Err($0)"
                                                                                                                                                                                    let v11059 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11054 v11058 
                                                                                                                                                                                    let _v11057 = v11059 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v11060 : string = "Err($0)"
                                                                                                                                                                                    let v11061 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11054 v11060 
                                                                                                                                                                                    let _v11057 = v11061 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v11062 : string = "Err($0)"
                                                                                                                                                                                    let v11063 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11054 v11062 
                                                                                                                                                                                    let _v11057 = v11063 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v11064 : Result<std_path_PathBuf, std_io_Error> = v11054 |> Error
                                                                                                                                                                                    let _v11057 = v11064 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v11065 : Result<std_path_PathBuf, std_io_Error> = v11054 |> Error
                                                                                                                                                                                    let _v11057 = v11065 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v11066 : Result<std_path_PathBuf, std_io_Error> = v11054 |> Error
                                                                                                                                                                                    let _v11057 = v11066 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v11067 : Result<std_path_PathBuf, std_io_Error> = _v11057 
                                                                                                                                                                                    v11067
                                                                                                                                                                        let v11072 : (std_io_Error -> string) = method41()
                                                                                                                                                                        let v11073 : unit = ()
                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                        let v11074 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                        let v11075 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11071, v11072) v11074 
                                                                                                                                                                        let _v11073 = v11075 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                        let v11076 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                        let v11077 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11071, v11072) v11076 
                                                                                                                                                                        let _v11073 = v11077 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                        let v11078 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                        let v11079 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11071, v11072) v11078 
                                                                                                                                                                        let _v11073 = v11079 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                        let v11080 : Result<std_path_PathBuf, string> = match v11071 with Ok x -> Ok x | Error x -> Error (v11072 x)
                                                                                                                                                                        let _v11073 = v11080 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                        let v11081 : Result<std_path_PathBuf, string> = match v11071 with Ok x -> Ok x | Error x -> Error (v11072 x)
                                                                                                                                                                        let _v11073 = v11081 
                                                                                                                                                                        #endif
#else
                                                                                                                                                                        let v11082 : Result<std_path_PathBuf, string> = match v11071 with Ok x -> Ok x | Error x -> Error (v11072 x)
                                                                                                                                                                        let _v11073 = v11082 
                                                                                                                                                                        #endif
                                                                                                                                                                        let v11083 : Result<std_path_PathBuf, string> = _v11073 
                                                                                                                                                                        let v11086 : (std_path_PathBuf -> US8) = closure16()
                                                                                                                                                                        let v11087 : (string -> US8) = closure17()
                                                                                                                                                                        let v11088 : US8 = match v11083 with Ok x -> v11086 x | Error x -> v11087 x
                                                                                                                                                                        match v11088 with
                                                                                                                                                                        | US8_1(v11191) -> (* Error *)
                                                                                                                                                                            let v11192 : string = $"file_system.read_link / error': {v11191} / error: {v10484} / name: {v10487}"
                                                                                                                                                                            let v11193 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v11194 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v11195 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11192 v11194 
                                                                                                                                                                            let _v11193 = v11195 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v11196 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v11197 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11192 v11196 
                                                                                                                                                                            let _v11193 = v11197 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v11198 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v11199 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11192 v11198 
                                                                                                                                                                            let _v11193 = v11199 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v11200 : std_io_Error = v11192 
                                                                                                                                                                            let _v11193 = v11200 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v11201 : std_io_Error = v11192 
                                                                                                                                                                            let _v11193 = v11201 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v11202 : std_io_Error = v11192 
                                                                                                                                                                            let _v11193 = v11202 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v11203 : std_io_Error = _v11193 
                                                                                                                                                                            let v11206 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v11207 : string = "Err($0)"
                                                                                                                                                                            let v11208 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11203 v11207 
                                                                                                                                                                            let _v11206 = v11208 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v11209 : string = "Err($0)"
                                                                                                                                                                            let v11210 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11203 v11209 
                                                                                                                                                                            let _v11206 = v11210 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v11211 : string = "Err($0)"
                                                                                                                                                                            let v11212 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11203 v11211 
                                                                                                                                                                            let _v11206 = v11212 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v11213 : Result<std_path_PathBuf, std_io_Error> = v11203 |> Error
                                                                                                                                                                            let _v11206 = v11213 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v11214 : Result<std_path_PathBuf, std_io_Error> = v11203 |> Error
                                                                                                                                                                            let _v11206 = v11214 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v11215 : Result<std_path_PathBuf, std_io_Error> = v11203 |> Error
                                                                                                                                                                            let _v11206 = v11215 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v11216 : Result<std_path_PathBuf, std_io_Error> = _v11206 
                                                                                                                                                                            v11216
                                                                                                                                                                        | US8_0(v11089) -> (* Ok *)
                                                                                                                                                                            let v11090 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v11091 : string = "$0.display()"
                                                                                                                                                                            let v11092 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11089 v11091 
                                                                                                                                                                            let _v11090 = v11092 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v11093 : string = "$0.display()"
                                                                                                                                                                            let v11094 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11089 v11093 
                                                                                                                                                                            let _v11090 = v11094 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v11095 : string = "$0.display()"
                                                                                                                                                                            let v11096 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11089 v11095 
                                                                                                                                                                            let _v11090 = v11096 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v11097 : std_path_Display = v11089 |> unbox<std_path_Display>
                                                                                                                                                                            let _v11090 = v11097 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v11100 : std_path_Display = v11089 |> unbox<std_path_Display>
                                                                                                                                                                            let _v11090 = v11100 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v11103 : std_path_Display = v11089 |> unbox<std_path_Display>
                                                                                                                                                                            let _v11090 = v11103 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v11106 : std_path_Display = _v11090 
                                                                                                                                                                            let v11111 : string = v11106 |> string 
                                                                                                                                                                            let v11114 : string = method26(v11111, v10487)
                                                                                                                                                                            let v11115 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v11116 : string = "&*$0"
                                                                                                                                                                            let v11117 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11114 v11116 
                                                                                                                                                                            let _v11115 = v11117 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v11118 : string = "&*$0"
                                                                                                                                                                            let v11119 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11114 v11118 
                                                                                                                                                                            let _v11115 = v11119 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v11120 : string = "&*$0"
                                                                                                                                                                            let v11121 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11114 v11120 
                                                                                                                                                                            let _v11115 = v11121 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v11122 : Ref<Str> = v11114 |> unbox<Ref<Str>>
                                                                                                                                                                            let _v11115 = v11122 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v11125 : Ref<Str> = v11114 |> unbox<Ref<Str>>
                                                                                                                                                                            let _v11115 = v11125 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v11128 : Ref<Str> = v11114 |> unbox<Ref<Str>>
                                                                                                                                                                            let _v11115 = v11128 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v11131 : Ref<Str> = _v11115 
                                                                                                                                                                            let v11136 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v11137 : string = "String::from($0)"
                                                                                                                                                                            let v11138 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11131 v11137 
                                                                                                                                                                            let _v11136 = v11138 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v11139 : string = "String::from($0)"
                                                                                                                                                                            let v11140 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11131 v11139 
                                                                                                                                                                            let _v11136 = v11140 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v11141 : string = "String::from($0)"
                                                                                                                                                                            let v11142 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11131 v11141 
                                                                                                                                                                            let _v11136 = v11142 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v11143 : std_string_String = v11131 |> unbox<std_string_String>
                                                                                                                                                                            let _v11136 = v11143 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v11146 : std_string_String = v11131 |> unbox<std_string_String>
                                                                                                                                                                            let _v11136 = v11146 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v11149 : std_string_String = v11131 |> unbox<std_string_String>
                                                                                                                                                                            let _v11136 = v11149 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v11152 : std_string_String = _v11136 
                                                                                                                                                                            let v11157 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v11158 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                            let v11159 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11152 v11158 
                                                                                                                                                                            let _v11157 = v11159 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v11160 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                            let v11161 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11152 v11160 
                                                                                                                                                                            let _v11157 = v11161 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v11162 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                            let v11163 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11152 v11162 
                                                                                                                                                                            let _v11157 = v11163 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v11164 : std_path_PathBuf = v11152 |> std_path_PathBuf 
                                                                                                                                                                            let _v11157 = v11164 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v11167 : std_path_PathBuf = v11152 |> std_path_PathBuf 
                                                                                                                                                                            let _v11157 = v11167 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v11170 : std_path_PathBuf = v11152 |> std_path_PathBuf 
                                                                                                                                                                            let _v11157 = v11170 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v11173 : std_path_PathBuf = _v11157 
                                                                                                                                                                            let v11178 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v11179 : string = "Ok($0)"
                                                                                                                                                                            let v11180 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11173 v11179 
                                                                                                                                                                            let _v11178 = v11180 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v11181 : string = "Ok($0)"
                                                                                                                                                                            let v11182 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11173 v11181 
                                                                                                                                                                            let _v11178 = v11182 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v11183 : string = "Ok($0)"
                                                                                                                                                                            let v11184 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11173 v11183 
                                                                                                                                                                            let _v11178 = v11184 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v11185 : Result<std_path_PathBuf, std_io_Error> = v11173 |> Ok
                                                                                                                                                                            let _v11178 = v11185 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v11186 : Result<std_path_PathBuf, std_io_Error> = v11173 |> Ok
                                                                                                                                                                            let _v11178 = v11186 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v11187 : Result<std_path_PathBuf, std_io_Error> = v11173 |> Ok
                                                                                                                                                                            let _v11178 = v11187 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v11188 : Result<std_path_PathBuf, std_io_Error> = _v11178 
                                                                                                                                                                            v11188
                                                                                                                                                                    else
                                                                                                                                                                        let v11221 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v10484} / path': {v10340} / name: {v10487}"
                                                                                                                                                                        let v11222 : unit = ()
                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                        let v11223 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                        let v11224 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11221 v11223 
                                                                                                                                                                        let _v11222 = v11224 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                        let v11225 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                        let v11226 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11221 v11225 
                                                                                                                                                                        let _v11222 = v11226 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                        let v11227 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                        let v11228 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11221 v11227 
                                                                                                                                                                        let _v11222 = v11228 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                        let v11229 : std_io_Error = v11221 
                                                                                                                                                                        let _v11222 = v11229 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                        let v11230 : std_io_Error = v11221 
                                                                                                                                                                        let _v11222 = v11230 
                                                                                                                                                                        #endif
#else
                                                                                                                                                                        let v11231 : std_io_Error = v11221 
                                                                                                                                                                        let _v11222 = v11231 
                                                                                                                                                                        #endif
                                                                                                                                                                        let v11232 : std_io_Error = _v11222 
                                                                                                                                                                        let v11235 : unit = ()
                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                        let v11236 : string = "Err($0)"
                                                                                                                                                                        let v11237 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11232 v11236 
                                                                                                                                                                        let _v11235 = v11237 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                        let v11238 : string = "Err($0)"
                                                                                                                                                                        let v11239 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11232 v11238 
                                                                                                                                                                        let _v11235 = v11239 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                        let v11240 : string = "Err($0)"
                                                                                                                                                                        let v11241 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11232 v11240 
                                                                                                                                                                        let _v11235 = v11241 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                        let v11242 : Result<std_path_PathBuf, std_io_Error> = v11232 |> Error
                                                                                                                                                                        let _v11235 = v11242 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                        let v11243 : Result<std_path_PathBuf, std_io_Error> = v11232 |> Error
                                                                                                                                                                        let _v11235 = v11243 
                                                                                                                                                                        #endif
#else
                                                                                                                                                                        let v11244 : Result<std_path_PathBuf, std_io_Error> = v11232 |> Error
                                                                                                                                                                        let _v11235 = v11244 
                                                                                                                                                                        #endif
                                                                                                                                                                        let v11245 : Result<std_path_PathBuf, std_io_Error> = _v11235 
                                                                                                                                                                        v11245
                                                                                                                                                                | _ ->
                                                                                                                                                                    let v11249 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v10484} / path': {v10340} / name: {v10487}"
                                                                                                                                                                    let v11250 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v11251 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                    let v11252 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11249 v11251 
                                                                                                                                                                    let _v11250 = v11252 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v11253 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                    let v11254 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11249 v11253 
                                                                                                                                                                    let _v11250 = v11254 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v11255 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                    let v11256 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11249 v11255 
                                                                                                                                                                    let _v11250 = v11256 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v11257 : std_io_Error = v11249 
                                                                                                                                                                    let _v11250 = v11257 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v11258 : std_io_Error = v11249 
                                                                                                                                                                    let _v11250 = v11258 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v11259 : std_io_Error = v11249 
                                                                                                                                                                    let _v11250 = v11259 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v11260 : std_io_Error = _v11250 
                                                                                                                                                                    let v11263 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v11264 : string = "Err($0)"
                                                                                                                                                                    let v11265 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11260 v11264 
                                                                                                                                                                    let _v11263 = v11265 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v11266 : string = "Err($0)"
                                                                                                                                                                    let v11267 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11260 v11266 
                                                                                                                                                                    let _v11263 = v11267 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v11268 : string = "Err($0)"
                                                                                                                                                                    let v11269 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11260 v11268 
                                                                                                                                                                    let _v11263 = v11269 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v11270 : Result<std_path_PathBuf, std_io_Error> = v11260 |> Error
                                                                                                                                                                    let _v11263 = v11270 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v11271 : Result<std_path_PathBuf, std_io_Error> = v11260 |> Error
                                                                                                                                                                    let _v11263 = v11271 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v11272 : Result<std_path_PathBuf, std_io_Error> = v11260 |> Error
                                                                                                                                                                    let _v11263 = v11272 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v11273 : Result<std_path_PathBuf, std_io_Error> = _v11263 
                                                                                                                                                                    v11273
                                                                                                                                                        let v11278 : (std_io_Error -> string) = method41()
                                                                                                                                                        let v11279 : unit = ()
                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                        let v11280 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                        let v11281 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11277, v11278) v11280 
                                                                                                                                                        let _v11279 = v11281 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                        let v11282 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                        let v11283 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11277, v11278) v11282 
                                                                                                                                                        let _v11279 = v11283 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                        let v11284 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                        let v11285 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11277, v11278) v11284 
                                                                                                                                                        let _v11279 = v11285 
                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                        let v11286 : Result<std_path_PathBuf, string> = match v11277 with Ok x -> Ok x | Error x -> Error (v11278 x)
                                                                                                                                                        let _v11279 = v11286 
                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                        let v11287 : Result<std_path_PathBuf, string> = match v11277 with Ok x -> Ok x | Error x -> Error (v11278 x)
                                                                                                                                                        let _v11279 = v11287 
                                                                                                                                                        #endif
#else
                                                                                                                                                        let v11288 : Result<std_path_PathBuf, string> = match v11277 with Ok x -> Ok x | Error x -> Error (v11278 x)
                                                                                                                                                        let _v11279 = v11288 
                                                                                                                                                        #endif
                                                                                                                                                        let v11289 : Result<std_path_PathBuf, string> = _v11279 
                                                                                                                                                        let v11292 : (std_path_PathBuf -> US8) = closure16()
                                                                                                                                                        let v11293 : (string -> US8) = closure17()
                                                                                                                                                        let v11294 : US8 = match v11289 with Ok x -> v11292 x | Error x -> v11293 x
                                                                                                                                                        match v11294 with
                                                                                                                                                        | US8_1(v11397) -> (* Error *)
                                                                                                                                                            let v11398 : string = $"file_system.read_link / error': {v11397} / error: {v10318} / name: {v10321}"
                                                                                                                                                            let v11399 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v11400 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v11401 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11398 v11400 
                                                                                                                                                            let _v11399 = v11401 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v11402 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v11403 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11398 v11402 
                                                                                                                                                            let _v11399 = v11403 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v11404 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v11405 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11398 v11404 
                                                                                                                                                            let _v11399 = v11405 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v11406 : std_io_Error = v11398 
                                                                                                                                                            let _v11399 = v11406 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v11407 : std_io_Error = v11398 
                                                                                                                                                            let _v11399 = v11407 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v11408 : std_io_Error = v11398 
                                                                                                                                                            let _v11399 = v11408 
                                                                                                                                                            #endif
                                                                                                                                                            let v11409 : std_io_Error = _v11399 
                                                                                                                                                            let v11412 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v11413 : string = "Err($0)"
                                                                                                                                                            let v11414 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11409 v11413 
                                                                                                                                                            let _v11412 = v11414 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v11415 : string = "Err($0)"
                                                                                                                                                            let v11416 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11409 v11415 
                                                                                                                                                            let _v11412 = v11416 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v11417 : string = "Err($0)"
                                                                                                                                                            let v11418 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11409 v11417 
                                                                                                                                                            let _v11412 = v11418 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v11419 : Result<std_path_PathBuf, std_io_Error> = v11409 |> Error
                                                                                                                                                            let _v11412 = v11419 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v11420 : Result<std_path_PathBuf, std_io_Error> = v11409 |> Error
                                                                                                                                                            let _v11412 = v11420 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v11421 : Result<std_path_PathBuf, std_io_Error> = v11409 |> Error
                                                                                                                                                            let _v11412 = v11421 
                                                                                                                                                            #endif
                                                                                                                                                            let v11422 : Result<std_path_PathBuf, std_io_Error> = _v11412 
                                                                                                                                                            v11422
                                                                                                                                                        | US8_0(v11295) -> (* Ok *)
                                                                                                                                                            let v11296 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v11297 : string = "$0.display()"
                                                                                                                                                            let v11298 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11295 v11297 
                                                                                                                                                            let _v11296 = v11298 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v11299 : string = "$0.display()"
                                                                                                                                                            let v11300 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11295 v11299 
                                                                                                                                                            let _v11296 = v11300 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v11301 : string = "$0.display()"
                                                                                                                                                            let v11302 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11295 v11301 
                                                                                                                                                            let _v11296 = v11302 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v11303 : std_path_Display = v11295 |> unbox<std_path_Display>
                                                                                                                                                            let _v11296 = v11303 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v11306 : std_path_Display = v11295 |> unbox<std_path_Display>
                                                                                                                                                            let _v11296 = v11306 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v11309 : std_path_Display = v11295 |> unbox<std_path_Display>
                                                                                                                                                            let _v11296 = v11309 
                                                                                                                                                            #endif
                                                                                                                                                            let v11312 : std_path_Display = _v11296 
                                                                                                                                                            let v11317 : string = v11312 |> string 
                                                                                                                                                            let v11320 : string = method26(v11317, v10321)
                                                                                                                                                            let v11321 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v11322 : string = "&*$0"
                                                                                                                                                            let v11323 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11320 v11322 
                                                                                                                                                            let _v11321 = v11323 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v11324 : string = "&*$0"
                                                                                                                                                            let v11325 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11320 v11324 
                                                                                                                                                            let _v11321 = v11325 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v11326 : string = "&*$0"
                                                                                                                                                            let v11327 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11320 v11326 
                                                                                                                                                            let _v11321 = v11327 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v11328 : Ref<Str> = v11320 |> unbox<Ref<Str>>
                                                                                                                                                            let _v11321 = v11328 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v11331 : Ref<Str> = v11320 |> unbox<Ref<Str>>
                                                                                                                                                            let _v11321 = v11331 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v11334 : Ref<Str> = v11320 |> unbox<Ref<Str>>
                                                                                                                                                            let _v11321 = v11334 
                                                                                                                                                            #endif
                                                                                                                                                            let v11337 : Ref<Str> = _v11321 
                                                                                                                                                            let v11342 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v11343 : string = "String::from($0)"
                                                                                                                                                            let v11344 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11337 v11343 
                                                                                                                                                            let _v11342 = v11344 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v11345 : string = "String::from($0)"
                                                                                                                                                            let v11346 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11337 v11345 
                                                                                                                                                            let _v11342 = v11346 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v11347 : string = "String::from($0)"
                                                                                                                                                            let v11348 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11337 v11347 
                                                                                                                                                            let _v11342 = v11348 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v11349 : std_string_String = v11337 |> unbox<std_string_String>
                                                                                                                                                            let _v11342 = v11349 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v11352 : std_string_String = v11337 |> unbox<std_string_String>
                                                                                                                                                            let _v11342 = v11352 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v11355 : std_string_String = v11337 |> unbox<std_string_String>
                                                                                                                                                            let _v11342 = v11355 
                                                                                                                                                            #endif
                                                                                                                                                            let v11358 : std_string_String = _v11342 
                                                                                                                                                            let v11363 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v11364 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                            let v11365 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11358 v11364 
                                                                                                                                                            let _v11363 = v11365 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v11366 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                            let v11367 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11358 v11366 
                                                                                                                                                            let _v11363 = v11367 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v11368 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                            let v11369 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11358 v11368 
                                                                                                                                                            let _v11363 = v11369 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v11370 : std_path_PathBuf = v11358 |> std_path_PathBuf 
                                                                                                                                                            let _v11363 = v11370 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v11373 : std_path_PathBuf = v11358 |> std_path_PathBuf 
                                                                                                                                                            let _v11363 = v11373 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v11376 : std_path_PathBuf = v11358 |> std_path_PathBuf 
                                                                                                                                                            let _v11363 = v11376 
                                                                                                                                                            #endif
                                                                                                                                                            let v11379 : std_path_PathBuf = _v11363 
                                                                                                                                                            let v11384 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v11385 : string = "Ok($0)"
                                                                                                                                                            let v11386 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11379 v11385 
                                                                                                                                                            let _v11384 = v11386 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v11387 : string = "Ok($0)"
                                                                                                                                                            let v11388 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11379 v11387 
                                                                                                                                                            let _v11384 = v11388 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v11389 : string = "Ok($0)"
                                                                                                                                                            let v11390 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11379 v11389 
                                                                                                                                                            let _v11384 = v11390 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v11391 : Result<std_path_PathBuf, std_io_Error> = v11379 |> Ok
                                                                                                                                                            let _v11384 = v11391 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v11392 : Result<std_path_PathBuf, std_io_Error> = v11379 |> Ok
                                                                                                                                                            let _v11384 = v11392 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v11393 : Result<std_path_PathBuf, std_io_Error> = v11379 |> Ok
                                                                                                                                                            let _v11384 = v11393 
                                                                                                                                                            #endif
                                                                                                                                                            let v11394 : Result<std_path_PathBuf, std_io_Error> = _v11384 
                                                                                                                                                            v11394
                                                                                                                                                    else
                                                                                                                                                        let v11427 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v10318} / path': {v10174} / name: {v10321}"
                                                                                                                                                        let v11428 : unit = ()
                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                        let v11429 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                        let v11430 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11427 v11429 
                                                                                                                                                        let _v11428 = v11430 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                        let v11431 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                        let v11432 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11427 v11431 
                                                                                                                                                        let _v11428 = v11432 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                        let v11433 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                        let v11434 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11427 v11433 
                                                                                                                                                        let _v11428 = v11434 
                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                        let v11435 : std_io_Error = v11427 
                                                                                                                                                        let _v11428 = v11435 
                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                        let v11436 : std_io_Error = v11427 
                                                                                                                                                        let _v11428 = v11436 
                                                                                                                                                        #endif
#else
                                                                                                                                                        let v11437 : std_io_Error = v11427 
                                                                                                                                                        let _v11428 = v11437 
                                                                                                                                                        #endif
                                                                                                                                                        let v11438 : std_io_Error = _v11428 
                                                                                                                                                        let v11441 : unit = ()
                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                        let v11442 : string = "Err($0)"
                                                                                                                                                        let v11443 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11438 v11442 
                                                                                                                                                        let _v11441 = v11443 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                        let v11444 : string = "Err($0)"
                                                                                                                                                        let v11445 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11438 v11444 
                                                                                                                                                        let _v11441 = v11445 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                        let v11446 : string = "Err($0)"
                                                                                                                                                        let v11447 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11438 v11446 
                                                                                                                                                        let _v11441 = v11447 
                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                        let v11448 : Result<std_path_PathBuf, std_io_Error> = v11438 |> Error
                                                                                                                                                        let _v11441 = v11448 
                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                        let v11449 : Result<std_path_PathBuf, std_io_Error> = v11438 |> Error
                                                                                                                                                        let _v11441 = v11449 
                                                                                                                                                        #endif
#else
                                                                                                                                                        let v11450 : Result<std_path_PathBuf, std_io_Error> = v11438 |> Error
                                                                                                                                                        let _v11441 = v11450 
                                                                                                                                                        #endif
                                                                                                                                                        let v11451 : Result<std_path_PathBuf, std_io_Error> = _v11441 
                                                                                                                                                        v11451
                                                                                                                                                | _ ->
                                                                                                                                                    let v11455 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v10318} / path': {v10174} / name: {v10321}"
                                                                                                                                                    let v11456 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v11457 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                    let v11458 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11455 v11457 
                                                                                                                                                    let _v11456 = v11458 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v11459 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                    let v11460 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11455 v11459 
                                                                                                                                                    let _v11456 = v11460 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v11461 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                    let v11462 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11455 v11461 
                                                                                                                                                    let _v11456 = v11462 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v11463 : std_io_Error = v11455 
                                                                                                                                                    let _v11456 = v11463 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v11464 : std_io_Error = v11455 
                                                                                                                                                    let _v11456 = v11464 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v11465 : std_io_Error = v11455 
                                                                                                                                                    let _v11456 = v11465 
                                                                                                                                                    #endif
                                                                                                                                                    let v11466 : std_io_Error = _v11456 
                                                                                                                                                    let v11469 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v11470 : string = "Err($0)"
                                                                                                                                                    let v11471 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11466 v11470 
                                                                                                                                                    let _v11469 = v11471 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v11472 : string = "Err($0)"
                                                                                                                                                    let v11473 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11466 v11472 
                                                                                                                                                    let _v11469 = v11473 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v11474 : string = "Err($0)"
                                                                                                                                                    let v11475 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11466 v11474 
                                                                                                                                                    let _v11469 = v11475 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v11476 : Result<std_path_PathBuf, std_io_Error> = v11466 |> Error
                                                                                                                                                    let _v11469 = v11476 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v11477 : Result<std_path_PathBuf, std_io_Error> = v11466 |> Error
                                                                                                                                                    let _v11469 = v11477 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v11478 : Result<std_path_PathBuf, std_io_Error> = v11466 |> Error
                                                                                                                                                    let _v11469 = v11478 
                                                                                                                                                    #endif
                                                                                                                                                    let v11479 : Result<std_path_PathBuf, std_io_Error> = _v11469 
                                                                                                                                                    v11479
                                                                                                                                        let v11484 : (std_io_Error -> string) = method41()
                                                                                                                                        let v11485 : unit = ()
                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                        let v11486 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                        let v11487 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11483, v11484) v11486 
                                                                                                                                        let _v11485 = v11487 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                        let v11488 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                        let v11489 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11483, v11484) v11488 
                                                                                                                                        let _v11485 = v11489 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                        let v11490 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                        let v11491 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11483, v11484) v11490 
                                                                                                                                        let _v11485 = v11491 
                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                        let v11492 : Result<std_path_PathBuf, string> = match v11483 with Ok x -> Ok x | Error x -> Error (v11484 x)
                                                                                                                                        let _v11485 = v11492 
                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                        let v11493 : Result<std_path_PathBuf, string> = match v11483 with Ok x -> Ok x | Error x -> Error (v11484 x)
                                                                                                                                        let _v11485 = v11493 
                                                                                                                                        #endif
#else
                                                                                                                                        let v11494 : Result<std_path_PathBuf, string> = match v11483 with Ok x -> Ok x | Error x -> Error (v11484 x)
                                                                                                                                        let _v11485 = v11494 
                                                                                                                                        #endif
                                                                                                                                        let v11495 : Result<std_path_PathBuf, string> = _v11485 
                                                                                                                                        let v11498 : (std_path_PathBuf -> US8) = closure16()
                                                                                                                                        let v11499 : (string -> US8) = closure17()
                                                                                                                                        let v11500 : US8 = match v11495 with Ok x -> v11498 x | Error x -> v11499 x
                                                                                                                                        match v11500 with
                                                                                                                                        | US8_1(v11603) -> (* Error *)
                                                                                                                                            let v11604 : string = $"file_system.read_link / error': {v11603} / error: {v10152} / name: {v10155}"
                                                                                                                                            let v11605 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v11606 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v11607 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11604 v11606 
                                                                                                                                            let _v11605 = v11607 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v11608 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v11609 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11604 v11608 
                                                                                                                                            let _v11605 = v11609 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v11610 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v11611 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11604 v11610 
                                                                                                                                            let _v11605 = v11611 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v11612 : std_io_Error = v11604 
                                                                                                                                            let _v11605 = v11612 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v11613 : std_io_Error = v11604 
                                                                                                                                            let _v11605 = v11613 
                                                                                                                                            #endif
#else
                                                                                                                                            let v11614 : std_io_Error = v11604 
                                                                                                                                            let _v11605 = v11614 
                                                                                                                                            #endif
                                                                                                                                            let v11615 : std_io_Error = _v11605 
                                                                                                                                            let v11618 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v11619 : string = "Err($0)"
                                                                                                                                            let v11620 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11615 v11619 
                                                                                                                                            let _v11618 = v11620 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v11621 : string = "Err($0)"
                                                                                                                                            let v11622 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11615 v11621 
                                                                                                                                            let _v11618 = v11622 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v11623 : string = "Err($0)"
                                                                                                                                            let v11624 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11615 v11623 
                                                                                                                                            let _v11618 = v11624 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v11625 : Result<std_path_PathBuf, std_io_Error> = v11615 |> Error
                                                                                                                                            let _v11618 = v11625 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v11626 : Result<std_path_PathBuf, std_io_Error> = v11615 |> Error
                                                                                                                                            let _v11618 = v11626 
                                                                                                                                            #endif
#else
                                                                                                                                            let v11627 : Result<std_path_PathBuf, std_io_Error> = v11615 |> Error
                                                                                                                                            let _v11618 = v11627 
                                                                                                                                            #endif
                                                                                                                                            let v11628 : Result<std_path_PathBuf, std_io_Error> = _v11618 
                                                                                                                                            v11628
                                                                                                                                        | US8_0(v11501) -> (* Ok *)
                                                                                                                                            let v11502 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v11503 : string = "$0.display()"
                                                                                                                                            let v11504 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11501 v11503 
                                                                                                                                            let _v11502 = v11504 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v11505 : string = "$0.display()"
                                                                                                                                            let v11506 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11501 v11505 
                                                                                                                                            let _v11502 = v11506 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v11507 : string = "$0.display()"
                                                                                                                                            let v11508 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11501 v11507 
                                                                                                                                            let _v11502 = v11508 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v11509 : std_path_Display = v11501 |> unbox<std_path_Display>
                                                                                                                                            let _v11502 = v11509 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v11512 : std_path_Display = v11501 |> unbox<std_path_Display>
                                                                                                                                            let _v11502 = v11512 
                                                                                                                                            #endif
#else
                                                                                                                                            let v11515 : std_path_Display = v11501 |> unbox<std_path_Display>
                                                                                                                                            let _v11502 = v11515 
                                                                                                                                            #endif
                                                                                                                                            let v11518 : std_path_Display = _v11502 
                                                                                                                                            let v11523 : string = v11518 |> string 
                                                                                                                                            let v11526 : string = method26(v11523, v10155)
                                                                                                                                            let v11527 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v11528 : string = "&*$0"
                                                                                                                                            let v11529 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11526 v11528 
                                                                                                                                            let _v11527 = v11529 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v11530 : string = "&*$0"
                                                                                                                                            let v11531 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11526 v11530 
                                                                                                                                            let _v11527 = v11531 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v11532 : string = "&*$0"
                                                                                                                                            let v11533 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11526 v11532 
                                                                                                                                            let _v11527 = v11533 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v11534 : Ref<Str> = v11526 |> unbox<Ref<Str>>
                                                                                                                                            let _v11527 = v11534 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v11537 : Ref<Str> = v11526 |> unbox<Ref<Str>>
                                                                                                                                            let _v11527 = v11537 
                                                                                                                                            #endif
#else
                                                                                                                                            let v11540 : Ref<Str> = v11526 |> unbox<Ref<Str>>
                                                                                                                                            let _v11527 = v11540 
                                                                                                                                            #endif
                                                                                                                                            let v11543 : Ref<Str> = _v11527 
                                                                                                                                            let v11548 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v11549 : string = "String::from($0)"
                                                                                                                                            let v11550 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11543 v11549 
                                                                                                                                            let _v11548 = v11550 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v11551 : string = "String::from($0)"
                                                                                                                                            let v11552 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11543 v11551 
                                                                                                                                            let _v11548 = v11552 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v11553 : string = "String::from($0)"
                                                                                                                                            let v11554 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11543 v11553 
                                                                                                                                            let _v11548 = v11554 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v11555 : std_string_String = v11543 |> unbox<std_string_String>
                                                                                                                                            let _v11548 = v11555 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v11558 : std_string_String = v11543 |> unbox<std_string_String>
                                                                                                                                            let _v11548 = v11558 
                                                                                                                                            #endif
#else
                                                                                                                                            let v11561 : std_string_String = v11543 |> unbox<std_string_String>
                                                                                                                                            let _v11548 = v11561 
                                                                                                                                            #endif
                                                                                                                                            let v11564 : std_string_String = _v11548 
                                                                                                                                            let v11569 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v11570 : string = "std::path::PathBuf::from($0)"
                                                                                                                                            let v11571 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11564 v11570 
                                                                                                                                            let _v11569 = v11571 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v11572 : string = "std::path::PathBuf::from($0)"
                                                                                                                                            let v11573 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11564 v11572 
                                                                                                                                            let _v11569 = v11573 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v11574 : string = "std::path::PathBuf::from($0)"
                                                                                                                                            let v11575 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11564 v11574 
                                                                                                                                            let _v11569 = v11575 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v11576 : std_path_PathBuf = v11564 |> std_path_PathBuf 
                                                                                                                                            let _v11569 = v11576 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v11579 : std_path_PathBuf = v11564 |> std_path_PathBuf 
                                                                                                                                            let _v11569 = v11579 
                                                                                                                                            #endif
#else
                                                                                                                                            let v11582 : std_path_PathBuf = v11564 |> std_path_PathBuf 
                                                                                                                                            let _v11569 = v11582 
                                                                                                                                            #endif
                                                                                                                                            let v11585 : std_path_PathBuf = _v11569 
                                                                                                                                            let v11590 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v11591 : string = "Ok($0)"
                                                                                                                                            let v11592 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11585 v11591 
                                                                                                                                            let _v11590 = v11592 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v11593 : string = "Ok($0)"
                                                                                                                                            let v11594 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11585 v11593 
                                                                                                                                            let _v11590 = v11594 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v11595 : string = "Ok($0)"
                                                                                                                                            let v11596 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11585 v11595 
                                                                                                                                            let _v11590 = v11596 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v11597 : Result<std_path_PathBuf, std_io_Error> = v11585 |> Ok
                                                                                                                                            let _v11590 = v11597 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v11598 : Result<std_path_PathBuf, std_io_Error> = v11585 |> Ok
                                                                                                                                            let _v11590 = v11598 
                                                                                                                                            #endif
#else
                                                                                                                                            let v11599 : Result<std_path_PathBuf, std_io_Error> = v11585 |> Ok
                                                                                                                                            let _v11590 = v11599 
                                                                                                                                            #endif
                                                                                                                                            let v11600 : Result<std_path_PathBuf, std_io_Error> = _v11590 
                                                                                                                                            v11600
                                                                                                                                    else
                                                                                                                                        let v11633 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v10152} / path': {v10008} / name: {v10155}"
                                                                                                                                        let v11634 : unit = ()
                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                        let v11635 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                        let v11636 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11633 v11635 
                                                                                                                                        let _v11634 = v11636 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                        let v11637 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                        let v11638 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11633 v11637 
                                                                                                                                        let _v11634 = v11638 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                        let v11639 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                        let v11640 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11633 v11639 
                                                                                                                                        let _v11634 = v11640 
                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                        let v11641 : std_io_Error = v11633 
                                                                                                                                        let _v11634 = v11641 
                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                        let v11642 : std_io_Error = v11633 
                                                                                                                                        let _v11634 = v11642 
                                                                                                                                        #endif
#else
                                                                                                                                        let v11643 : std_io_Error = v11633 
                                                                                                                                        let _v11634 = v11643 
                                                                                                                                        #endif
                                                                                                                                        let v11644 : std_io_Error = _v11634 
                                                                                                                                        let v11647 : unit = ()
                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                        let v11648 : string = "Err($0)"
                                                                                                                                        let v11649 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11644 v11648 
                                                                                                                                        let _v11647 = v11649 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                        let v11650 : string = "Err($0)"
                                                                                                                                        let v11651 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11644 v11650 
                                                                                                                                        let _v11647 = v11651 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                        let v11652 : string = "Err($0)"
                                                                                                                                        let v11653 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11644 v11652 
                                                                                                                                        let _v11647 = v11653 
                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                        let v11654 : Result<std_path_PathBuf, std_io_Error> = v11644 |> Error
                                                                                                                                        let _v11647 = v11654 
                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                        let v11655 : Result<std_path_PathBuf, std_io_Error> = v11644 |> Error
                                                                                                                                        let _v11647 = v11655 
                                                                                                                                        #endif
#else
                                                                                                                                        let v11656 : Result<std_path_PathBuf, std_io_Error> = v11644 |> Error
                                                                                                                                        let _v11647 = v11656 
                                                                                                                                        #endif
                                                                                                                                        let v11657 : Result<std_path_PathBuf, std_io_Error> = _v11647 
                                                                                                                                        v11657
                                                                                                                                | _ ->
                                                                                                                                    let v11661 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v10152} / path': {v10008} / name: {v10155}"
                                                                                                                                    let v11662 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v11663 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                    let v11664 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11661 v11663 
                                                                                                                                    let _v11662 = v11664 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v11665 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                    let v11666 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11661 v11665 
                                                                                                                                    let _v11662 = v11666 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v11667 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                    let v11668 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11661 v11667 
                                                                                                                                    let _v11662 = v11668 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v11669 : std_io_Error = v11661 
                                                                                                                                    let _v11662 = v11669 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v11670 : std_io_Error = v11661 
                                                                                                                                    let _v11662 = v11670 
                                                                                                                                    #endif
#else
                                                                                                                                    let v11671 : std_io_Error = v11661 
                                                                                                                                    let _v11662 = v11671 
                                                                                                                                    #endif
                                                                                                                                    let v11672 : std_io_Error = _v11662 
                                                                                                                                    let v11675 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v11676 : string = "Err($0)"
                                                                                                                                    let v11677 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11672 v11676 
                                                                                                                                    let _v11675 = v11677 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v11678 : string = "Err($0)"
                                                                                                                                    let v11679 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11672 v11678 
                                                                                                                                    let _v11675 = v11679 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v11680 : string = "Err($0)"
                                                                                                                                    let v11681 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11672 v11680 
                                                                                                                                    let _v11675 = v11681 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v11682 : Result<std_path_PathBuf, std_io_Error> = v11672 |> Error
                                                                                                                                    let _v11675 = v11682 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v11683 : Result<std_path_PathBuf, std_io_Error> = v11672 |> Error
                                                                                                                                    let _v11675 = v11683 
                                                                                                                                    #endif
#else
                                                                                                                                    let v11684 : Result<std_path_PathBuf, std_io_Error> = v11672 |> Error
                                                                                                                                    let _v11675 = v11684 
                                                                                                                                    #endif
                                                                                                                                    let v11685 : Result<std_path_PathBuf, std_io_Error> = _v11675 
                                                                                                                                    v11685
                                                                                                                        let v11690 : (std_io_Error -> string) = method41()
                                                                                                                        let v11691 : unit = ()
                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                        let v11692 : string = "$0.map_err(|x| $1(x))"
                                                                                                                        let v11693 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11689, v11690) v11692 
                                                                                                                        let _v11691 = v11693 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                        let v11694 : string = "$0.map_err(|x| $1(x))"
                                                                                                                        let v11695 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11689, v11690) v11694 
                                                                                                                        let _v11691 = v11695 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                        let v11696 : string = "$0.map_err(|x| $1(x))"
                                                                                                                        let v11697 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11689, v11690) v11696 
                                                                                                                        let _v11691 = v11697 
                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                        let v11698 : Result<std_path_PathBuf, string> = match v11689 with Ok x -> Ok x | Error x -> Error (v11690 x)
                                                                                                                        let _v11691 = v11698 
                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                        let v11699 : Result<std_path_PathBuf, string> = match v11689 with Ok x -> Ok x | Error x -> Error (v11690 x)
                                                                                                                        let _v11691 = v11699 
                                                                                                                        #endif
#else
                                                                                                                        let v11700 : Result<std_path_PathBuf, string> = match v11689 with Ok x -> Ok x | Error x -> Error (v11690 x)
                                                                                                                        let _v11691 = v11700 
                                                                                                                        #endif
                                                                                                                        let v11701 : Result<std_path_PathBuf, string> = _v11691 
                                                                                                                        let v11704 : (std_path_PathBuf -> US8) = closure16()
                                                                                                                        let v11705 : (string -> US8) = closure17()
                                                                                                                        let v11706 : US8 = match v11701 with Ok x -> v11704 x | Error x -> v11705 x
                                                                                                                        match v11706 with
                                                                                                                        | US8_1(v11809) -> (* Error *)
                                                                                                                            let v11810 : string = $"file_system.read_link / error': {v11809} / error: {v9986} / name: {v9989}"
                                                                                                                            let v11811 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v11812 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v11813 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11810 v11812 
                                                                                                                            let _v11811 = v11813 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v11814 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v11815 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11810 v11814 
                                                                                                                            let _v11811 = v11815 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v11816 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v11817 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11810 v11816 
                                                                                                                            let _v11811 = v11817 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v11818 : std_io_Error = v11810 
                                                                                                                            let _v11811 = v11818 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v11819 : std_io_Error = v11810 
                                                                                                                            let _v11811 = v11819 
                                                                                                                            #endif
#else
                                                                                                                            let v11820 : std_io_Error = v11810 
                                                                                                                            let _v11811 = v11820 
                                                                                                                            #endif
                                                                                                                            let v11821 : std_io_Error = _v11811 
                                                                                                                            let v11824 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v11825 : string = "Err($0)"
                                                                                                                            let v11826 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11821 v11825 
                                                                                                                            let _v11824 = v11826 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v11827 : string = "Err($0)"
                                                                                                                            let v11828 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11821 v11827 
                                                                                                                            let _v11824 = v11828 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v11829 : string = "Err($0)"
                                                                                                                            let v11830 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11821 v11829 
                                                                                                                            let _v11824 = v11830 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v11831 : Result<std_path_PathBuf, std_io_Error> = v11821 |> Error
                                                                                                                            let _v11824 = v11831 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v11832 : Result<std_path_PathBuf, std_io_Error> = v11821 |> Error
                                                                                                                            let _v11824 = v11832 
                                                                                                                            #endif
#else
                                                                                                                            let v11833 : Result<std_path_PathBuf, std_io_Error> = v11821 |> Error
                                                                                                                            let _v11824 = v11833 
                                                                                                                            #endif
                                                                                                                            let v11834 : Result<std_path_PathBuf, std_io_Error> = _v11824 
                                                                                                                            v11834
                                                                                                                        | US8_0(v11707) -> (* Ok *)
                                                                                                                            let v11708 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v11709 : string = "$0.display()"
                                                                                                                            let v11710 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11707 v11709 
                                                                                                                            let _v11708 = v11710 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v11711 : string = "$0.display()"
                                                                                                                            let v11712 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11707 v11711 
                                                                                                                            let _v11708 = v11712 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v11713 : string = "$0.display()"
                                                                                                                            let v11714 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11707 v11713 
                                                                                                                            let _v11708 = v11714 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v11715 : std_path_Display = v11707 |> unbox<std_path_Display>
                                                                                                                            let _v11708 = v11715 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v11718 : std_path_Display = v11707 |> unbox<std_path_Display>
                                                                                                                            let _v11708 = v11718 
                                                                                                                            #endif
#else
                                                                                                                            let v11721 : std_path_Display = v11707 |> unbox<std_path_Display>
                                                                                                                            let _v11708 = v11721 
                                                                                                                            #endif
                                                                                                                            let v11724 : std_path_Display = _v11708 
                                                                                                                            let v11729 : string = v11724 |> string 
                                                                                                                            let v11732 : string = method26(v11729, v9989)
                                                                                                                            let v11733 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v11734 : string = "&*$0"
                                                                                                                            let v11735 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11732 v11734 
                                                                                                                            let _v11733 = v11735 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v11736 : string = "&*$0"
                                                                                                                            let v11737 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11732 v11736 
                                                                                                                            let _v11733 = v11737 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v11738 : string = "&*$0"
                                                                                                                            let v11739 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11732 v11738 
                                                                                                                            let _v11733 = v11739 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v11740 : Ref<Str> = v11732 |> unbox<Ref<Str>>
                                                                                                                            let _v11733 = v11740 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v11743 : Ref<Str> = v11732 |> unbox<Ref<Str>>
                                                                                                                            let _v11733 = v11743 
                                                                                                                            #endif
#else
                                                                                                                            let v11746 : Ref<Str> = v11732 |> unbox<Ref<Str>>
                                                                                                                            let _v11733 = v11746 
                                                                                                                            #endif
                                                                                                                            let v11749 : Ref<Str> = _v11733 
                                                                                                                            let v11754 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v11755 : string = "String::from($0)"
                                                                                                                            let v11756 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11749 v11755 
                                                                                                                            let _v11754 = v11756 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v11757 : string = "String::from($0)"
                                                                                                                            let v11758 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11749 v11757 
                                                                                                                            let _v11754 = v11758 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v11759 : string = "String::from($0)"
                                                                                                                            let v11760 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11749 v11759 
                                                                                                                            let _v11754 = v11760 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v11761 : std_string_String = v11749 |> unbox<std_string_String>
                                                                                                                            let _v11754 = v11761 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v11764 : std_string_String = v11749 |> unbox<std_string_String>
                                                                                                                            let _v11754 = v11764 
                                                                                                                            #endif
#else
                                                                                                                            let v11767 : std_string_String = v11749 |> unbox<std_string_String>
                                                                                                                            let _v11754 = v11767 
                                                                                                                            #endif
                                                                                                                            let v11770 : std_string_String = _v11754 
                                                                                                                            let v11775 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v11776 : string = "std::path::PathBuf::from($0)"
                                                                                                                            let v11777 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11770 v11776 
                                                                                                                            let _v11775 = v11777 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v11778 : string = "std::path::PathBuf::from($0)"
                                                                                                                            let v11779 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11770 v11778 
                                                                                                                            let _v11775 = v11779 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v11780 : string = "std::path::PathBuf::from($0)"
                                                                                                                            let v11781 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11770 v11780 
                                                                                                                            let _v11775 = v11781 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v11782 : std_path_PathBuf = v11770 |> std_path_PathBuf 
                                                                                                                            let _v11775 = v11782 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v11785 : std_path_PathBuf = v11770 |> std_path_PathBuf 
                                                                                                                            let _v11775 = v11785 
                                                                                                                            #endif
#else
                                                                                                                            let v11788 : std_path_PathBuf = v11770 |> std_path_PathBuf 
                                                                                                                            let _v11775 = v11788 
                                                                                                                            #endif
                                                                                                                            let v11791 : std_path_PathBuf = _v11775 
                                                                                                                            let v11796 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v11797 : string = "Ok($0)"
                                                                                                                            let v11798 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11791 v11797 
                                                                                                                            let _v11796 = v11798 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v11799 : string = "Ok($0)"
                                                                                                                            let v11800 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11791 v11799 
                                                                                                                            let _v11796 = v11800 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v11801 : string = "Ok($0)"
                                                                                                                            let v11802 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11791 v11801 
                                                                                                                            let _v11796 = v11802 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v11803 : Result<std_path_PathBuf, std_io_Error> = v11791 |> Ok
                                                                                                                            let _v11796 = v11803 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v11804 : Result<std_path_PathBuf, std_io_Error> = v11791 |> Ok
                                                                                                                            let _v11796 = v11804 
                                                                                                                            #endif
#else
                                                                                                                            let v11805 : Result<std_path_PathBuf, std_io_Error> = v11791 |> Ok
                                                                                                                            let _v11796 = v11805 
                                                                                                                            #endif
                                                                                                                            let v11806 : Result<std_path_PathBuf, std_io_Error> = _v11796 
                                                                                                                            v11806
                                                                                                                    else
                                                                                                                        let v11839 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v9986} / path': {v9842} / name: {v9989}"
                                                                                                                        let v11840 : unit = ()
                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                        let v11841 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                        let v11842 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11839 v11841 
                                                                                                                        let _v11840 = v11842 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                        let v11843 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                        let v11844 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11839 v11843 
                                                                                                                        let _v11840 = v11844 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                        let v11845 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                        let v11846 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11839 v11845 
                                                                                                                        let _v11840 = v11846 
                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                        let v11847 : std_io_Error = v11839 
                                                                                                                        let _v11840 = v11847 
                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                        let v11848 : std_io_Error = v11839 
                                                                                                                        let _v11840 = v11848 
                                                                                                                        #endif
#else
                                                                                                                        let v11849 : std_io_Error = v11839 
                                                                                                                        let _v11840 = v11849 
                                                                                                                        #endif
                                                                                                                        let v11850 : std_io_Error = _v11840 
                                                                                                                        let v11853 : unit = ()
                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                        let v11854 : string = "Err($0)"
                                                                                                                        let v11855 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11850 v11854 
                                                                                                                        let _v11853 = v11855 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                        let v11856 : string = "Err($0)"
                                                                                                                        let v11857 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11850 v11856 
                                                                                                                        let _v11853 = v11857 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                        let v11858 : string = "Err($0)"
                                                                                                                        let v11859 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11850 v11858 
                                                                                                                        let _v11853 = v11859 
                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                        let v11860 : Result<std_path_PathBuf, std_io_Error> = v11850 |> Error
                                                                                                                        let _v11853 = v11860 
                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                        let v11861 : Result<std_path_PathBuf, std_io_Error> = v11850 |> Error
                                                                                                                        let _v11853 = v11861 
                                                                                                                        #endif
#else
                                                                                                                        let v11862 : Result<std_path_PathBuf, std_io_Error> = v11850 |> Error
                                                                                                                        let _v11853 = v11862 
                                                                                                                        #endif
                                                                                                                        let v11863 : Result<std_path_PathBuf, std_io_Error> = _v11853 
                                                                                                                        v11863
                                                                                                                | _ ->
                                                                                                                    let v11867 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v9986} / path': {v9842} / name: {v9989}"
                                                                                                                    let v11868 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v11869 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                    let v11870 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11867 v11869 
                                                                                                                    let _v11868 = v11870 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v11871 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                    let v11872 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11867 v11871 
                                                                                                                    let _v11868 = v11872 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v11873 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                    let v11874 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11867 v11873 
                                                                                                                    let _v11868 = v11874 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v11875 : std_io_Error = v11867 
                                                                                                                    let _v11868 = v11875 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v11876 : std_io_Error = v11867 
                                                                                                                    let _v11868 = v11876 
                                                                                                                    #endif
#else
                                                                                                                    let v11877 : std_io_Error = v11867 
                                                                                                                    let _v11868 = v11877 
                                                                                                                    #endif
                                                                                                                    let v11878 : std_io_Error = _v11868 
                                                                                                                    let v11881 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v11882 : string = "Err($0)"
                                                                                                                    let v11883 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11878 v11882 
                                                                                                                    let _v11881 = v11883 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v11884 : string = "Err($0)"
                                                                                                                    let v11885 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11878 v11884 
                                                                                                                    let _v11881 = v11885 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v11886 : string = "Err($0)"
                                                                                                                    let v11887 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11878 v11886 
                                                                                                                    let _v11881 = v11887 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v11888 : Result<std_path_PathBuf, std_io_Error> = v11878 |> Error
                                                                                                                    let _v11881 = v11888 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v11889 : Result<std_path_PathBuf, std_io_Error> = v11878 |> Error
                                                                                                                    let _v11881 = v11889 
                                                                                                                    #endif
#else
                                                                                                                    let v11890 : Result<std_path_PathBuf, std_io_Error> = v11878 |> Error
                                                                                                                    let _v11881 = v11890 
                                                                                                                    #endif
                                                                                                                    let v11891 : Result<std_path_PathBuf, std_io_Error> = _v11881 
                                                                                                                    v11891
                                                                                                        let v11896 : (std_io_Error -> string) = method41()
                                                                                                        let v11897 : unit = ()
                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                        let v11898 : string = "$0.map_err(|x| $1(x))"
                                                                                                        let v11899 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11895, v11896) v11898 
                                                                                                        let _v11897 = v11899 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                        let v11900 : string = "$0.map_err(|x| $1(x))"
                                                                                                        let v11901 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11895, v11896) v11900 
                                                                                                        let _v11897 = v11901 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                        let v11902 : string = "$0.map_err(|x| $1(x))"
                                                                                                        let v11903 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11895, v11896) v11902 
                                                                                                        let _v11897 = v11903 
                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                        let v11904 : Result<std_path_PathBuf, string> = match v11895 with Ok x -> Ok x | Error x -> Error (v11896 x)
                                                                                                        let _v11897 = v11904 
                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                        let v11905 : Result<std_path_PathBuf, string> = match v11895 with Ok x -> Ok x | Error x -> Error (v11896 x)
                                                                                                        let _v11897 = v11905 
                                                                                                        #endif
#else
                                                                                                        let v11906 : Result<std_path_PathBuf, string> = match v11895 with Ok x -> Ok x | Error x -> Error (v11896 x)
                                                                                                        let _v11897 = v11906 
                                                                                                        #endif
                                                                                                        let v11907 : Result<std_path_PathBuf, string> = _v11897 
                                                                                                        let v11910 : (std_path_PathBuf -> US8) = closure16()
                                                                                                        let v11911 : (string -> US8) = closure17()
                                                                                                        let v11912 : US8 = match v11907 with Ok x -> v11910 x | Error x -> v11911 x
                                                                                                        match v11912 with
                                                                                                        | US8_1(v12015) -> (* Error *)
                                                                                                            let v12016 : string = $"file_system.read_link / error': {v12015} / error: {v9820} / name: {v9823}"
                                                                                                            let v12017 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v12018 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v12019 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12016 v12018 
                                                                                                            let _v12017 = v12019 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v12020 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v12021 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12016 v12020 
                                                                                                            let _v12017 = v12021 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v12022 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v12023 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12016 v12022 
                                                                                                            let _v12017 = v12023 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v12024 : std_io_Error = v12016 
                                                                                                            let _v12017 = v12024 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v12025 : std_io_Error = v12016 
                                                                                                            let _v12017 = v12025 
                                                                                                            #endif
#else
                                                                                                            let v12026 : std_io_Error = v12016 
                                                                                                            let _v12017 = v12026 
                                                                                                            #endif
                                                                                                            let v12027 : std_io_Error = _v12017 
                                                                                                            let v12030 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v12031 : string = "Err($0)"
                                                                                                            let v12032 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12027 v12031 
                                                                                                            let _v12030 = v12032 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v12033 : string = "Err($0)"
                                                                                                            let v12034 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12027 v12033 
                                                                                                            let _v12030 = v12034 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v12035 : string = "Err($0)"
                                                                                                            let v12036 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12027 v12035 
                                                                                                            let _v12030 = v12036 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v12037 : Result<std_path_PathBuf, std_io_Error> = v12027 |> Error
                                                                                                            let _v12030 = v12037 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v12038 : Result<std_path_PathBuf, std_io_Error> = v12027 |> Error
                                                                                                            let _v12030 = v12038 
                                                                                                            #endif
#else
                                                                                                            let v12039 : Result<std_path_PathBuf, std_io_Error> = v12027 |> Error
                                                                                                            let _v12030 = v12039 
                                                                                                            #endif
                                                                                                            let v12040 : Result<std_path_PathBuf, std_io_Error> = _v12030 
                                                                                                            v12040
                                                                                                        | US8_0(v11913) -> (* Ok *)
                                                                                                            let v11914 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v11915 : string = "$0.display()"
                                                                                                            let v11916 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11913 v11915 
                                                                                                            let _v11914 = v11916 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v11917 : string = "$0.display()"
                                                                                                            let v11918 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11913 v11917 
                                                                                                            let _v11914 = v11918 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v11919 : string = "$0.display()"
                                                                                                            let v11920 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11913 v11919 
                                                                                                            let _v11914 = v11920 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v11921 : std_path_Display = v11913 |> unbox<std_path_Display>
                                                                                                            let _v11914 = v11921 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v11924 : std_path_Display = v11913 |> unbox<std_path_Display>
                                                                                                            let _v11914 = v11924 
                                                                                                            #endif
#else
                                                                                                            let v11927 : std_path_Display = v11913 |> unbox<std_path_Display>
                                                                                                            let _v11914 = v11927 
                                                                                                            #endif
                                                                                                            let v11930 : std_path_Display = _v11914 
                                                                                                            let v11935 : string = v11930 |> string 
                                                                                                            let v11938 : string = method26(v11935, v9823)
                                                                                                            let v11939 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v11940 : string = "&*$0"
                                                                                                            let v11941 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11938 v11940 
                                                                                                            let _v11939 = v11941 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v11942 : string = "&*$0"
                                                                                                            let v11943 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11938 v11942 
                                                                                                            let _v11939 = v11943 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v11944 : string = "&*$0"
                                                                                                            let v11945 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11938 v11944 
                                                                                                            let _v11939 = v11945 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v11946 : Ref<Str> = v11938 |> unbox<Ref<Str>>
                                                                                                            let _v11939 = v11946 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v11949 : Ref<Str> = v11938 |> unbox<Ref<Str>>
                                                                                                            let _v11939 = v11949 
                                                                                                            #endif
#else
                                                                                                            let v11952 : Ref<Str> = v11938 |> unbox<Ref<Str>>
                                                                                                            let _v11939 = v11952 
                                                                                                            #endif
                                                                                                            let v11955 : Ref<Str> = _v11939 
                                                                                                            let v11960 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v11961 : string = "String::from($0)"
                                                                                                            let v11962 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11955 v11961 
                                                                                                            let _v11960 = v11962 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v11963 : string = "String::from($0)"
                                                                                                            let v11964 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11955 v11963 
                                                                                                            let _v11960 = v11964 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v11965 : string = "String::from($0)"
                                                                                                            let v11966 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11955 v11965 
                                                                                                            let _v11960 = v11966 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v11967 : std_string_String = v11955 |> unbox<std_string_String>
                                                                                                            let _v11960 = v11967 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v11970 : std_string_String = v11955 |> unbox<std_string_String>
                                                                                                            let _v11960 = v11970 
                                                                                                            #endif
#else
                                                                                                            let v11973 : std_string_String = v11955 |> unbox<std_string_String>
                                                                                                            let _v11960 = v11973 
                                                                                                            #endif
                                                                                                            let v11976 : std_string_String = _v11960 
                                                                                                            let v11981 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v11982 : string = "std::path::PathBuf::from($0)"
                                                                                                            let v11983 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11976 v11982 
                                                                                                            let _v11981 = v11983 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v11984 : string = "std::path::PathBuf::from($0)"
                                                                                                            let v11985 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11976 v11984 
                                                                                                            let _v11981 = v11985 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v11986 : string = "std::path::PathBuf::from($0)"
                                                                                                            let v11987 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11976 v11986 
                                                                                                            let _v11981 = v11987 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v11988 : std_path_PathBuf = v11976 |> std_path_PathBuf 
                                                                                                            let _v11981 = v11988 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v11991 : std_path_PathBuf = v11976 |> std_path_PathBuf 
                                                                                                            let _v11981 = v11991 
                                                                                                            #endif
#else
                                                                                                            let v11994 : std_path_PathBuf = v11976 |> std_path_PathBuf 
                                                                                                            let _v11981 = v11994 
                                                                                                            #endif
                                                                                                            let v11997 : std_path_PathBuf = _v11981 
                                                                                                            let v12002 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v12003 : string = "Ok($0)"
                                                                                                            let v12004 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11997 v12003 
                                                                                                            let _v12002 = v12004 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v12005 : string = "Ok($0)"
                                                                                                            let v12006 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11997 v12005 
                                                                                                            let _v12002 = v12006 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v12007 : string = "Ok($0)"
                                                                                                            let v12008 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11997 v12007 
                                                                                                            let _v12002 = v12008 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v12009 : Result<std_path_PathBuf, std_io_Error> = v11997 |> Ok
                                                                                                            let _v12002 = v12009 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v12010 : Result<std_path_PathBuf, std_io_Error> = v11997 |> Ok
                                                                                                            let _v12002 = v12010 
                                                                                                            #endif
#else
                                                                                                            let v12011 : Result<std_path_PathBuf, std_io_Error> = v11997 |> Ok
                                                                                                            let _v12002 = v12011 
                                                                                                            #endif
                                                                                                            let v12012 : Result<std_path_PathBuf, std_io_Error> = _v12002 
                                                                                                            v12012
                                                                                                    else
                                                                                                        let v12045 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v9820} / path': {v9676} / name: {v9823}"
                                                                                                        let v12046 : unit = ()
                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                        let v12047 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                        let v12048 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12045 v12047 
                                                                                                        let _v12046 = v12048 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                        let v12049 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                        let v12050 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12045 v12049 
                                                                                                        let _v12046 = v12050 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                        let v12051 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                        let v12052 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12045 v12051 
                                                                                                        let _v12046 = v12052 
                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                        let v12053 : std_io_Error = v12045 
                                                                                                        let _v12046 = v12053 
                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                        let v12054 : std_io_Error = v12045 
                                                                                                        let _v12046 = v12054 
                                                                                                        #endif
#else
                                                                                                        let v12055 : std_io_Error = v12045 
                                                                                                        let _v12046 = v12055 
                                                                                                        #endif
                                                                                                        let v12056 : std_io_Error = _v12046 
                                                                                                        let v12059 : unit = ()
                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                        let v12060 : string = "Err($0)"
                                                                                                        let v12061 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12056 v12060 
                                                                                                        let _v12059 = v12061 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                        let v12062 : string = "Err($0)"
                                                                                                        let v12063 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12056 v12062 
                                                                                                        let _v12059 = v12063 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                        let v12064 : string = "Err($0)"
                                                                                                        let v12065 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12056 v12064 
                                                                                                        let _v12059 = v12065 
                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                        let v12066 : Result<std_path_PathBuf, std_io_Error> = v12056 |> Error
                                                                                                        let _v12059 = v12066 
                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                        let v12067 : Result<std_path_PathBuf, std_io_Error> = v12056 |> Error
                                                                                                        let _v12059 = v12067 
                                                                                                        #endif
#else
                                                                                                        let v12068 : Result<std_path_PathBuf, std_io_Error> = v12056 |> Error
                                                                                                        let _v12059 = v12068 
                                                                                                        #endif
                                                                                                        let v12069 : Result<std_path_PathBuf, std_io_Error> = _v12059 
                                                                                                        v12069
                                                                                                | _ ->
                                                                                                    let v12073 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v9820} / path': {v9676} / name: {v9823}"
                                                                                                    let v12074 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v12075 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                    let v12076 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12073 v12075 
                                                                                                    let _v12074 = v12076 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v12077 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                    let v12078 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12073 v12077 
                                                                                                    let _v12074 = v12078 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v12079 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                    let v12080 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12073 v12079 
                                                                                                    let _v12074 = v12080 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v12081 : std_io_Error = v12073 
                                                                                                    let _v12074 = v12081 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v12082 : std_io_Error = v12073 
                                                                                                    let _v12074 = v12082 
                                                                                                    #endif
#else
                                                                                                    let v12083 : std_io_Error = v12073 
                                                                                                    let _v12074 = v12083 
                                                                                                    #endif
                                                                                                    let v12084 : std_io_Error = _v12074 
                                                                                                    let v12087 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v12088 : string = "Err($0)"
                                                                                                    let v12089 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12084 v12088 
                                                                                                    let _v12087 = v12089 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v12090 : string = "Err($0)"
                                                                                                    let v12091 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12084 v12090 
                                                                                                    let _v12087 = v12091 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v12092 : string = "Err($0)"
                                                                                                    let v12093 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12084 v12092 
                                                                                                    let _v12087 = v12093 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v12094 : Result<std_path_PathBuf, std_io_Error> = v12084 |> Error
                                                                                                    let _v12087 = v12094 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v12095 : Result<std_path_PathBuf, std_io_Error> = v12084 |> Error
                                                                                                    let _v12087 = v12095 
                                                                                                    #endif
#else
                                                                                                    let v12096 : Result<std_path_PathBuf, std_io_Error> = v12084 |> Error
                                                                                                    let _v12087 = v12096 
                                                                                                    #endif
                                                                                                    let v12097 : Result<std_path_PathBuf, std_io_Error> = _v12087 
                                                                                                    v12097
                                                                                        let v12102 : (std_io_Error -> string) = method41()
                                                                                        let v12103 : unit = ()
                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                        let v12104 : string = "$0.map_err(|x| $1(x))"
                                                                                        let v12105 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12101, v12102) v12104 
                                                                                        let _v12103 = v12105 
                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                        let v12106 : string = "$0.map_err(|x| $1(x))"
                                                                                        let v12107 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12101, v12102) v12106 
                                                                                        let _v12103 = v12107 
                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                        let v12108 : string = "$0.map_err(|x| $1(x))"
                                                                                        let v12109 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12101, v12102) v12108 
                                                                                        let _v12103 = v12109 
                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                        let v12110 : Result<std_path_PathBuf, string> = match v12101 with Ok x -> Ok x | Error x -> Error (v12102 x)
                                                                                        let _v12103 = v12110 
                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                        let v12111 : Result<std_path_PathBuf, string> = match v12101 with Ok x -> Ok x | Error x -> Error (v12102 x)
                                                                                        let _v12103 = v12111 
                                                                                        #endif
#else
                                                                                        let v12112 : Result<std_path_PathBuf, string> = match v12101 with Ok x -> Ok x | Error x -> Error (v12102 x)
                                                                                        let _v12103 = v12112 
                                                                                        #endif
                                                                                        let v12113 : Result<std_path_PathBuf, string> = _v12103 
                                                                                        let v12116 : (std_path_PathBuf -> US8) = closure16()
                                                                                        let v12117 : (string -> US8) = closure17()
                                                                                        let v12118 : US8 = match v12113 with Ok x -> v12116 x | Error x -> v12117 x
                                                                                        match v12118 with
                                                                                        | US8_1(v12221) -> (* Error *)
                                                                                            let v12222 : string = $"file_system.read_link / error': {v12221} / error: {v9654} / name: {v9657}"
                                                                                            let v12223 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v12224 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v12225 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12222 v12224 
                                                                                            let _v12223 = v12225 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v12226 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v12227 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12222 v12226 
                                                                                            let _v12223 = v12227 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v12228 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v12229 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12222 v12228 
                                                                                            let _v12223 = v12229 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v12230 : std_io_Error = v12222 
                                                                                            let _v12223 = v12230 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v12231 : std_io_Error = v12222 
                                                                                            let _v12223 = v12231 
                                                                                            #endif
#else
                                                                                            let v12232 : std_io_Error = v12222 
                                                                                            let _v12223 = v12232 
                                                                                            #endif
                                                                                            let v12233 : std_io_Error = _v12223 
                                                                                            let v12236 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v12237 : string = "Err($0)"
                                                                                            let v12238 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12233 v12237 
                                                                                            let _v12236 = v12238 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v12239 : string = "Err($0)"
                                                                                            let v12240 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12233 v12239 
                                                                                            let _v12236 = v12240 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v12241 : string = "Err($0)"
                                                                                            let v12242 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12233 v12241 
                                                                                            let _v12236 = v12242 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v12243 : Result<std_path_PathBuf, std_io_Error> = v12233 |> Error
                                                                                            let _v12236 = v12243 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v12244 : Result<std_path_PathBuf, std_io_Error> = v12233 |> Error
                                                                                            let _v12236 = v12244 
                                                                                            #endif
#else
                                                                                            let v12245 : Result<std_path_PathBuf, std_io_Error> = v12233 |> Error
                                                                                            let _v12236 = v12245 
                                                                                            #endif
                                                                                            let v12246 : Result<std_path_PathBuf, std_io_Error> = _v12236 
                                                                                            v12246
                                                                                        | US8_0(v12119) -> (* Ok *)
                                                                                            let v12120 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v12121 : string = "$0.display()"
                                                                                            let v12122 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12119 v12121 
                                                                                            let _v12120 = v12122 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v12123 : string = "$0.display()"
                                                                                            let v12124 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12119 v12123 
                                                                                            let _v12120 = v12124 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v12125 : string = "$0.display()"
                                                                                            let v12126 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12119 v12125 
                                                                                            let _v12120 = v12126 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v12127 : std_path_Display = v12119 |> unbox<std_path_Display>
                                                                                            let _v12120 = v12127 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v12130 : std_path_Display = v12119 |> unbox<std_path_Display>
                                                                                            let _v12120 = v12130 
                                                                                            #endif
#else
                                                                                            let v12133 : std_path_Display = v12119 |> unbox<std_path_Display>
                                                                                            let _v12120 = v12133 
                                                                                            #endif
                                                                                            let v12136 : std_path_Display = _v12120 
                                                                                            let v12141 : string = v12136 |> string 
                                                                                            let v12144 : string = method26(v12141, v9657)
                                                                                            let v12145 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v12146 : string = "&*$0"
                                                                                            let v12147 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12144 v12146 
                                                                                            let _v12145 = v12147 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v12148 : string = "&*$0"
                                                                                            let v12149 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12144 v12148 
                                                                                            let _v12145 = v12149 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v12150 : string = "&*$0"
                                                                                            let v12151 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12144 v12150 
                                                                                            let _v12145 = v12151 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v12152 : Ref<Str> = v12144 |> unbox<Ref<Str>>
                                                                                            let _v12145 = v12152 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v12155 : Ref<Str> = v12144 |> unbox<Ref<Str>>
                                                                                            let _v12145 = v12155 
                                                                                            #endif
#else
                                                                                            let v12158 : Ref<Str> = v12144 |> unbox<Ref<Str>>
                                                                                            let _v12145 = v12158 
                                                                                            #endif
                                                                                            let v12161 : Ref<Str> = _v12145 
                                                                                            let v12166 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v12167 : string = "String::from($0)"
                                                                                            let v12168 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12161 v12167 
                                                                                            let _v12166 = v12168 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v12169 : string = "String::from($0)"
                                                                                            let v12170 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12161 v12169 
                                                                                            let _v12166 = v12170 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v12171 : string = "String::from($0)"
                                                                                            let v12172 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12161 v12171 
                                                                                            let _v12166 = v12172 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v12173 : std_string_String = v12161 |> unbox<std_string_String>
                                                                                            let _v12166 = v12173 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v12176 : std_string_String = v12161 |> unbox<std_string_String>
                                                                                            let _v12166 = v12176 
                                                                                            #endif
#else
                                                                                            let v12179 : std_string_String = v12161 |> unbox<std_string_String>
                                                                                            let _v12166 = v12179 
                                                                                            #endif
                                                                                            let v12182 : std_string_String = _v12166 
                                                                                            let v12187 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v12188 : string = "std::path::PathBuf::from($0)"
                                                                                            let v12189 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12182 v12188 
                                                                                            let _v12187 = v12189 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v12190 : string = "std::path::PathBuf::from($0)"
                                                                                            let v12191 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12182 v12190 
                                                                                            let _v12187 = v12191 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v12192 : string = "std::path::PathBuf::from($0)"
                                                                                            let v12193 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12182 v12192 
                                                                                            let _v12187 = v12193 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v12194 : std_path_PathBuf = v12182 |> std_path_PathBuf 
                                                                                            let _v12187 = v12194 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v12197 : std_path_PathBuf = v12182 |> std_path_PathBuf 
                                                                                            let _v12187 = v12197 
                                                                                            #endif
#else
                                                                                            let v12200 : std_path_PathBuf = v12182 |> std_path_PathBuf 
                                                                                            let _v12187 = v12200 
                                                                                            #endif
                                                                                            let v12203 : std_path_PathBuf = _v12187 
                                                                                            let v12208 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v12209 : string = "Ok($0)"
                                                                                            let v12210 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12203 v12209 
                                                                                            let _v12208 = v12210 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v12211 : string = "Ok($0)"
                                                                                            let v12212 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12203 v12211 
                                                                                            let _v12208 = v12212 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v12213 : string = "Ok($0)"
                                                                                            let v12214 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12203 v12213 
                                                                                            let _v12208 = v12214 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v12215 : Result<std_path_PathBuf, std_io_Error> = v12203 |> Ok
                                                                                            let _v12208 = v12215 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v12216 : Result<std_path_PathBuf, std_io_Error> = v12203 |> Ok
                                                                                            let _v12208 = v12216 
                                                                                            #endif
#else
                                                                                            let v12217 : Result<std_path_PathBuf, std_io_Error> = v12203 |> Ok
                                                                                            let _v12208 = v12217 
                                                                                            #endif
                                                                                            let v12218 : Result<std_path_PathBuf, std_io_Error> = _v12208 
                                                                                            v12218
                                                                                    else
                                                                                        let v12251 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v9654} / path': {v9510} / name: {v9657}"
                                                                                        let v12252 : unit = ()
                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                        let v12253 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                        let v12254 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12251 v12253 
                                                                                        let _v12252 = v12254 
                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                        let v12255 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                        let v12256 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12251 v12255 
                                                                                        let _v12252 = v12256 
                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                        let v12257 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                        let v12258 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12251 v12257 
                                                                                        let _v12252 = v12258 
                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                        let v12259 : std_io_Error = v12251 
                                                                                        let _v12252 = v12259 
                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                        let v12260 : std_io_Error = v12251 
                                                                                        let _v12252 = v12260 
                                                                                        #endif
#else
                                                                                        let v12261 : std_io_Error = v12251 
                                                                                        let _v12252 = v12261 
                                                                                        #endif
                                                                                        let v12262 : std_io_Error = _v12252 
                                                                                        let v12265 : unit = ()
                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                        let v12266 : string = "Err($0)"
                                                                                        let v12267 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12262 v12266 
                                                                                        let _v12265 = v12267 
                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                        let v12268 : string = "Err($0)"
                                                                                        let v12269 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12262 v12268 
                                                                                        let _v12265 = v12269 
                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                        let v12270 : string = "Err($0)"
                                                                                        let v12271 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12262 v12270 
                                                                                        let _v12265 = v12271 
                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                        let v12272 : Result<std_path_PathBuf, std_io_Error> = v12262 |> Error
                                                                                        let _v12265 = v12272 
                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                        let v12273 : Result<std_path_PathBuf, std_io_Error> = v12262 |> Error
                                                                                        let _v12265 = v12273 
                                                                                        #endif
#else
                                                                                        let v12274 : Result<std_path_PathBuf, std_io_Error> = v12262 |> Error
                                                                                        let _v12265 = v12274 
                                                                                        #endif
                                                                                        let v12275 : Result<std_path_PathBuf, std_io_Error> = _v12265 
                                                                                        v12275
                                                                                | _ ->
                                                                                    let v12279 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v9654} / path': {v9510} / name: {v9657}"
                                                                                    let v12280 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v12281 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                    let v12282 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12279 v12281 
                                                                                    let _v12280 = v12282 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v12283 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                    let v12284 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12279 v12283 
                                                                                    let _v12280 = v12284 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v12285 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                    let v12286 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12279 v12285 
                                                                                    let _v12280 = v12286 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v12287 : std_io_Error = v12279 
                                                                                    let _v12280 = v12287 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v12288 : std_io_Error = v12279 
                                                                                    let _v12280 = v12288 
                                                                                    #endif
#else
                                                                                    let v12289 : std_io_Error = v12279 
                                                                                    let _v12280 = v12289 
                                                                                    #endif
                                                                                    let v12290 : std_io_Error = _v12280 
                                                                                    let v12293 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v12294 : string = "Err($0)"
                                                                                    let v12295 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12290 v12294 
                                                                                    let _v12293 = v12295 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v12296 : string = "Err($0)"
                                                                                    let v12297 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12290 v12296 
                                                                                    let _v12293 = v12297 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v12298 : string = "Err($0)"
                                                                                    let v12299 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12290 v12298 
                                                                                    let _v12293 = v12299 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v12300 : Result<std_path_PathBuf, std_io_Error> = v12290 |> Error
                                                                                    let _v12293 = v12300 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v12301 : Result<std_path_PathBuf, std_io_Error> = v12290 |> Error
                                                                                    let _v12293 = v12301 
                                                                                    #endif
#else
                                                                                    let v12302 : Result<std_path_PathBuf, std_io_Error> = v12290 |> Error
                                                                                    let _v12293 = v12302 
                                                                                    #endif
                                                                                    let v12303 : Result<std_path_PathBuf, std_io_Error> = _v12293 
                                                                                    v12303
                                                                        let v12308 : (std_io_Error -> string) = method41()
                                                                        let v12309 : unit = ()
                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                        let v12310 : string = "$0.map_err(|x| $1(x))"
                                                                        let v12311 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12307, v12308) v12310 
                                                                        let _v12309 = v12311 
                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                        let v12312 : string = "$0.map_err(|x| $1(x))"
                                                                        let v12313 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12307, v12308) v12312 
                                                                        let _v12309 = v12313 
                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                        let v12314 : string = "$0.map_err(|x| $1(x))"
                                                                        let v12315 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12307, v12308) v12314 
                                                                        let _v12309 = v12315 
                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                        let v12316 : Result<std_path_PathBuf, string> = match v12307 with Ok x -> Ok x | Error x -> Error (v12308 x)
                                                                        let _v12309 = v12316 
                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                        let v12317 : Result<std_path_PathBuf, string> = match v12307 with Ok x -> Ok x | Error x -> Error (v12308 x)
                                                                        let _v12309 = v12317 
                                                                        #endif
#else
                                                                        let v12318 : Result<std_path_PathBuf, string> = match v12307 with Ok x -> Ok x | Error x -> Error (v12308 x)
                                                                        let _v12309 = v12318 
                                                                        #endif
                                                                        let v12319 : Result<std_path_PathBuf, string> = _v12309 
                                                                        let v12322 : (std_path_PathBuf -> US8) = closure16()
                                                                        let v12323 : (string -> US8) = closure17()
                                                                        let v12324 : US8 = match v12319 with Ok x -> v12322 x | Error x -> v12323 x
                                                                        match v12324 with
                                                                        | US8_1(v12427) -> (* Error *)
                                                                            let v12428 : string = $"file_system.read_link / error': {v12427} / error: {v9488} / name: {v9491}"
                                                                            let v12429 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v12430 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v12431 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12428 v12430 
                                                                            let _v12429 = v12431 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v12432 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v12433 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12428 v12432 
                                                                            let _v12429 = v12433 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v12434 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v12435 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12428 v12434 
                                                                            let _v12429 = v12435 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v12436 : std_io_Error = v12428 
                                                                            let _v12429 = v12436 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v12437 : std_io_Error = v12428 
                                                                            let _v12429 = v12437 
                                                                            #endif
#else
                                                                            let v12438 : std_io_Error = v12428 
                                                                            let _v12429 = v12438 
                                                                            #endif
                                                                            let v12439 : std_io_Error = _v12429 
                                                                            let v12442 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v12443 : string = "Err($0)"
                                                                            let v12444 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12439 v12443 
                                                                            let _v12442 = v12444 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v12445 : string = "Err($0)"
                                                                            let v12446 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12439 v12445 
                                                                            let _v12442 = v12446 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v12447 : string = "Err($0)"
                                                                            let v12448 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12439 v12447 
                                                                            let _v12442 = v12448 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v12449 : Result<std_path_PathBuf, std_io_Error> = v12439 |> Error
                                                                            let _v12442 = v12449 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v12450 : Result<std_path_PathBuf, std_io_Error> = v12439 |> Error
                                                                            let _v12442 = v12450 
                                                                            #endif
#else
                                                                            let v12451 : Result<std_path_PathBuf, std_io_Error> = v12439 |> Error
                                                                            let _v12442 = v12451 
                                                                            #endif
                                                                            let v12452 : Result<std_path_PathBuf, std_io_Error> = _v12442 
                                                                            v12452
                                                                        | US8_0(v12325) -> (* Ok *)
                                                                            let v12326 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v12327 : string = "$0.display()"
                                                                            let v12328 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12325 v12327 
                                                                            let _v12326 = v12328 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v12329 : string = "$0.display()"
                                                                            let v12330 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12325 v12329 
                                                                            let _v12326 = v12330 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v12331 : string = "$0.display()"
                                                                            let v12332 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12325 v12331 
                                                                            let _v12326 = v12332 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v12333 : std_path_Display = v12325 |> unbox<std_path_Display>
                                                                            let _v12326 = v12333 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v12336 : std_path_Display = v12325 |> unbox<std_path_Display>
                                                                            let _v12326 = v12336 
                                                                            #endif
#else
                                                                            let v12339 : std_path_Display = v12325 |> unbox<std_path_Display>
                                                                            let _v12326 = v12339 
                                                                            #endif
                                                                            let v12342 : std_path_Display = _v12326 
                                                                            let v12347 : string = v12342 |> string 
                                                                            let v12350 : string = method26(v12347, v9491)
                                                                            let v12351 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v12352 : string = "&*$0"
                                                                            let v12353 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12350 v12352 
                                                                            let _v12351 = v12353 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v12354 : string = "&*$0"
                                                                            let v12355 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12350 v12354 
                                                                            let _v12351 = v12355 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v12356 : string = "&*$0"
                                                                            let v12357 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12350 v12356 
                                                                            let _v12351 = v12357 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v12358 : Ref<Str> = v12350 |> unbox<Ref<Str>>
                                                                            let _v12351 = v12358 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v12361 : Ref<Str> = v12350 |> unbox<Ref<Str>>
                                                                            let _v12351 = v12361 
                                                                            #endif
#else
                                                                            let v12364 : Ref<Str> = v12350 |> unbox<Ref<Str>>
                                                                            let _v12351 = v12364 
                                                                            #endif
                                                                            let v12367 : Ref<Str> = _v12351 
                                                                            let v12372 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v12373 : string = "String::from($0)"
                                                                            let v12374 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12367 v12373 
                                                                            let _v12372 = v12374 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v12375 : string = "String::from($0)"
                                                                            let v12376 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12367 v12375 
                                                                            let _v12372 = v12376 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v12377 : string = "String::from($0)"
                                                                            let v12378 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12367 v12377 
                                                                            let _v12372 = v12378 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v12379 : std_string_String = v12367 |> unbox<std_string_String>
                                                                            let _v12372 = v12379 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v12382 : std_string_String = v12367 |> unbox<std_string_String>
                                                                            let _v12372 = v12382 
                                                                            #endif
#else
                                                                            let v12385 : std_string_String = v12367 |> unbox<std_string_String>
                                                                            let _v12372 = v12385 
                                                                            #endif
                                                                            let v12388 : std_string_String = _v12372 
                                                                            let v12393 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v12394 : string = "std::path::PathBuf::from($0)"
                                                                            let v12395 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12388 v12394 
                                                                            let _v12393 = v12395 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v12396 : string = "std::path::PathBuf::from($0)"
                                                                            let v12397 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12388 v12396 
                                                                            let _v12393 = v12397 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v12398 : string = "std::path::PathBuf::from($0)"
                                                                            let v12399 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12388 v12398 
                                                                            let _v12393 = v12399 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v12400 : std_path_PathBuf = v12388 |> std_path_PathBuf 
                                                                            let _v12393 = v12400 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v12403 : std_path_PathBuf = v12388 |> std_path_PathBuf 
                                                                            let _v12393 = v12403 
                                                                            #endif
#else
                                                                            let v12406 : std_path_PathBuf = v12388 |> std_path_PathBuf 
                                                                            let _v12393 = v12406 
                                                                            #endif
                                                                            let v12409 : std_path_PathBuf = _v12393 
                                                                            let v12414 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v12415 : string = "Ok($0)"
                                                                            let v12416 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12409 v12415 
                                                                            let _v12414 = v12416 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v12417 : string = "Ok($0)"
                                                                            let v12418 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12409 v12417 
                                                                            let _v12414 = v12418 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v12419 : string = "Ok($0)"
                                                                            let v12420 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12409 v12419 
                                                                            let _v12414 = v12420 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v12421 : Result<std_path_PathBuf, std_io_Error> = v12409 |> Ok
                                                                            let _v12414 = v12421 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v12422 : Result<std_path_PathBuf, std_io_Error> = v12409 |> Ok
                                                                            let _v12414 = v12422 
                                                                            #endif
#else
                                                                            let v12423 : Result<std_path_PathBuf, std_io_Error> = v12409 |> Ok
                                                                            let _v12414 = v12423 
                                                                            #endif
                                                                            let v12424 : Result<std_path_PathBuf, std_io_Error> = _v12414 
                                                                            v12424
                                                                    else
                                                                        let v12457 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v9488} / path': {v9344} / name: {v9491}"
                                                                        let v12458 : unit = ()
                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                        let v12459 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                        let v12460 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12457 v12459 
                                                                        let _v12458 = v12460 
                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                        let v12461 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                        let v12462 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12457 v12461 
                                                                        let _v12458 = v12462 
                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                        let v12463 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                        let v12464 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12457 v12463 
                                                                        let _v12458 = v12464 
                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                        let v12465 : std_io_Error = v12457 
                                                                        let _v12458 = v12465 
                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                        let v12466 : std_io_Error = v12457 
                                                                        let _v12458 = v12466 
                                                                        #endif
#else
                                                                        let v12467 : std_io_Error = v12457 
                                                                        let _v12458 = v12467 
                                                                        #endif
                                                                        let v12468 : std_io_Error = _v12458 
                                                                        let v12471 : unit = ()
                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                        let v12472 : string = "Err($0)"
                                                                        let v12473 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12468 v12472 
                                                                        let _v12471 = v12473 
                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                        let v12474 : string = "Err($0)"
                                                                        let v12475 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12468 v12474 
                                                                        let _v12471 = v12475 
                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                        let v12476 : string = "Err($0)"
                                                                        let v12477 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12468 v12476 
                                                                        let _v12471 = v12477 
                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                        let v12478 : Result<std_path_PathBuf, std_io_Error> = v12468 |> Error
                                                                        let _v12471 = v12478 
                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                        let v12479 : Result<std_path_PathBuf, std_io_Error> = v12468 |> Error
                                                                        let _v12471 = v12479 
                                                                        #endif
#else
                                                                        let v12480 : Result<std_path_PathBuf, std_io_Error> = v12468 |> Error
                                                                        let _v12471 = v12480 
                                                                        #endif
                                                                        let v12481 : Result<std_path_PathBuf, std_io_Error> = _v12471 
                                                                        v12481
                                                                | _ ->
                                                                    let v12485 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v9488} / path': {v9344} / name: {v9491}"
                                                                    let v12486 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v12487 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                    let v12488 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12485 v12487 
                                                                    let _v12486 = v12488 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v12489 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                    let v12490 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12485 v12489 
                                                                    let _v12486 = v12490 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v12491 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                    let v12492 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12485 v12491 
                                                                    let _v12486 = v12492 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v12493 : std_io_Error = v12485 
                                                                    let _v12486 = v12493 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v12494 : std_io_Error = v12485 
                                                                    let _v12486 = v12494 
                                                                    #endif
#else
                                                                    let v12495 : std_io_Error = v12485 
                                                                    let _v12486 = v12495 
                                                                    #endif
                                                                    let v12496 : std_io_Error = _v12486 
                                                                    let v12499 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v12500 : string = "Err($0)"
                                                                    let v12501 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12496 v12500 
                                                                    let _v12499 = v12501 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v12502 : string = "Err($0)"
                                                                    let v12503 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12496 v12502 
                                                                    let _v12499 = v12503 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v12504 : string = "Err($0)"
                                                                    let v12505 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12496 v12504 
                                                                    let _v12499 = v12505 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v12506 : Result<std_path_PathBuf, std_io_Error> = v12496 |> Error
                                                                    let _v12499 = v12506 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v12507 : Result<std_path_PathBuf, std_io_Error> = v12496 |> Error
                                                                    let _v12499 = v12507 
                                                                    #endif
#else
                                                                    let v12508 : Result<std_path_PathBuf, std_io_Error> = v12496 |> Error
                                                                    let _v12499 = v12508 
                                                                    #endif
                                                                    let v12509 : Result<std_path_PathBuf, std_io_Error> = _v12499 
                                                                    v12509
                                                        let v12514 : (std_io_Error -> string) = method41()
                                                        let v12515 : unit = ()
                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                        let v12516 : string = "$0.map_err(|x| $1(x))"
                                                        let v12517 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12513, v12514) v12516 
                                                        let _v12515 = v12517 
                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                        let v12518 : string = "$0.map_err(|x| $1(x))"
                                                        let v12519 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12513, v12514) v12518 
                                                        let _v12515 = v12519 
                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                        let v12520 : string = "$0.map_err(|x| $1(x))"
                                                        let v12521 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12513, v12514) v12520 
                                                        let _v12515 = v12521 
                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                        let v12522 : Result<std_path_PathBuf, string> = match v12513 with Ok x -> Ok x | Error x -> Error (v12514 x)
                                                        let _v12515 = v12522 
                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                        let v12523 : Result<std_path_PathBuf, string> = match v12513 with Ok x -> Ok x | Error x -> Error (v12514 x)
                                                        let _v12515 = v12523 
                                                        #endif
#else
                                                        let v12524 : Result<std_path_PathBuf, string> = match v12513 with Ok x -> Ok x | Error x -> Error (v12514 x)
                                                        let _v12515 = v12524 
                                                        #endif
                                                        let v12525 : Result<std_path_PathBuf, string> = _v12515 
                                                        let v12528 : (std_path_PathBuf -> US8) = closure16()
                                                        let v12529 : (string -> US8) = closure17()
                                                        let v12530 : US8 = match v12525 with Ok x -> v12528 x | Error x -> v12529 x
                                                        match v12530 with
                                                        | US8_1(v12633) -> (* Error *)
                                                            let v12634 : string = $"file_system.read_link / error': {v12633} / error: {v9322} / name: {v9325}"
                                                            let v12635 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v12636 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v12637 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12634 v12636 
                                                            let _v12635 = v12637 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v12638 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v12639 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12634 v12638 
                                                            let _v12635 = v12639 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v12640 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v12641 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12634 v12640 
                                                            let _v12635 = v12641 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v12642 : std_io_Error = v12634 
                                                            let _v12635 = v12642 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v12643 : std_io_Error = v12634 
                                                            let _v12635 = v12643 
                                                            #endif
#else
                                                            let v12644 : std_io_Error = v12634 
                                                            let _v12635 = v12644 
                                                            #endif
                                                            let v12645 : std_io_Error = _v12635 
                                                            let v12648 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v12649 : string = "Err($0)"
                                                            let v12650 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12645 v12649 
                                                            let _v12648 = v12650 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v12651 : string = "Err($0)"
                                                            let v12652 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12645 v12651 
                                                            let _v12648 = v12652 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v12653 : string = "Err($0)"
                                                            let v12654 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12645 v12653 
                                                            let _v12648 = v12654 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v12655 : Result<std_path_PathBuf, std_io_Error> = v12645 |> Error
                                                            let _v12648 = v12655 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v12656 : Result<std_path_PathBuf, std_io_Error> = v12645 |> Error
                                                            let _v12648 = v12656 
                                                            #endif
#else
                                                            let v12657 : Result<std_path_PathBuf, std_io_Error> = v12645 |> Error
                                                            let _v12648 = v12657 
                                                            #endif
                                                            let v12658 : Result<std_path_PathBuf, std_io_Error> = _v12648 
                                                            v12658
                                                        | US8_0(v12531) -> (* Ok *)
                                                            let v12532 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v12533 : string = "$0.display()"
                                                            let v12534 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12531 v12533 
                                                            let _v12532 = v12534 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v12535 : string = "$0.display()"
                                                            let v12536 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12531 v12535 
                                                            let _v12532 = v12536 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v12537 : string = "$0.display()"
                                                            let v12538 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12531 v12537 
                                                            let _v12532 = v12538 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v12539 : std_path_Display = v12531 |> unbox<std_path_Display>
                                                            let _v12532 = v12539 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v12542 : std_path_Display = v12531 |> unbox<std_path_Display>
                                                            let _v12532 = v12542 
                                                            #endif
#else
                                                            let v12545 : std_path_Display = v12531 |> unbox<std_path_Display>
                                                            let _v12532 = v12545 
                                                            #endif
                                                            let v12548 : std_path_Display = _v12532 
                                                            let v12553 : string = v12548 |> string 
                                                            let v12556 : string = method26(v12553, v9325)
                                                            let v12557 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v12558 : string = "&*$0"
                                                            let v12559 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12556 v12558 
                                                            let _v12557 = v12559 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v12560 : string = "&*$0"
                                                            let v12561 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12556 v12560 
                                                            let _v12557 = v12561 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v12562 : string = "&*$0"
                                                            let v12563 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12556 v12562 
                                                            let _v12557 = v12563 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v12564 : Ref<Str> = v12556 |> unbox<Ref<Str>>
                                                            let _v12557 = v12564 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v12567 : Ref<Str> = v12556 |> unbox<Ref<Str>>
                                                            let _v12557 = v12567 
                                                            #endif
#else
                                                            let v12570 : Ref<Str> = v12556 |> unbox<Ref<Str>>
                                                            let _v12557 = v12570 
                                                            #endif
                                                            let v12573 : Ref<Str> = _v12557 
                                                            let v12578 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v12579 : string = "String::from($0)"
                                                            let v12580 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12573 v12579 
                                                            let _v12578 = v12580 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v12581 : string = "String::from($0)"
                                                            let v12582 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12573 v12581 
                                                            let _v12578 = v12582 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v12583 : string = "String::from($0)"
                                                            let v12584 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12573 v12583 
                                                            let _v12578 = v12584 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v12585 : std_string_String = v12573 |> unbox<std_string_String>
                                                            let _v12578 = v12585 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v12588 : std_string_String = v12573 |> unbox<std_string_String>
                                                            let _v12578 = v12588 
                                                            #endif
#else
                                                            let v12591 : std_string_String = v12573 |> unbox<std_string_String>
                                                            let _v12578 = v12591 
                                                            #endif
                                                            let v12594 : std_string_String = _v12578 
                                                            let v12599 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v12600 : string = "std::path::PathBuf::from($0)"
                                                            let v12601 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12594 v12600 
                                                            let _v12599 = v12601 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v12602 : string = "std::path::PathBuf::from($0)"
                                                            let v12603 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12594 v12602 
                                                            let _v12599 = v12603 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v12604 : string = "std::path::PathBuf::from($0)"
                                                            let v12605 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12594 v12604 
                                                            let _v12599 = v12605 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v12606 : std_path_PathBuf = v12594 |> std_path_PathBuf 
                                                            let _v12599 = v12606 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v12609 : std_path_PathBuf = v12594 |> std_path_PathBuf 
                                                            let _v12599 = v12609 
                                                            #endif
#else
                                                            let v12612 : std_path_PathBuf = v12594 |> std_path_PathBuf 
                                                            let _v12599 = v12612 
                                                            #endif
                                                            let v12615 : std_path_PathBuf = _v12599 
                                                            let v12620 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v12621 : string = "Ok($0)"
                                                            let v12622 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12615 v12621 
                                                            let _v12620 = v12622 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v12623 : string = "Ok($0)"
                                                            let v12624 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12615 v12623 
                                                            let _v12620 = v12624 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v12625 : string = "Ok($0)"
                                                            let v12626 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12615 v12625 
                                                            let _v12620 = v12626 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v12627 : Result<std_path_PathBuf, std_io_Error> = v12615 |> Ok
                                                            let _v12620 = v12627 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v12628 : Result<std_path_PathBuf, std_io_Error> = v12615 |> Ok
                                                            let _v12620 = v12628 
                                                            #endif
#else
                                                            let v12629 : Result<std_path_PathBuf, std_io_Error> = v12615 |> Ok
                                                            let _v12620 = v12629 
                                                            #endif
                                                            let v12630 : Result<std_path_PathBuf, std_io_Error> = _v12620 
                                                            v12630
                                                    else
                                                        let v12663 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v9322} / path': {v9178} / name: {v9325}"
                                                        let v12664 : unit = ()
                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                        let v12665 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                        let v12666 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12663 v12665 
                                                        let _v12664 = v12666 
                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                        let v12667 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                        let v12668 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12663 v12667 
                                                        let _v12664 = v12668 
                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                        let v12669 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                        let v12670 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12663 v12669 
                                                        let _v12664 = v12670 
                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                        let v12671 : std_io_Error = v12663 
                                                        let _v12664 = v12671 
                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                        let v12672 : std_io_Error = v12663 
                                                        let _v12664 = v12672 
                                                        #endif
#else
                                                        let v12673 : std_io_Error = v12663 
                                                        let _v12664 = v12673 
                                                        #endif
                                                        let v12674 : std_io_Error = _v12664 
                                                        let v12677 : unit = ()
                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                        let v12678 : string = "Err($0)"
                                                        let v12679 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12674 v12678 
                                                        let _v12677 = v12679 
                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                        let v12680 : string = "Err($0)"
                                                        let v12681 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12674 v12680 
                                                        let _v12677 = v12681 
                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                        let v12682 : string = "Err($0)"
                                                        let v12683 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12674 v12682 
                                                        let _v12677 = v12683 
                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                        let v12684 : Result<std_path_PathBuf, std_io_Error> = v12674 |> Error
                                                        let _v12677 = v12684 
                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                        let v12685 : Result<std_path_PathBuf, std_io_Error> = v12674 |> Error
                                                        let _v12677 = v12685 
                                                        #endif
#else
                                                        let v12686 : Result<std_path_PathBuf, std_io_Error> = v12674 |> Error
                                                        let _v12677 = v12686 
                                                        #endif
                                                        let v12687 : Result<std_path_PathBuf, std_io_Error> = _v12677 
                                                        v12687
                                                | _ ->
                                                    let v12691 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v9322} / path': {v9178} / name: {v9325}"
                                                    let v12692 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v12693 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                    let v12694 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12691 v12693 
                                                    let _v12692 = v12694 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v12695 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                    let v12696 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12691 v12695 
                                                    let _v12692 = v12696 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v12697 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                    let v12698 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12691 v12697 
                                                    let _v12692 = v12698 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v12699 : std_io_Error = v12691 
                                                    let _v12692 = v12699 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v12700 : std_io_Error = v12691 
                                                    let _v12692 = v12700 
                                                    #endif
#else
                                                    let v12701 : std_io_Error = v12691 
                                                    let _v12692 = v12701 
                                                    #endif
                                                    let v12702 : std_io_Error = _v12692 
                                                    let v12705 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v12706 : string = "Err($0)"
                                                    let v12707 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12702 v12706 
                                                    let _v12705 = v12707 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v12708 : string = "Err($0)"
                                                    let v12709 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12702 v12708 
                                                    let _v12705 = v12709 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v12710 : string = "Err($0)"
                                                    let v12711 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12702 v12710 
                                                    let _v12705 = v12711 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v12712 : Result<std_path_PathBuf, std_io_Error> = v12702 |> Error
                                                    let _v12705 = v12712 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v12713 : Result<std_path_PathBuf, std_io_Error> = v12702 |> Error
                                                    let _v12705 = v12713 
                                                    #endif
#else
                                                    let v12714 : Result<std_path_PathBuf, std_io_Error> = v12702 |> Error
                                                    let _v12705 = v12714 
                                                    #endif
                                                    let v12715 : Result<std_path_PathBuf, std_io_Error> = _v12705 
                                                    v12715
                                        let v12720 : (std_io_Error -> string) = method41()
                                        let v12721 : unit = ()
                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                        let v12722 : string = "$0.map_err(|x| $1(x))"
                                        let v12723 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12719, v12720) v12722 
                                        let _v12721 = v12723 
                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                        let v12724 : string = "$0.map_err(|x| $1(x))"
                                        let v12725 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12719, v12720) v12724 
                                        let _v12721 = v12725 
                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                        let v12726 : string = "$0.map_err(|x| $1(x))"
                                        let v12727 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12719, v12720) v12726 
                                        let _v12721 = v12727 
                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                        let v12728 : Result<std_path_PathBuf, string> = match v12719 with Ok x -> Ok x | Error x -> Error (v12720 x)
                                        let _v12721 = v12728 
                                        #endif
#if FABLE_COMPILER_PYTHON
                                        let v12729 : Result<std_path_PathBuf, string> = match v12719 with Ok x -> Ok x | Error x -> Error (v12720 x)
                                        let _v12721 = v12729 
                                        #endif
#else
                                        let v12730 : Result<std_path_PathBuf, string> = match v12719 with Ok x -> Ok x | Error x -> Error (v12720 x)
                                        let _v12721 = v12730 
                                        #endif
                                        let v12731 : Result<std_path_PathBuf, string> = _v12721 
                                        let v12734 : (std_path_PathBuf -> US8) = closure16()
                                        let v12735 : (string -> US8) = closure17()
                                        let v12736 : US8 = match v12731 with Ok x -> v12734 x | Error x -> v12735 x
                                        match v12736 with
                                        | US8_1(v12839) -> (* Error *)
                                            let v12840 : string = $"file_system.read_link / error': {v12839} / error: {v9156} / name: {v9159}"
                                            let v12841 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v12842 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v12843 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12840 v12842 
                                            let _v12841 = v12843 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v12844 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v12845 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12840 v12844 
                                            let _v12841 = v12845 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v12846 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v12847 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12840 v12846 
                                            let _v12841 = v12847 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v12848 : std_io_Error = v12840 
                                            let _v12841 = v12848 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v12849 : std_io_Error = v12840 
                                            let _v12841 = v12849 
                                            #endif
#else
                                            let v12850 : std_io_Error = v12840 
                                            let _v12841 = v12850 
                                            #endif
                                            let v12851 : std_io_Error = _v12841 
                                            let v12854 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v12855 : string = "Err($0)"
                                            let v12856 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12851 v12855 
                                            let _v12854 = v12856 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v12857 : string = "Err($0)"
                                            let v12858 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12851 v12857 
                                            let _v12854 = v12858 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v12859 : string = "Err($0)"
                                            let v12860 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12851 v12859 
                                            let _v12854 = v12860 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v12861 : Result<std_path_PathBuf, std_io_Error> = v12851 |> Error
                                            let _v12854 = v12861 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v12862 : Result<std_path_PathBuf, std_io_Error> = v12851 |> Error
                                            let _v12854 = v12862 
                                            #endif
#else
                                            let v12863 : Result<std_path_PathBuf, std_io_Error> = v12851 |> Error
                                            let _v12854 = v12863 
                                            #endif
                                            let v12864 : Result<std_path_PathBuf, std_io_Error> = _v12854 
                                            v12864
                                        | US8_0(v12737) -> (* Ok *)
                                            let v12738 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v12739 : string = "$0.display()"
                                            let v12740 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12737 v12739 
                                            let _v12738 = v12740 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v12741 : string = "$0.display()"
                                            let v12742 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12737 v12741 
                                            let _v12738 = v12742 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v12743 : string = "$0.display()"
                                            let v12744 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12737 v12743 
                                            let _v12738 = v12744 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v12745 : std_path_Display = v12737 |> unbox<std_path_Display>
                                            let _v12738 = v12745 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v12748 : std_path_Display = v12737 |> unbox<std_path_Display>
                                            let _v12738 = v12748 
                                            #endif
#else
                                            let v12751 : std_path_Display = v12737 |> unbox<std_path_Display>
                                            let _v12738 = v12751 
                                            #endif
                                            let v12754 : std_path_Display = _v12738 
                                            let v12759 : string = v12754 |> string 
                                            let v12762 : string = method26(v12759, v9159)
                                            let v12763 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v12764 : string = "&*$0"
                                            let v12765 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12762 v12764 
                                            let _v12763 = v12765 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v12766 : string = "&*$0"
                                            let v12767 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12762 v12766 
                                            let _v12763 = v12767 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v12768 : string = "&*$0"
                                            let v12769 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12762 v12768 
                                            let _v12763 = v12769 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v12770 : Ref<Str> = v12762 |> unbox<Ref<Str>>
                                            let _v12763 = v12770 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v12773 : Ref<Str> = v12762 |> unbox<Ref<Str>>
                                            let _v12763 = v12773 
                                            #endif
#else
                                            let v12776 : Ref<Str> = v12762 |> unbox<Ref<Str>>
                                            let _v12763 = v12776 
                                            #endif
                                            let v12779 : Ref<Str> = _v12763 
                                            let v12784 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v12785 : string = "String::from($0)"
                                            let v12786 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12779 v12785 
                                            let _v12784 = v12786 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v12787 : string = "String::from($0)"
                                            let v12788 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12779 v12787 
                                            let _v12784 = v12788 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v12789 : string = "String::from($0)"
                                            let v12790 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12779 v12789 
                                            let _v12784 = v12790 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v12791 : std_string_String = v12779 |> unbox<std_string_String>
                                            let _v12784 = v12791 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v12794 : std_string_String = v12779 |> unbox<std_string_String>
                                            let _v12784 = v12794 
                                            #endif
#else
                                            let v12797 : std_string_String = v12779 |> unbox<std_string_String>
                                            let _v12784 = v12797 
                                            #endif
                                            let v12800 : std_string_String = _v12784 
                                            let v12805 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v12806 : string = "std::path::PathBuf::from($0)"
                                            let v12807 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12800 v12806 
                                            let _v12805 = v12807 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v12808 : string = "std::path::PathBuf::from($0)"
                                            let v12809 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12800 v12808 
                                            let _v12805 = v12809 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v12810 : string = "std::path::PathBuf::from($0)"
                                            let v12811 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12800 v12810 
                                            let _v12805 = v12811 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v12812 : std_path_PathBuf = v12800 |> std_path_PathBuf 
                                            let _v12805 = v12812 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v12815 : std_path_PathBuf = v12800 |> std_path_PathBuf 
                                            let _v12805 = v12815 
                                            #endif
#else
                                            let v12818 : std_path_PathBuf = v12800 |> std_path_PathBuf 
                                            let _v12805 = v12818 
                                            #endif
                                            let v12821 : std_path_PathBuf = _v12805 
                                            let v12826 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v12827 : string = "Ok($0)"
                                            let v12828 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12821 v12827 
                                            let _v12826 = v12828 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v12829 : string = "Ok($0)"
                                            let v12830 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12821 v12829 
                                            let _v12826 = v12830 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v12831 : string = "Ok($0)"
                                            let v12832 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12821 v12831 
                                            let _v12826 = v12832 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v12833 : Result<std_path_PathBuf, std_io_Error> = v12821 |> Ok
                                            let _v12826 = v12833 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v12834 : Result<std_path_PathBuf, std_io_Error> = v12821 |> Ok
                                            let _v12826 = v12834 
                                            #endif
#else
                                            let v12835 : Result<std_path_PathBuf, std_io_Error> = v12821 |> Ok
                                            let _v12826 = v12835 
                                            #endif
                                            let v12836 : Result<std_path_PathBuf, std_io_Error> = _v12826 
                                            v12836
                                    else
                                        let v12869 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v9156} / path': {v9011} / name: {v9159}"
                                        let v12870 : unit = ()
                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                        let v12871 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                        let v12872 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12869 v12871 
                                        let _v12870 = v12872 
                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                        let v12873 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                        let v12874 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12869 v12873 
                                        let _v12870 = v12874 
                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                        let v12875 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                        let v12876 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12869 v12875 
                                        let _v12870 = v12876 
                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                        let v12877 : std_io_Error = v12869 
                                        let _v12870 = v12877 
                                        #endif
#if FABLE_COMPILER_PYTHON
                                        let v12878 : std_io_Error = v12869 
                                        let _v12870 = v12878 
                                        #endif
#else
                                        let v12879 : std_io_Error = v12869 
                                        let _v12870 = v12879 
                                        #endif
                                        let v12880 : std_io_Error = _v12870 
                                        let v12883 : unit = ()
                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                        let v12884 : string = "Err($0)"
                                        let v12885 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12880 v12884 
                                        let _v12883 = v12885 
                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                        let v12886 : string = "Err($0)"
                                        let v12887 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12880 v12886 
                                        let _v12883 = v12887 
                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                        let v12888 : string = "Err($0)"
                                        let v12889 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12880 v12888 
                                        let _v12883 = v12889 
                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                        let v12890 : Result<std_path_PathBuf, std_io_Error> = v12880 |> Error
                                        let _v12883 = v12890 
                                        #endif
#if FABLE_COMPILER_PYTHON
                                        let v12891 : Result<std_path_PathBuf, std_io_Error> = v12880 |> Error
                                        let _v12883 = v12891 
                                        #endif
#else
                                        let v12892 : Result<std_path_PathBuf, std_io_Error> = v12880 |> Error
                                        let _v12883 = v12892 
                                        #endif
                                        let v12893 : Result<std_path_PathBuf, std_io_Error> = _v12883 
                                        v12893
                                | _ ->
                                    let v12897 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v9156} / path': {v9011} / name: {v9159}"
                                    let v12898 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v12899 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                    let v12900 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12897 v12899 
                                    let _v12898 = v12900 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v12901 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                    let v12902 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12897 v12901 
                                    let _v12898 = v12902 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v12903 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                    let v12904 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12897 v12903 
                                    let _v12898 = v12904 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v12905 : std_io_Error = v12897 
                                    let _v12898 = v12905 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v12906 : std_io_Error = v12897 
                                    let _v12898 = v12906 
                                    #endif
#else
                                    let v12907 : std_io_Error = v12897 
                                    let _v12898 = v12907 
                                    #endif
                                    let v12908 : std_io_Error = _v12898 
                                    let v12911 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v12912 : string = "Err($0)"
                                    let v12913 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12908 v12912 
                                    let _v12911 = v12913 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v12914 : string = "Err($0)"
                                    let v12915 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12908 v12914 
                                    let _v12911 = v12915 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v12916 : string = "Err($0)"
                                    let v12917 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12908 v12916 
                                    let _v12911 = v12917 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v12918 : Result<std_path_PathBuf, std_io_Error> = v12908 |> Error
                                    let _v12911 = v12918 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v12919 : Result<std_path_PathBuf, std_io_Error> = v12908 |> Error
                                    let _v12911 = v12919 
                                    #endif
#else
                                    let v12920 : Result<std_path_PathBuf, std_io_Error> = v12908 |> Error
                                    let _v12911 = v12920 
                                    #endif
                                    let v12921 : Result<std_path_PathBuf, std_io_Error> = _v12911 
                                    v12921
                        let v12926 : (std_io_Error -> string) = method41()
                        let v12927 : unit = ()
                        
#if FABLE_COMPILER || WASM || CONTRACT
                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                        let v12928 : string = "$0.map_err(|x| $1(x))"
                        let v12929 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12925, v12926) v12928 
                        let _v12927 = v12929 
                        #endif
#if FABLE_COMPILER_RUST && WASM
                        let v12930 : string = "$0.map_err(|x| $1(x))"
                        let v12931 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12925, v12926) v12930 
                        let _v12927 = v12931 
                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                        let v12932 : string = "$0.map_err(|x| $1(x))"
                        let v12933 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12925, v12926) v12932 
                        let _v12927 = v12933 
                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                        let v12934 : Result<std_path_PathBuf, string> = match v12925 with Ok x -> Ok x | Error x -> Error (v12926 x)
                        let _v12927 = v12934 
                        #endif
#if FABLE_COMPILER_PYTHON
                        let v12935 : Result<std_path_PathBuf, string> = match v12925 with Ok x -> Ok x | Error x -> Error (v12926 x)
                        let _v12927 = v12935 
                        #endif
#else
                        let v12936 : Result<std_path_PathBuf, string> = match v12925 with Ok x -> Ok x | Error x -> Error (v12926 x)
                        let _v12927 = v12936 
                        #endif
                        let v12937 : Result<std_path_PathBuf, string> = _v12927 
                        let v12940 : (std_path_PathBuf -> US8) = closure16()
                        let v12941 : (string -> US8) = closure17()
                        let v12942 : US8 = match v12937 with Ok x -> v12940 x | Error x -> v12941 x
                        match v12942 with
                        | US8_1(v13045) -> (* Error *)
                            let v13046 : string = $"file_system.read_link / error': {v13045} / error: {v8989} / name: {v8992}"
                            let v13047 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v13048 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v13049 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v13046 v13048 
                            let _v13047 = v13049 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v13050 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v13051 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v13046 v13050 
                            let _v13047 = v13051 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v13052 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v13053 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v13046 v13052 
                            let _v13047 = v13053 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v13054 : std_io_Error = v13046 
                            let _v13047 = v13054 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v13055 : std_io_Error = v13046 
                            let _v13047 = v13055 
                            #endif
#else
                            let v13056 : std_io_Error = v13046 
                            let _v13047 = v13056 
                            #endif
                            let v13057 : std_io_Error = _v13047 
                            let v13060 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v13061 : string = "Err($0)"
                            let v13062 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13057 v13061 
                            let _v13060 = v13062 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v13063 : string = "Err($0)"
                            let v13064 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13057 v13063 
                            let _v13060 = v13064 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v13065 : string = "Err($0)"
                            let v13066 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13057 v13065 
                            let _v13060 = v13066 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v13067 : Result<std_path_PathBuf, std_io_Error> = v13057 |> Error
                            let _v13060 = v13067 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v13068 : Result<std_path_PathBuf, std_io_Error> = v13057 |> Error
                            let _v13060 = v13068 
                            #endif
#else
                            let v13069 : Result<std_path_PathBuf, std_io_Error> = v13057 |> Error
                            let _v13060 = v13069 
                            #endif
                            let v13070 : Result<std_path_PathBuf, std_io_Error> = _v13060 
                            v13070
                        | US8_0(v12943) -> (* Ok *)
                            let v12944 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v12945 : string = "$0.display()"
                            let v12946 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12943 v12945 
                            let _v12944 = v12946 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v12947 : string = "$0.display()"
                            let v12948 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12943 v12947 
                            let _v12944 = v12948 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v12949 : string = "$0.display()"
                            let v12950 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12943 v12949 
                            let _v12944 = v12950 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v12951 : std_path_Display = v12943 |> unbox<std_path_Display>
                            let _v12944 = v12951 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v12954 : std_path_Display = v12943 |> unbox<std_path_Display>
                            let _v12944 = v12954 
                            #endif
#else
                            let v12957 : std_path_Display = v12943 |> unbox<std_path_Display>
                            let _v12944 = v12957 
                            #endif
                            let v12960 : std_path_Display = _v12944 
                            let v12965 : string = v12960 |> string 
                            let v12968 : string = method26(v12965, v8992)
                            let v12969 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v12970 : string = "&*$0"
                            let v12971 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12968 v12970 
                            let _v12969 = v12971 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v12972 : string = "&*$0"
                            let v12973 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12968 v12972 
                            let _v12969 = v12973 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v12974 : string = "&*$0"
                            let v12975 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12968 v12974 
                            let _v12969 = v12975 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v12976 : Ref<Str> = v12968 |> unbox<Ref<Str>>
                            let _v12969 = v12976 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v12979 : Ref<Str> = v12968 |> unbox<Ref<Str>>
                            let _v12969 = v12979 
                            #endif
#else
                            let v12982 : Ref<Str> = v12968 |> unbox<Ref<Str>>
                            let _v12969 = v12982 
                            #endif
                            let v12985 : Ref<Str> = _v12969 
                            let v12990 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v12991 : string = "String::from($0)"
                            let v12992 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12985 v12991 
                            let _v12990 = v12992 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v12993 : string = "String::from($0)"
                            let v12994 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12985 v12993 
                            let _v12990 = v12994 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v12995 : string = "String::from($0)"
                            let v12996 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12985 v12995 
                            let _v12990 = v12996 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v12997 : std_string_String = v12985 |> unbox<std_string_String>
                            let _v12990 = v12997 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v13000 : std_string_String = v12985 |> unbox<std_string_String>
                            let _v12990 = v13000 
                            #endif
#else
                            let v13003 : std_string_String = v12985 |> unbox<std_string_String>
                            let _v12990 = v13003 
                            #endif
                            let v13006 : std_string_String = _v12990 
                            let v13011 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v13012 : string = "std::path::PathBuf::from($0)"
                            let v13013 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v13006 v13012 
                            let _v13011 = v13013 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v13014 : string = "std::path::PathBuf::from($0)"
                            let v13015 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v13006 v13014 
                            let _v13011 = v13015 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v13016 : string = "std::path::PathBuf::from($0)"
                            let v13017 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v13006 v13016 
                            let _v13011 = v13017 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v13018 : std_path_PathBuf = v13006 |> std_path_PathBuf 
                            let _v13011 = v13018 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v13021 : std_path_PathBuf = v13006 |> std_path_PathBuf 
                            let _v13011 = v13021 
                            #endif
#else
                            let v13024 : std_path_PathBuf = v13006 |> std_path_PathBuf 
                            let _v13011 = v13024 
                            #endif
                            let v13027 : std_path_PathBuf = _v13011 
                            let v13032 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v13033 : string = "Ok($0)"
                            let v13034 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13027 v13033 
                            let _v13032 = v13034 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v13035 : string = "Ok($0)"
                            let v13036 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13027 v13035 
                            let _v13032 = v13036 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v13037 : string = "Ok($0)"
                            let v13038 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13027 v13037 
                            let _v13032 = v13038 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v13039 : Result<std_path_PathBuf, std_io_Error> = v13027 |> Ok
                            let _v13032 = v13039 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v13040 : Result<std_path_PathBuf, std_io_Error> = v13027 |> Ok
                            let _v13032 = v13040 
                            #endif
#else
                            let v13041 : Result<std_path_PathBuf, std_io_Error> = v13027 |> Ok
                            let _v13032 = v13041 
                            #endif
                            let v13042 : Result<std_path_PathBuf, std_io_Error> = _v13032 
                            v13042
                    else
                        let v13075 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v8989} / path': {v0} / name: {v8992}"
                        let v13076 : unit = ()
                        
#if FABLE_COMPILER || WASM || CONTRACT
                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                        let v13077 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                        let v13078 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v13075 v13077 
                        let _v13076 = v13078 
                        #endif
#if FABLE_COMPILER_RUST && WASM
                        let v13079 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                        let v13080 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v13075 v13079 
                        let _v13076 = v13080 
                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                        let v13081 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                        let v13082 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v13075 v13081 
                        let _v13076 = v13082 
                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                        let v13083 : std_io_Error = v13075 
                        let _v13076 = v13083 
                        #endif
#if FABLE_COMPILER_PYTHON
                        let v13084 : std_io_Error = v13075 
                        let _v13076 = v13084 
                        #endif
#else
                        let v13085 : std_io_Error = v13075 
                        let _v13076 = v13085 
                        #endif
                        let v13086 : std_io_Error = _v13076 
                        let v13089 : unit = ()
                        
#if FABLE_COMPILER || WASM || CONTRACT
                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                        let v13090 : string = "Err($0)"
                        let v13091 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13086 v13090 
                        let _v13089 = v13091 
                        #endif
#if FABLE_COMPILER_RUST && WASM
                        let v13092 : string = "Err($0)"
                        let v13093 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13086 v13092 
                        let _v13089 = v13093 
                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                        let v13094 : string = "Err($0)"
                        let v13095 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13086 v13094 
                        let _v13089 = v13095 
                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                        let v13096 : Result<std_path_PathBuf, std_io_Error> = v13086 |> Error
                        let _v13089 = v13096 
                        #endif
#if FABLE_COMPILER_PYTHON
                        let v13097 : Result<std_path_PathBuf, std_io_Error> = v13086 |> Error
                        let _v13089 = v13097 
                        #endif
#else
                        let v13098 : Result<std_path_PathBuf, std_io_Error> = v13086 |> Error
                        let _v13089 = v13098 
                        #endif
                        let v13099 : Result<std_path_PathBuf, std_io_Error> = _v13089 
                        v13099
                | _ ->
                    let v13103 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v0} / error: {v8989} / path': {v0} / name: {v8992}"
                    let v13104 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v13105 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                    let v13106 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v13103 v13105 
                    let _v13104 = v13106 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v13107 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                    let v13108 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v13103 v13107 
                    let _v13104 = v13108 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v13109 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                    let v13110 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v13103 v13109 
                    let _v13104 = v13110 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v13111 : std_io_Error = v13103 
                    let _v13104 = v13111 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v13112 : std_io_Error = v13103 
                    let _v13104 = v13112 
                    #endif
#else
                    let v13113 : std_io_Error = v13103 
                    let _v13104 = v13113 
                    #endif
                    let v13114 : std_io_Error = _v13104 
                    let v13117 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v13118 : string = "Err($0)"
                    let v13119 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13114 v13118 
                    let _v13117 = v13119 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v13120 : string = "Err($0)"
                    let v13121 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13114 v13120 
                    let _v13117 = v13121 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v13122 : string = "Err($0)"
                    let v13123 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13114 v13122 
                    let _v13117 = v13123 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v13124 : Result<std_path_PathBuf, std_io_Error> = v13114 |> Error
                    let _v13117 = v13124 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v13125 : Result<std_path_PathBuf, std_io_Error> = v13114 |> Error
                    let _v13117 = v13125 
                    #endif
#else
                    let v13126 : Result<std_path_PathBuf, std_io_Error> = v13114 |> Error
                    let _v13117 = v13126 
                    #endif
                    let v13127 : Result<std_path_PathBuf, std_io_Error> = _v13117 
                    v13127
        let _v3 = v13131 
        #endif
        let v13132 : Result<std_path_PathBuf, std_io_Error> = _v3 
        let v13135 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v13136 : string = "$0.ok()"
        let v13137 : std_path_PathBuf option = Fable.Core.RustInterop.emitRustExpr v13132 v13136 
        let _v13135 = v13137 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v13138 : string = "$0.ok()"
        let v13139 : std_path_PathBuf option = Fable.Core.RustInterop.emitRustExpr v13132 v13138 
        let _v13135 = v13139 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v13140 : string = "$0.ok()"
        let v13141 : std_path_PathBuf option = Fable.Core.RustInterop.emitRustExpr v13132 v13140 
        let _v13135 = v13141 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v13142 : std_path_PathBuf option = match v13132 with Ok x -> Some x | Error _ -> None
        let _v13135 = v13142 
        #endif
#if FABLE_COMPILER_PYTHON
        let v13143 : std_path_PathBuf option = match v13132 with Ok x -> Some x | Error _ -> None
        let _v13135 = v13143 
        #endif
#else
        let v13144 : std_path_PathBuf option = match v13132 with Ok x -> Some x | Error _ -> None
        let _v13135 = v13144 
        #endif
        let v13145 : std_path_PathBuf option = _v13135 
        let v13148 : (std_path_PathBuf -> US9) = method44()
        let v13149 : US9 option = v13145 |> Option.map v13148 
        let v13160 : US9 = US9_1
        let v13161 : US9 = v13149 |> Option.defaultValue v13160 
        let v13193 : string =
            match v13161 with
            | US9_1 -> (* None *)
                v0
            | US9_0(v13165) -> (* Some *)
                let v13166 : unit = ()
                
#if FABLE_COMPILER || WASM || CONTRACT
                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                let v13167 : string = "$0.display()"
                let v13168 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v13165 v13167 
                let _v13166 = v13168 
                #endif
#if FABLE_COMPILER_RUST && WASM
                let v13169 : string = "$0.display()"
                let v13170 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v13165 v13169 
                let _v13166 = v13170 
                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                let v13171 : string = "$0.display()"
                let v13172 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v13165 v13171 
                let _v13166 = v13172 
                #endif
#if FABLE_COMPILER_TYPESCRIPT
                let v13173 : std_path_Display = v13165 |> unbox<std_path_Display>
                let _v13166 = v13173 
                #endif
#if FABLE_COMPILER_PYTHON
                let v13176 : std_path_Display = v13165 |> unbox<std_path_Display>
                let _v13166 = v13176 
                #endif
#else
                let v13179 : std_path_Display = v13165 |> unbox<std_path_Display>
                let _v13166 = v13179 
                #endif
                let v13182 : std_path_Display = _v13166 
                let v13187 : string = v13182 |> string 
                let v13190 : bool = v13187 = ""
                if v13190 then
                    v0
                else
                    v13187
        let v13194 : bool = v13193 = ""
        if v13194 then
            let v13195 : string = ""
            v13195
        else
            let v13196 : string = "^\\\\\\\\\\?\\\\"
            let v13197 : string = ""
            let v13198 : string = method45(v13196, v13197, v13193)
            let v13199 : string = $"{v13198.[0] |> string |> _.ToLower()}{v13198.[1..]}"
            let v13200 : string = "\\"
            let v13201 : string = "/"
            let v13202 : string = v13199.Replace (v13200, v13201)
            v13202
and method47 (v0 : int32, v1 : Mut5) : bool =
    let v2 : int32 = v1.l0
    let v3 : bool = v2 < v0
    v3
and method48 (v0 : int32, v1 : Mut6) : bool =
    let v2 : int32 = v1.l0
    let v3 : bool = v2 < v0
    v3
and method49 () : char =
    let v0 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v1 : string = "std::path::MAIN_SEPARATOR"
    let v2 : char = Fable.Core.RustInterop.emitRustExpr () v1 
    let _v0 = v2 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v3 : char = System.IO.Path.DirectorySeparatorChar
    let _v0 = v3 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v4 : char = System.IO.Path.DirectorySeparatorChar
    let _v0 = v4 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v5 : char = System.IO.Path.DirectorySeparatorChar
    let _v0 = v5 
    #endif
#if FABLE_COMPILER_PYTHON
    let v6 : char = System.IO.Path.DirectorySeparatorChar
    let _v0 = v6 
    #endif
#else
    let v7 : char = System.IO.Path.DirectorySeparatorChar
    let _v0 = v7 
    #endif
    let v8 : char = _v0 
    v8
and method39 (v0 : string) : string =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v3 : string = "&*$0"
    let v4 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v0 v3 
    let _v2 = v4 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v5 : string = "&*$0"
    let v6 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v0 v5 
    let _v2 = v6 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v7 : string = "&*$0"
    let v8 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v0 v7 
    let _v2 = v8 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v9 : Ref<Str> = v0 |> unbox<Ref<Str>>
    let _v2 = v9 
    #endif
#if FABLE_COMPILER_PYTHON
    let v12 : Ref<Str> = v0 |> unbox<Ref<Str>>
    let _v2 = v12 
    #endif
#else
    let v15 : Ref<Str> = v0 |> unbox<Ref<Str>>
    let _v2 = v15 
    #endif
    let v18 : Ref<Str> = _v2 
    let v23 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v24 : string = "String::from($0)"
    let v25 : std_string_String = Fable.Core.RustInterop.emitRustExpr v18 v24 
    let _v23 = v25 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v26 : string = "String::from($0)"
    let v27 : std_string_String = Fable.Core.RustInterop.emitRustExpr v18 v26 
    let _v23 = v27 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v28 : string = "String::from($0)"
    let v29 : std_string_String = Fable.Core.RustInterop.emitRustExpr v18 v28 
    let _v23 = v29 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v30 : std_string_String = v18 |> unbox<std_string_String>
    let _v23 = v30 
    #endif
#if FABLE_COMPILER_PYTHON
    let v33 : std_string_String = v18 |> unbox<std_string_String>
    let _v23 = v33 
    #endif
#else
    let v36 : std_string_String = v18 |> unbox<std_string_String>
    let _v23 = v36 
    #endif
    let v39 : std_string_String = _v23 
    let v44 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v45 : string = "std::path::PathBuf::from($0)"
    let v46 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v39 v45 
    let _v44 = v46 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v47 : string = "std::path::PathBuf::from($0)"
    let v48 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v39 v47 
    let _v44 = v48 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v49 : string = "std::path::PathBuf::from($0)"
    let v50 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v39 v49 
    let _v44 = v50 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v51 : std_path_PathBuf = v39 |> std_path_PathBuf 
    let _v44 = v51 
    #endif
#if FABLE_COMPILER_PYTHON
    let v54 : std_path_PathBuf = v39 |> std_path_PathBuf 
    let _v44 = v54 
    #endif
#else
    let v57 : std_path_PathBuf = v39 |> std_path_PathBuf 
    let _v44 = v57 
    #endif
    let v60 : std_path_PathBuf = _v44 
    let v65 : string = "$0.exists()"
    let v66 : bool = Fable.Core.RustInterop.emitRustExpr v60 v65 
    let v67 : bool = v66 = false
    let v205 : string =
        if v67 then
            let v68 : string = method38()
            let v69 : string = method26(v68, v0)
            let v70 : string = method40(v69)
            let v71 : string = "/"
            let v72 : (string []) = v70.Split v71 
            let v75 : (string []) = [||]
            let v76 : int32 = v72.Length
            let v77 : Mut5 = {l0 = 0; l1 = 0; l2 = v75} : Mut5
            while method47(v76, v77) do
                let v79 : int32 = v77.l0
                let v80 : int32 =  -v79
                let v81 : int32 = v80 + v76
                let v82 : int32 = v81 - 1
                let struct (v83 : int32, v84 : (string [])) = v77.l1, v77.l2
                let v85 : string = v72.[int v82]
                let v86 : bool = ".." = v85
                let struct (v128 : int32, v129 : (string [])) =
                    if v86 then
                        let v87 : int32 = v83 + 1
                        struct (v87, v84)
                    else
                        let v88 : bool = "." = v85
                        if v88 then
                            struct (v83, v84)
                        else
                            let v89 : bool = 0 = v83
                            if v89 then
                                let v90 : string = ":"
                                let v91 : bool = v85.EndsWith v90 
                                if v91 then
                                    let v92 : string = $"{v68.[0]}:"
                                    let v93 : (string []) = [|v92|]
                                    let v94 : int32 = v93.Length
                                    let v95 : int32 = v84.Length
                                    let v96 : int32 = v94 + v95
                                    let v97 : (string []) = Array.zeroCreate<string> (v96)
                                    let v98 : Mut6 = {l0 = 0} : Mut6
                                    while method48(v96, v98) do
                                        let v100 : int32 = v98.l0
                                        let v101 : bool = v100 < v94
                                        let v105 : string =
                                            if v101 then
                                                let v102 : string = v93.[int v100]
                                                v102
                                            else
                                                let v103 : int32 = v100 - v94
                                                let v104 : string = v84.[int v103]
                                                v104
                                        v97.[int v100] <- v105
                                        let v106 : int32 = v100 + 1
                                        v98.l0 <- v106
                                        ()
                                    struct (0, v97)
                                else
                                    let v107 : (string []) = [|v85|]
                                    let v108 : int32 = v107.Length
                                    let v109 : int32 = v84.Length
                                    let v110 : int32 = v108 + v109
                                    let v111 : (string []) = Array.zeroCreate<string> (v110)
                                    let v112 : Mut6 = {l0 = 0} : Mut6
                                    while method48(v110, v112) do
                                        let v114 : int32 = v112.l0
                                        let v115 : bool = v114 < v108
                                        let v119 : string =
                                            if v115 then
                                                let v116 : string = v107.[int v114]
                                                v116
                                            else
                                                let v117 : int32 = v114 - v108
                                                let v118 : string = v84.[int v117]
                                                v118
                                        v111.[int v114] <- v119
                                        let v120 : int32 = v114 + 1
                                        v112.l0 <- v120
                                        ()
                                    struct (0, v111)
                            else
                                let v123 : int32 = v83 - 1
                                struct (v123, v84)
                let v130 : int32 = v79 + 1
                v77.l0 <- v130
                v77.l1 <- v128
                v77.l2 <- v129
                ()
            let struct (v131 : int32, v132 : (string [])) = v77.l1, v77.l2
            let v133 : string seq = seq { for i = 0 to v132.Length - 1 do yield v132.[i] }
            let v136 : char = method49()
            let v137 : (char -> string) = _.ToString()
            let v138 : string = v137 v136
            let v141 : (string -> (string seq -> string)) = String.concat
            let v142 : (string seq -> string) = v141 v138
            v142 v133
        else
            let v146 : string = "std::fs::canonicalize(&*$0)"
            let v147 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v0 v146 
            let v148 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v149 : string = "$0.unwrap()"
            let v150 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v147 v149 
            let _v148 = v150 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v151 : string = "$0.unwrap()"
            let v152 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v147 v151 
            let _v148 = v152 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v153 : string = "$0.unwrap()"
            let v154 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v147 v153 
            let _v148 = v154 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v155 : std_path_PathBuf = match v147 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v148 = v155 
            #endif
#if FABLE_COMPILER_PYTHON
            let v156 : std_path_PathBuf = match v147 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v148 = v156 
            #endif
#else
            let v157 : std_path_PathBuf = match v147 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v148 = v157 
            #endif
            let v158 : std_path_PathBuf = _v148 
            let v161 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v162 : string = "$0.display()"
            let v163 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v158 v162 
            let _v161 = v163 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v164 : string = "$0.display()"
            let v165 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v158 v164 
            let _v161 = v165 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v166 : string = "$0.display()"
            let v167 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v158 v166 
            let _v161 = v167 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v168 : std_path_Display = v158 |> unbox<std_path_Display>
            let _v161 = v168 
            #endif
#if FABLE_COMPILER_PYTHON
            let v171 : std_path_Display = v158 |> unbox<std_path_Display>
            let _v161 = v171 
            #endif
#else
            let v174 : std_path_Display = v158 |> unbox<std_path_Display>
            let _v161 = v174 
            #endif
            let v177 : std_path_Display = _v161 
            let v182 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v183 : string = "format!(\"{}\", $0)"
            let v184 : std_string_String = Fable.Core.RustInterop.emitRustExpr v177 v183 
            let _v182 = v184 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v185 : string = "format!(\"{}\", $0)"
            let v186 : std_string_String = Fable.Core.RustInterop.emitRustExpr v177 v185 
            let _v182 = v186 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v187 : string = "format!(\"{}\", $0)"
            let v188 : std_string_String = Fable.Core.RustInterop.emitRustExpr v177 v187 
            let _v182 = v188 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v189 : std_string_String = null |> unbox<std_string_String>
            let _v182 = v189 
            #endif
#if FABLE_COMPILER_PYTHON
            let v192 : std_string_String = null |> unbox<std_string_String>
            let _v182 = v192 
            #endif
#else
            let v195 : std_string_String = null |> unbox<std_string_String>
            let _v182 = v195 
            #endif
            let v198 : std_string_String = _v182 
            let v203 : string = "fable_library_rust::String_::fromString($0)"
            let v204 : string = Fable.Core.RustInterop.emitRustExpr v198 v203 
            v204
    let _v1 = v205 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v206 : string = null |> unbox<string>
    let _v1 = v206 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v209 : string = null |> unbox<string>
    let _v1 = v209 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v212 : string = null |> unbox<string>
    let _v1 = v212 
    #endif
#if FABLE_COMPILER_PYTHON
    let v215 : string = null |> unbox<string>
    let _v1 = v215 
    #endif
#else
    let v218 : (string -> string) = System.IO.Path.GetFullPath
    let v219 : string = v218 v0
    let _v1 = v219 
    #endif
    let v220 : string = _v1 
    v220
and method50 () : string =
    
    
    
    
    
    let v0 : string = "Debug"
    let v1 : (unit -> string) = v0.ToLower
    let v2 : string = v1 ()
    let v5 : char = v2.[int 0]
    let v6 : string = method13(v5)
    let v7 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v8 : string = "inline_colorization::color_bright_blue"
    let v9 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v8 
    let v10 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v11 : string = "&*$0"
    let v12 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v11 
    let _v10 = v12 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v13 : string = "&*$0"
    let v14 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v13 
    let _v10 = v14 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v15 : string = "&*$0"
    let v16 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v15 
    let _v10 = v16 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v17 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v10 = v17 
    #endif
#if FABLE_COMPILER_PYTHON
    let v20 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v10 = v20 
    #endif
#else
    let v23 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v10 = v23 
    #endif
    let v26 : Ref<Str> = _v10 
    let v31 : string = "inline_colorization::color_reset"
    let v32 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v31 
    let v33 : string = $"format!(\"{{}}{{}}{{}}\", $0, $1, $2)"
    let v34 : std_string_String = Fable.Core.RustInterop.emitRustExpr struct (v9, v26, v32) v33 
    let v35 : string = "fable_library_rust::String_::fromString($0)"
    let v36 : string = Fable.Core.RustInterop.emitRustExpr v34 v35 
    let _v7 = v36 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v37 : string = "inline_colorization::color_bright_blue"
    let v38 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v37 
    let v39 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v40 : string = "&*$0"
    let v41 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v40 
    let _v39 = v41 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v42 : string = "&*$0"
    let v43 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v42 
    let _v39 = v43 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v44 : string = "&*$0"
    let v45 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v44 
    let _v39 = v45 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v46 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v39 = v46 
    #endif
#if FABLE_COMPILER_PYTHON
    let v49 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v39 = v49 
    #endif
#else
    let v52 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v39 = v52 
    #endif
    let v55 : Ref<Str> = _v39 
    let v60 : string = "inline_colorization::color_reset"
    let v61 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v60 
    let v62 : string = $"format!(\"{{}}{{}}{{}}\", $0, $1, $2)"
    let v63 : std_string_String = Fable.Core.RustInterop.emitRustExpr struct (v38, v55, v61) v62 
    let v64 : string = "fable_library_rust::String_::fromString($0)"
    let v65 : string = Fable.Core.RustInterop.emitRustExpr v63 v64 
    let _v7 = v65 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v66 : string = "inline_colorization::color_bright_blue"
    let v67 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v66 
    let v68 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v69 : string = "&*$0"
    let v70 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v69 
    let _v68 = v70 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v71 : string = "&*$0"
    let v72 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v71 
    let _v68 = v72 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v73 : string = "&*$0"
    let v74 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v73 
    let _v68 = v74 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v75 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v68 = v75 
    #endif
#if FABLE_COMPILER_PYTHON
    let v78 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v68 = v78 
    #endif
#else
    let v81 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v68 = v81 
    #endif
    let v84 : Ref<Str> = _v68 
    let v89 : string = "inline_colorization::color_reset"
    let v90 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v89 
    let v91 : string = $"format!(\"{{}}{{}}{{}}\", $0, $1, $2)"
    let v92 : std_string_String = Fable.Core.RustInterop.emitRustExpr struct (v67, v84, v90) v91 
    let v93 : string = "fable_library_rust::String_::fromString($0)"
    let v94 : string = Fable.Core.RustInterop.emitRustExpr v92 v93 
    let _v7 = v94 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v95 : string = "\u001b[94m"
    let v96 : string = method15()
    let v97 : string = v95 + v6 
    let v98 : string = v97 + v96 
    let _v7 = v98 
    #endif
#if FABLE_COMPILER_PYTHON
    let v99 : string = "\u001b[94m"
    let v100 : string = method15()
    let v101 : string = v99 + v6 
    let v102 : string = v101 + v100 
    let _v7 = v102 
    #endif
#else
    let v103 : string = "\u001b[94m"
    let v104 : string = method15()
    let v105 : string = v103 + v6 
    let v106 : string = v105 + v104 
    let _v7 = v106 
    #endif
    let v107 : string = _v7 
    v107
and method52 (v0 : string, v1 : string, v2 : string, v3 : string) : string =
    let v4 : string = method14()
    let v5 : Mut3 = {l0 = v4} : Mut3
    let v6 : string = "{ "
    let v7 : string = $"{v6}"
    let v10 : unit = ()
    let v11 : (unit -> unit) = closure8(v5, v7)
    let v12 : unit = (fun () -> v11 (); v10) ()
    let v15 : string = "source_dir"
    let v16 : string = $"{v15}"
    let v19 : unit = ()
    let v20 : (unit -> unit) = closure8(v5, v16)
    let v21 : unit = (fun () -> v20 (); v19) ()
    let v24 : string = " = "
    let v25 : string = $"{v24}"
    let v28 : unit = ()
    let v29 : (unit -> unit) = closure8(v5, v25)
    let v30 : unit = (fun () -> v29 (); v28) ()
    let v33 : string = $"{v0}"
    let v36 : unit = ()
    let v37 : (unit -> unit) = closure8(v5, v33)
    let v38 : unit = (fun () -> v37 (); v36) ()
    let v41 : string = "; "
    let v42 : string = $"{v41}"
    let v45 : unit = ()
    let v46 : (unit -> unit) = closure8(v5, v42)
    let v47 : unit = (fun () -> v46 (); v45) ()
    let v50 : string = "dist_dir"
    let v51 : string = $"{v50}"
    let v54 : unit = ()
    let v55 : (unit -> unit) = closure8(v5, v51)
    let v56 : unit = (fun () -> v55 (); v54) ()
    let v59 : string = $"{v24}"
    let v62 : unit = ()
    let v63 : (unit -> unit) = closure8(v5, v59)
    let v64 : unit = (fun () -> v63 (); v62) ()
    let v67 : string = $"{v1}"
    let v70 : unit = ()
    let v71 : (unit -> unit) = closure8(v5, v67)
    let v72 : unit = (fun () -> v71 (); v70) ()
    let v75 : string = $"{v41}"
    let v78 : unit = ()
    let v79 : (unit -> unit) = closure8(v5, v75)
    let v80 : unit = (fun () -> v79 (); v78) ()
    let v83 : string = "cache_dir"
    let v84 : string = $"{v83}"
    let v87 : unit = ()
    let v88 : (unit -> unit) = closure8(v5, v84)
    let v89 : unit = (fun () -> v88 (); v87) ()
    let v92 : string = $"{v24}"
    let v95 : unit = ()
    let v96 : (unit -> unit) = closure8(v5, v92)
    let v97 : unit = (fun () -> v96 (); v95) ()
    let v100 : string = $"{v2}"
    let v103 : unit = ()
    let v104 : (unit -> unit) = closure8(v5, v100)
    let v105 : unit = (fun () -> v104 (); v103) ()
    let v108 : string = $"{v41}"
    let v111 : unit = ()
    let v112 : (unit -> unit) = closure8(v5, v108)
    let v113 : unit = (fun () -> v112 (); v111) ()
    let v116 : string = "hangul_spec"
    let v117 : string = $"{v116}"
    let v120 : unit = ()
    let v121 : (unit -> unit) = closure8(v5, v117)
    let v122 : unit = (fun () -> v121 (); v120) ()
    let v125 : string = $"{v24}"
    let v128 : unit = ()
    let v129 : (unit -> unit) = closure8(v5, v125)
    let v130 : unit = (fun () -> v129 (); v128) ()
    let v133 : string = $"{v3}"
    let v136 : unit = ()
    let v137 : (unit -> unit) = closure8(v5, v133)
    let v138 : unit = (fun () -> v137 (); v136) ()
    let v141 : string = " }"
    let v142 : string = $"{v141}"
    let v145 : unit = ()
    let v146 : (unit -> unit) = closure8(v5, v142)
    let v147 : unit = (fun () -> v146 (); v145) ()
    let v150 : string = v5.l0
    v150
and method51 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : string, v9 : string, v10 : string, v11 : string) : string =
    let v12 : string = method52(v8, v9, v10, v11)
    let v13 : int64 = v0.l0
    let v14 : string = "documents.run"
    let v15 : string = $"{v6} {v7} #{v13} %s{v14} / {v12}"
    method18(v15)
and closure19 (v0 : string, v1 : string, v2 : string, v3 : string) () : unit =
    let v4 : US0 = US0_1
    let v5 : bool = method7(v4)
    if v5 then
        let v6 : unit = ()
        let v7 : (unit -> unit) = closure6()
        let v8 : unit = (fun () -> v7 (); v6) ()
        let struct (v22 : Mut0, v23 : Mut1, v24 : Mut2, v25 : Mut3, v26 : Mut4, v27 : int64 option) = TraceState.trace_state.Value
        let v40 : string = method8(v22, v23, v24, v25, v26, v27)
        let v41 : string = method50()
        let v42 : string = method51(v22, v23, v24, v25, v26, v27, v40, v41, v1, v2, v3, v0)
        method19(v42)
and method53 (v0 : async_walkdir_DirEntry) : async_walkdir_DirEntry =
    v0
and closure21 () (v0 : std_io_Error) : std_string_String =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : string = "format!(\"{}\", $0)"
    let v3 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v2 
    let _v1 = v3 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v4 : string = "format!(\"{}\", $0)"
    let v5 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v4 
    let _v1 = v5 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v6 : string = "format!(\"{}\", $0)"
    let v7 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v6 
    let _v1 = v7 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v8 : std_string_String = null |> unbox<std_string_String>
    let _v1 = v8 
    #endif
#if FABLE_COMPILER_PYTHON
    let v11 : std_string_String = null |> unbox<std_string_String>
    let _v1 = v11 
    #endif
#else
    let v14 : std_string_String = null |> unbox<std_string_String>
    let _v1 = v14 
    #endif
    let v17 : std_string_String = _v1 
    v17
and method54 () : (std_io_Error -> std_string_String) =
    closure21()
and closure22 () (v0 : std_fs_FileType) : US10 =
    US10_0(v0)
and closure23 () (v0 : std_string_String) : US10 =
    US10_1(v0)
and method55 (v0 : std_fs_FileType) : std_fs_FileType =
    v0
and method56 (v0 : US11) : US11 =
    v0
and method57 (v0 : async_walkdir_Filtering) : async_walkdir_Filtering =
    v0
and closure20 () (v0 : async_walkdir_DirEntry) : std_pin_Pin<Box<LifetimeJoin<Dyn<std_future_Future<async_walkdir_Filtering>>, Send<Dyn<std_future_Future<async_walkdir_Filtering>>>>>> =
    let v1 : string = "true; let __future_init = Box::pin(async { //"
    let v2 : bool = Fable.Core.RustInterop.emitRustExpr () v1 
    let v3 : string = "true; let __future_init = Box::pin(async move { //"
    let v4 : bool = Fable.Core.RustInterop.emitRustExpr () v3 
    let v5 : async_walkdir_DirEntry = method53(v0)
    let v6 : string = "Box::pin(async_walkdir::DirEntry::file_type(&v5))"
    let v7 : std_pin_Pin<Box<LifetimeJoin<Dyn<std_future_Future<Result<std_fs_FileType, std_io_Error>>>, Send<Dyn<std_future_Future<Result<std_fs_FileType, std_io_Error>>>>>>> = Fable.Core.RustInterop.emitRustExpr () v6 
    let v8 : string = "v7.await"
    let v9 : Result<std_fs_FileType, std_io_Error> = Fable.Core.RustInterop.emitRustExpr () v8 
    let v10 : (std_io_Error -> std_string_String) = method54()
    let v11 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v12 : string = "$0.map_err(|x| $1(x))"
    let v13 : Result<std_fs_FileType, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v9, v10) v12 
    let _v11 = v13 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v14 : string = "$0.map_err(|x| $1(x))"
    let v15 : Result<std_fs_FileType, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v9, v10) v14 
    let _v11 = v15 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v16 : string = "$0.map_err(|x| $1(x))"
    let v17 : Result<std_fs_FileType, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v9, v10) v16 
    let _v11 = v17 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v18 : Result<std_fs_FileType, std_string_String> = match v9 with Ok x -> Ok x | Error x -> Error (v10 x)
    let _v11 = v18 
    #endif
#if FABLE_COMPILER_PYTHON
    let v19 : Result<std_fs_FileType, std_string_String> = match v9 with Ok x -> Ok x | Error x -> Error (v10 x)
    let _v11 = v19 
    #endif
#else
    let v20 : Result<std_fs_FileType, std_string_String> = match v9 with Ok x -> Ok x | Error x -> Error (v10 x)
    let _v11 = v20 
    #endif
    let v21 : Result<std_fs_FileType, std_string_String> = _v11 
    let v24 : (std_fs_FileType -> US10) = closure22()
    let v25 : (std_string_String -> US10) = closure23()
    let v26 : US10 = match v21 with Ok x -> v24 x | Error x -> v25 x
    let v143 : US11 =
        match v26 with
        | US10_0(v27) -> (* Ok *)
            let v28 : std_fs_FileType = method55(v27)
            let v29 : string = "std::fs::FileType::is_dir(&v28)"
            let v30 : bool = Fable.Core.RustInterop.emitRustExpr () v29 
            if v30 then
                US11_0
            else
                let v32 : string = "async_walkdir::DirEntry::path(&$0)"
                let v33 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v0 v32 
                let v34 : unit = ()
                
#if FABLE_COMPILER || WASM || CONTRACT
                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                let v35 : string = "$0.display()"
                let v36 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v33 v35 
                let _v34 = v36 
                #endif
#if FABLE_COMPILER_RUST && WASM
                let v37 : string = "$0.display()"
                let v38 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v33 v37 
                let _v34 = v38 
                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                let v39 : string = "$0.display()"
                let v40 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v33 v39 
                let _v34 = v40 
                #endif
#if FABLE_COMPILER_TYPESCRIPT
                let v41 : std_path_Display = v33 |> unbox<std_path_Display>
                let _v34 = v41 
                #endif
#if FABLE_COMPILER_PYTHON
                let v44 : std_path_Display = v33 |> unbox<std_path_Display>
                let _v34 = v44 
                #endif
#else
                let v47 : std_path_Display = v33 |> unbox<std_path_Display>
                let _v34 = v47 
                #endif
                let v50 : std_path_Display = _v34 
                let v55 : unit = ()
                
#if FABLE_COMPILER || WASM || CONTRACT
                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                let v56 : string = "format!(\"{}\", $0)"
                let v57 : std_string_String = Fable.Core.RustInterop.emitRustExpr v50 v56 
                let _v55 = v57 
                #endif
#if FABLE_COMPILER_RUST && WASM
                let v58 : string = "format!(\"{}\", $0)"
                let v59 : std_string_String = Fable.Core.RustInterop.emitRustExpr v50 v58 
                let _v55 = v59 
                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                let v60 : string = "format!(\"{}\", $0)"
                let v61 : std_string_String = Fable.Core.RustInterop.emitRustExpr v50 v60 
                let _v55 = v61 
                #endif
#if FABLE_COMPILER_TYPESCRIPT
                let v62 : std_string_String = null |> unbox<std_string_String>
                let _v55 = v62 
                #endif
#if FABLE_COMPILER_PYTHON
                let v65 : std_string_String = null |> unbox<std_string_String>
                let _v55 = v65 
                #endif
#else
                let v68 : std_string_String = null |> unbox<std_string_String>
                let _v55 = v68 
                #endif
                let v71 : std_string_String = _v55 
                let v76 : string = "fable_library_rust::String_::fromString($0)"
                let v77 : string = Fable.Core.RustInterop.emitRustExpr v71 v76 
                let v78 : string = ".md"
                let v79 : bool = v77.EndsWith v78 
                let v80 : bool = v79 = false
                let v83 : bool =
                    if v80 then
                        true
                    else
                        let v81 : string = ".hangul.md"
                        let v82 : bool = v77.EndsWith v81 
                        v82
                if v83 then
                    US11_0
                else
                    US11_2
        | _ ->
            let v88 : string = "async_walkdir::DirEntry::path(&$0)"
            let v89 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v0 v88 
            let v90 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v91 : string = "$0.display()"
            let v92 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v89 v91 
            let _v90 = v92 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v93 : string = "$0.display()"
            let v94 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v89 v93 
            let _v90 = v94 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v95 : string = "$0.display()"
            let v96 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v89 v95 
            let _v90 = v96 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v97 : std_path_Display = v89 |> unbox<std_path_Display>
            let _v90 = v97 
            #endif
#if FABLE_COMPILER_PYTHON
            let v100 : std_path_Display = v89 |> unbox<std_path_Display>
            let _v90 = v100 
            #endif
#else
            let v103 : std_path_Display = v89 |> unbox<std_path_Display>
            let _v90 = v103 
            #endif
            let v106 : std_path_Display = _v90 
            let v111 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v112 : string = "format!(\"{}\", $0)"
            let v113 : std_string_String = Fable.Core.RustInterop.emitRustExpr v106 v112 
            let _v111 = v113 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v114 : string = "format!(\"{}\", $0)"
            let v115 : std_string_String = Fable.Core.RustInterop.emitRustExpr v106 v114 
            let _v111 = v115 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v116 : string = "format!(\"{}\", $0)"
            let v117 : std_string_String = Fable.Core.RustInterop.emitRustExpr v106 v116 
            let _v111 = v117 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v118 : std_string_String = null |> unbox<std_string_String>
            let _v111 = v118 
            #endif
#if FABLE_COMPILER_PYTHON
            let v121 : std_string_String = null |> unbox<std_string_String>
            let _v111 = v121 
            #endif
#else
            let v124 : std_string_String = null |> unbox<std_string_String>
            let _v111 = v124 
            #endif
            let v127 : std_string_String = _v111 
            let v132 : string = "fable_library_rust::String_::fromString($0)"
            let v133 : string = Fable.Core.RustInterop.emitRustExpr v127 v132 
            let v134 : string = ".md"
            let v135 : bool = v133.EndsWith v134 
            let v136 : bool = v135 = false
            let v139 : bool =
                if v136 then
                    true
                else
                    let v137 : string = ".hangul.md"
                    let v138 : bool = v133.EndsWith v137 
                    v138
            if v139 then
                US11_0
            else
                US11_2
    let v144 : US11 = method56(v143)
    let v145 : string = ""
    let v146 : string = "}"
    let v147 : string = v145 + v146 
    let v148 : _ = v144 
    let v149 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v150 : string = $"true; let v148 = $0"
    let v151 : bool = Fable.Core.RustInterop.emitRustExpr v148 v150 
    let _v149 = v151 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v152 : string = $"true; let v148 = $0"
    let v153 : bool = Fable.Core.RustInterop.emitRustExpr v148 v152 
    let _v149 = v153 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v154 : string = $"true; let v148 = $0"
    let v155 : bool = Fable.Core.RustInterop.emitRustExpr v148 v154 
    let _v149 = v155 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v156 : bool = true
    let _v149 = v156 
    #endif
#if FABLE_COMPILER_PYTHON
    let v157 : bool = true
    let _v149 = v157 
    #endif
#else
    let v158 : bool = true
    let _v149 = v158 
    #endif
    let v159 : bool = _v149 
    let v162 : string = $"true; v148 " + v147 + "); " + v145 + " // rust.fix_closure'"
    let v163 : bool = Fable.Core.RustInterop.emitRustExpr () v162 
    let v164 : string = "__future_init"
    let v165 : _ = Fable.Core.RustInterop.emitRustExpr () v164 
    let v166 : string = "v165"
    let v167 : std_pin_Pin<Box<LifetimeJoin<Dyn<std_future_Future<US11>>, Send<Dyn<std_future_Future<US11>>>>>> = Fable.Core.RustInterop.emitRustExpr () v166 
    let v168 : string = "v167.await"
    let v169 : US11 = Fable.Core.RustInterop.emitRustExpr () v168 
    let v178 : async_walkdir_Filtering =
        match v169 with
        | US11_2 -> (* Continue *)
            let v174 : string = "async_walkdir::Filtering::Continue"
            let v175 : async_walkdir_Filtering = Fable.Core.RustInterop.emitRustExpr () v174 
            v175
        | US11_0 -> (* Ignore *)
            let v170 : string = "async_walkdir::Filtering::Ignore"
            let v171 : async_walkdir_Filtering = Fable.Core.RustInterop.emitRustExpr () v170 
            v171
        | US11_1 -> (* IgnoreDir *)
            let v172 : string = "async_walkdir::Filtering::IgnoreDir"
            let v173 : async_walkdir_Filtering = Fable.Core.RustInterop.emitRustExpr () v172 
            v173
    let v179 : async_walkdir_Filtering = method57(v178)
    let v180 : string = v145 + v146 
    let v181 : _ = v179 
    let v182 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v183 : string = $"true; let v181 = $0"
    let v184 : bool = Fable.Core.RustInterop.emitRustExpr v181 v183 
    let _v182 = v184 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v185 : string = $"true; let v181 = $0"
    let v186 : bool = Fable.Core.RustInterop.emitRustExpr v181 v185 
    let _v182 = v186 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v187 : string = $"true; let v181 = $0"
    let v188 : bool = Fable.Core.RustInterop.emitRustExpr v181 v187 
    let _v182 = v188 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v189 : bool = true
    let _v182 = v189 
    #endif
#if FABLE_COMPILER_PYTHON
    let v190 : bool = true
    let _v182 = v190 
    #endif
#else
    let v191 : bool = true
    let _v182 = v191 
    #endif
    let v192 : bool = _v182 
    let v195 : string = $"true; v181 " + v180 + "); " + v145 + " // rust.fix_closure'"
    let v196 : bool = Fable.Core.RustInterop.emitRustExpr () v195 
    let v197 : string = "__future_init"
    let v198 : _ = Fable.Core.RustInterop.emitRustExpr () v197 
    let v199 : string = "v198"
    let v200 : std_pin_Pin<Box<LifetimeJoin<Dyn<std_future_Future<async_walkdir_Filtering>>, Send<Dyn<std_future_Future<async_walkdir_Filtering>>>>>> = Fable.Core.RustInterop.emitRustExpr () v199 
    v200
and closure25 () (v0 : async_walkdir_Error) : std_string_String =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : string = "format!(\"{}\", $0)"
    let v3 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v2 
    let _v1 = v3 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v4 : string = "format!(\"{}\", $0)"
    let v5 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v4 
    let _v1 = v5 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v6 : string = "format!(\"{}\", $0)"
    let v7 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v6 
    let _v1 = v7 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v8 : std_string_String = null |> unbox<std_string_String>
    let _v1 = v8 
    #endif
#if FABLE_COMPILER_PYTHON
    let v11 : std_string_String = null |> unbox<std_string_String>
    let _v1 = v11 
    #endif
#else
    let v14 : std_string_String = null |> unbox<std_string_String>
    let _v1 = v14 
    #endif
    let v17 : std_string_String = _v1 
    v17
and method59 () : (async_walkdir_Error -> std_string_String) =
    closure25()
and closure26 () (v0 : async_walkdir_DirEntry) : US12 =
    US12_0(v0)
and closure27 () (v0 : std_string_String) : US12 =
    US12_1(v0)
and method60 () : string =
    
    
    
    
    
    let v0 : string = "Critical"
    let v1 : (unit -> string) = v0.ToLower
    let v2 : string = v1 ()
    let v5 : char = v2.[int 0]
    let v6 : string = method13(v5)
    let v7 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v8 : string = "inline_colorization::color_bright_red"
    let v9 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v8 
    let v10 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v11 : string = "&*$0"
    let v12 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v11 
    let _v10 = v12 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v13 : string = "&*$0"
    let v14 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v13 
    let _v10 = v14 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v15 : string = "&*$0"
    let v16 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v15 
    let _v10 = v16 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v17 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v10 = v17 
    #endif
#if FABLE_COMPILER_PYTHON
    let v20 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v10 = v20 
    #endif
#else
    let v23 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v10 = v23 
    #endif
    let v26 : Ref<Str> = _v10 
    let v31 : string = "inline_colorization::color_reset"
    let v32 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v31 
    let v33 : string = $"format!(\"{{}}{{}}{{}}\", $0, $1, $2)"
    let v34 : std_string_String = Fable.Core.RustInterop.emitRustExpr struct (v9, v26, v32) v33 
    let v35 : string = "fable_library_rust::String_::fromString($0)"
    let v36 : string = Fable.Core.RustInterop.emitRustExpr v34 v35 
    let _v7 = v36 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v37 : string = "inline_colorization::color_bright_red"
    let v38 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v37 
    let v39 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v40 : string = "&*$0"
    let v41 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v40 
    let _v39 = v41 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v42 : string = "&*$0"
    let v43 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v42 
    let _v39 = v43 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v44 : string = "&*$0"
    let v45 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v44 
    let _v39 = v45 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v46 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v39 = v46 
    #endif
#if FABLE_COMPILER_PYTHON
    let v49 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v39 = v49 
    #endif
#else
    let v52 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v39 = v52 
    #endif
    let v55 : Ref<Str> = _v39 
    let v60 : string = "inline_colorization::color_reset"
    let v61 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v60 
    let v62 : string = $"format!(\"{{}}{{}}{{}}\", $0, $1, $2)"
    let v63 : std_string_String = Fable.Core.RustInterop.emitRustExpr struct (v38, v55, v61) v62 
    let v64 : string = "fable_library_rust::String_::fromString($0)"
    let v65 : string = Fable.Core.RustInterop.emitRustExpr v63 v64 
    let _v7 = v65 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v66 : string = "inline_colorization::color_bright_red"
    let v67 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v66 
    let v68 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v69 : string = "&*$0"
    let v70 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v69 
    let _v68 = v70 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v71 : string = "&*$0"
    let v72 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v71 
    let _v68 = v72 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v73 : string = "&*$0"
    let v74 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v73 
    let _v68 = v74 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v75 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v68 = v75 
    #endif
#if FABLE_COMPILER_PYTHON
    let v78 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v68 = v78 
    #endif
#else
    let v81 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v68 = v81 
    #endif
    let v84 : Ref<Str> = _v68 
    let v89 : string = "inline_colorization::color_reset"
    let v90 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v89 
    let v91 : string = $"format!(\"{{}}{{}}{{}}\", $0, $1, $2)"
    let v92 : std_string_String = Fable.Core.RustInterop.emitRustExpr struct (v67, v84, v90) v91 
    let v93 : string = "fable_library_rust::String_::fromString($0)"
    let v94 : string = Fable.Core.RustInterop.emitRustExpr v92 v93 
    let _v7 = v94 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v95 : string = "\u001b[91m"
    let v96 : string = method15()
    let v97 : string = v95 + v6 
    let v98 : string = v97 + v96 
    let _v7 = v98 
    #endif
#if FABLE_COMPILER_PYTHON
    let v99 : string = "\u001b[91m"
    let v100 : string = method15()
    let v101 : string = v99 + v6 
    let v102 : string = v101 + v100 
    let _v7 = v102 
    #endif
#else
    let v103 : string = "\u001b[91m"
    let v104 : string = method15()
    let v105 : string = v103 + v6 
    let v106 : string = v105 + v104 
    let _v7 = v106 
    #endif
    let v107 : string = _v7 
    v107
and method62 (v0 : std_string_String) : string =
    let v1 : string = method14()
    let v2 : Mut3 = {l0 = v1} : Mut3
    let v3 : string = "{ "
    let v4 : string = $"{v3}"
    let v7 : unit = ()
    let v8 : (unit -> unit) = closure8(v2, v4)
    let v9 : unit = (fun () -> v8 (); v7) ()
    let v12 : string = "error"
    let v13 : string = $"{v12}"
    let v16 : unit = ()
    let v17 : (unit -> unit) = closure8(v2, v13)
    let v18 : unit = (fun () -> v17 (); v16) ()
    let v21 : string = " = "
    let v22 : string = $"{v21}"
    let v25 : unit = ()
    let v26 : (unit -> unit) = closure8(v2, v22)
    let v27 : unit = (fun () -> v26 (); v25) ()
    let v30 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v31 : string = "format!(\"{:#?}\", $0)"
    let v32 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v31 
    let v33 : string = "fable_library_rust::String_::fromString($0)"
    let v34 : string = Fable.Core.RustInterop.emitRustExpr v32 v33 
    let _v30 = v34 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v35 : string = "format!(\"{:#?}\", $0)"
    let v36 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v35 
    let v37 : string = "fable_library_rust::String_::fromString($0)"
    let v38 : string = Fable.Core.RustInterop.emitRustExpr v36 v37 
    let _v30 = v38 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v39 : string = "format!(\"{:#?}\", $0)"
    let v40 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v39 
    let v41 : string = "fable_library_rust::String_::fromString($0)"
    let v42 : string = Fable.Core.RustInterop.emitRustExpr v40 v41 
    let _v30 = v42 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v43 : string = $"%A{v0}"
    let _v30 = v43 
    #endif
#if FABLE_COMPILER_PYTHON
    let v46 : string = $"%A{v0}"
    let _v30 = v46 
    #endif
#else
    let v49 : string = $"%A{v0}"
    let _v30 = v49 
    #endif
    let v52 : string = _v30 
    let v57 : string = $"{v52}"
    let v60 : unit = ()
    let v61 : (unit -> unit) = closure8(v2, v57)
    let v62 : unit = (fun () -> v61 (); v60) ()
    let v65 : string = " }"
    let v66 : string = $"{v65}"
    let v69 : unit = ()
    let v70 : (unit -> unit) = closure8(v2, v66)
    let v71 : unit = (fun () -> v70 (); v69) ()
    let v74 : string = v2.l0
    v74
and method61 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : std_string_String) : string =
    let v9 : string = method62(v8)
    let v10 : int64 = v0.l0
    let v11 : string = "documents.run / stream_filter_map"
    let v12 : string = $"{v6} {v7} #{v10} %s{v11} / {v9}"
    method18(v12)
and closure28 (v0 : std_string_String) () : unit =
    let v1 : US0 = US0_4
    let v2 : bool = method7(v1)
    if v2 then
        let v3 : unit = ()
        let v4 : (unit -> unit) = closure6()
        let v5 : unit = (fun () -> v4 (); v3) ()
        let struct (v19 : Mut0, v20 : Mut1, v21 : Mut2, v22 : Mut3, v23 : Mut4, v24 : int64 option) = TraceState.trace_state.Value
        let v37 : string = method8(v19, v20, v21, v22, v23, v24)
        let v38 : string = method60()
        let v39 : string = method61(v19, v20, v21, v22, v23, v24, v37, v38, v0)
        method19(v39)
and closure24 () (v0 : Result<async_walkdir_DirEntry, async_walkdir_Error>) : string option =
    let v1 : (async_walkdir_Error -> std_string_String) = method59()
    let v2 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v3 : string = "$0.map_err(|x| $1(x))"
    let v4 : Result<async_walkdir_DirEntry, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v0, v1) v3 
    let _v2 = v4 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v5 : string = "$0.map_err(|x| $1(x))"
    let v6 : Result<async_walkdir_DirEntry, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v0, v1) v5 
    let _v2 = v6 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v7 : string = "$0.map_err(|x| $1(x))"
    let v8 : Result<async_walkdir_DirEntry, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v0, v1) v7 
    let _v2 = v8 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v9 : Result<async_walkdir_DirEntry, std_string_String> = match v0 with Ok x -> Ok x | Error x -> Error (v1 x)
    let _v2 = v9 
    #endif
#if FABLE_COMPILER_PYTHON
    let v10 : Result<async_walkdir_DirEntry, std_string_String> = match v0 with Ok x -> Ok x | Error x -> Error (v1 x)
    let _v2 = v10 
    #endif
#else
    let v11 : Result<async_walkdir_DirEntry, std_string_String> = match v0 with Ok x -> Ok x | Error x -> Error (v1 x)
    let _v2 = v11 
    #endif
    let v12 : Result<async_walkdir_DirEntry, std_string_String> = _v2 
    let v15 : (async_walkdir_DirEntry -> US12) = closure26()
    let v16 : (std_string_String -> US12) = closure27()
    let v17 : US12 = match v12 with Ok x -> v15 x | Error x -> v16 x
    let v111 : US1 =
        match v17 with
        | US12_1(v66) -> (* Error *)
            let v67 : unit = ()
            let v68 : (unit -> unit) = closure28(v66)
            let v69 : unit = (fun () -> v68 (); v67) ()
            US1_1
        | US12_0(v18) -> (* Ok *)
            let v19 : string = "async_walkdir::DirEntry::path(&$0)"
            let v20 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v18 v19 
            let v21 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v22 : string = "$0.display()"
            let v23 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v20 v22 
            let _v21 = v23 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v24 : string = "$0.display()"
            let v25 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v20 v24 
            let _v21 = v25 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v26 : string = "$0.display()"
            let v27 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v20 v26 
            let _v21 = v27 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v28 : std_path_Display = v20 |> unbox<std_path_Display>
            let _v21 = v28 
            #endif
#if FABLE_COMPILER_PYTHON
            let v31 : std_path_Display = v20 |> unbox<std_path_Display>
            let _v21 = v31 
            #endif
#else
            let v34 : std_path_Display = v20 |> unbox<std_path_Display>
            let _v21 = v34 
            #endif
            let v37 : std_path_Display = _v21 
            let v42 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v43 : string = "format!(\"{}\", $0)"
            let v44 : std_string_String = Fable.Core.RustInterop.emitRustExpr v37 v43 
            let _v42 = v44 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v45 : string = "format!(\"{}\", $0)"
            let v46 : std_string_String = Fable.Core.RustInterop.emitRustExpr v37 v45 
            let _v42 = v46 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v47 : string = "format!(\"{}\", $0)"
            let v48 : std_string_String = Fable.Core.RustInterop.emitRustExpr v37 v47 
            let _v42 = v48 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v49 : std_string_String = null |> unbox<std_string_String>
            let _v42 = v49 
            #endif
#if FABLE_COMPILER_PYTHON
            let v52 : std_string_String = null |> unbox<std_string_String>
            let _v42 = v52 
            #endif
#else
            let v55 : std_string_String = null |> unbox<std_string_String>
            let _v42 = v55 
            #endif
            let v58 : std_string_String = _v42 
            let v63 : string = "fable_library_rust::String_::fromString($0)"
            let v64 : string = Fable.Core.RustInterop.emitRustExpr v58 v63 
            US1_0(v64)
    match v111 with
    | US1_1 -> (* None *)
        let v116 : string option = None
        v116
    | US1_0(v112) -> (* Some *)
        let v113 : string option = Some v112 
        v113
and method58 () : (Result<async_walkdir_DirEntry, async_walkdir_Error> -> string option) =
    closure24()
and method64 (v0 : unativeint) : string =
    let v1 : string = method14()
    let v2 : Mut3 = {l0 = v1} : Mut3
    let v3 : string = "{ "
    let v4 : string = $"{v3}"
    let v7 : unit = ()
    let v8 : (unit -> unit) = closure8(v2, v4)
    let v9 : unit = (fun () -> v8 (); v7) ()
    let v12 : string = "files_len"
    let v13 : string = $"{v12}"
    let v16 : unit = ()
    let v17 : (unit -> unit) = closure8(v2, v13)
    let v18 : unit = (fun () -> v17 (); v16) ()
    let v21 : string = " = "
    let v22 : string = $"{v21}"
    let v25 : unit = ()
    let v26 : (unit -> unit) = closure8(v2, v22)
    let v27 : unit = (fun () -> v26 (); v25) ()
    let v30 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v31 : string = "format!(\"{:#?}\", $0)"
    let v32 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v31 
    let v33 : string = "fable_library_rust::String_::fromString($0)"
    let v34 : string = Fable.Core.RustInterop.emitRustExpr v32 v33 
    let _v30 = v34 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v35 : string = "format!(\"{:#?}\", $0)"
    let v36 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v35 
    let v37 : string = "fable_library_rust::String_::fromString($0)"
    let v38 : string = Fable.Core.RustInterop.emitRustExpr v36 v37 
    let _v30 = v38 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v39 : string = "format!(\"{:#?}\", $0)"
    let v40 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v39 
    let v41 : string = "fable_library_rust::String_::fromString($0)"
    let v42 : string = Fable.Core.RustInterop.emitRustExpr v40 v41 
    let _v30 = v42 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v43 : string = $"%A{v0}"
    let _v30 = v43 
    #endif
#if FABLE_COMPILER_PYTHON
    let v46 : string = $"%A{v0}"
    let _v30 = v46 
    #endif
#else
    let v49 : string = $"%A{v0}"
    let _v30 = v49 
    #endif
    let v52 : string = _v30 
    let v57 : string = $"{v52}"
    let v60 : unit = ()
    let v61 : (unit -> unit) = closure8(v2, v57)
    let v62 : unit = (fun () -> v61 (); v60) ()
    let v65 : string = " }"
    let v66 : string = $"{v65}"
    let v69 : unit = ()
    let v70 : (unit -> unit) = closure8(v2, v66)
    let v71 : unit = (fun () -> v70 (); v69) ()
    let v74 : string = v2.l0
    v74
and method63 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : unativeint) : string =
    let v9 : string = method64(v8)
    let v10 : int64 = v0.l0
    let v11 : string = "documents.run"
    let v12 : string = $"{v6} {v7} #{v10} %s{v11} / {v9}"
    method18(v12)
and closure29 (v0 : Vec<string>) () : unit =
    let v1 : US0 = US0_1
    let v2 : bool = method7(v1)
    if v2 then
        let v3 : unit = ()
        let v4 : (unit -> unit) = closure6()
        let v5 : unit = (fun () -> v4 (); v3) ()
        let struct (v19 : Mut0, v20 : Mut1, v21 : Mut2, v22 : Mut3, v23 : Mut4, v24 : int64 option) = TraceState.trace_state.Value
        let v37 : string = method8(v19, v20, v21, v22, v23, v24)
        let v38 : string = method50()
        let v39 : string = "$0.len()"
        let v40 : unativeint = Fable.Core.RustInterop.emitRustExpr v0 v39 
        let v41 : string = method63(v19, v20, v21, v22, v23, v24, v37, v38, v40)
        method19(v41)
and method65 () : string =
    let v0 : string = ""
    v0
and method66 (v0 : string) : string =
    let v1 : string = method39(v0)
    method40(v1)
and method68 (v0 : string, v1 : System.Threading.CancellationToken option, v2 : (struct (string * string) []), v3 : (struct (int32 * string * bool) -> Async<unit>) option, v4 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit) option, v5 : bool, v6 : string option) : string =
    v0
and closure33 (v0 : char) (v1 : UH0) : UH0 =
    UH0_1(v0, v1)
and closure32 () (v0 : char) : (UH0 -> UH0) =
    closure33(v0)
and method70 () : (char -> (UH0 -> UH0)) =
    closure32()
and method71 (v0 : UH0, v1 : System.Text.StringBuilder, v2 : int32, v3 : int32) : struct (System.Text.StringBuilder * int32 * int32) =
    match v0 with
    | UH0_1(v4, v5) -> (* Cons *)
        let v6 : bool = '\n' = v4
        let struct (v9 : int32, v10 : int32) =
            if v6 then
                let v7 : int32 = v2 + 1
                struct (v7, 1)
            else
                let v8 : int32 = v3 + 1
                struct (v2, v8)
        let v19 : System.Text.StringBuilder =
            if v6 then
                let v11 : (unit -> System.Text.StringBuilder) = v1.Clear
                let v12 : System.Text.StringBuilder = v11 ()
                v1
            else
                let v13 : (char -> string) = _.ToString()
                let v14 : string = v13 v4
                let v17 : (string -> System.Text.StringBuilder) = v1.Append
                let v18 : System.Text.StringBuilder = v17 v14
                v1
        method71(v5, v19, v9, v10)
    | UH0_0 -> (* Nil *)
        struct (v1, v2, v3)
and closure31 () struct (v0 : string, v1 : System.Text.StringBuilder, v2 : int32, v3 : int32) : US14 =
    let v4 : bool = "" = v0
    if v4 then
        let v5 : string = $"parsing.p_char / unexpected end of input / s: %A{struct (v1, v2, v3)}"
        US14_1(v5)
    else
        let v7 : char = v0.[int 0]
        let v8 : bool = v7 = '"'
        if v8 then
            let v9 : (string -> int32) = String.length
            let v10 : int32 = v9 v0
            let v11 : (int32 -> int32) = int32
            let v12 : int32 = v11 1
            let v13 : (int32 -> int32) = int32
            let v14 : int32 = v13 v10
            let v15 : string = v0.[int v12..int v14]
            let v16 : (char -> string) = _.ToString()
            let v17 : string = v16 v7
            let v20 : int32 = v17.Length
            let v21 : (char []) = Array.zeroCreate<char> (v20)
            let v22 : Mut6 = {l0 = 0} : Mut6
            while method48(v20, v22) do
                let v24 : int32 = v22.l0
                let v25 : char = v17.[int v24]
                v21.[int v24] <- v25
                let v26 : int32 = v24 + 1
                v22.l0 <- v26
                ()
            let v27 : char list = v21 |> Array.toList
            let v28 : ((char -> (UH0 -> UH0)) -> (char list -> (UH0 -> UH0))) = List.foldBack
            let v29 : (char -> (UH0 -> UH0)) = method70()
            let v30 : (char list -> (UH0 -> UH0)) = v28 v29
            let v31 : (UH0 -> UH0) = v30 v27
            let v32 : UH0 = UH0_0
            let v33 : UH0 = v31 v32
            let struct (v38 : System.Text.StringBuilder, v39 : int32, v40 : int32) = method71(v33, v1, v2, v3)
            US14_0(v7, v15, v38, v39, v40)
        else
            let v42 : (string -> int32) = String.length
            let v43 : int32 = v42 v0
            let v44 : string = "\n"
            let v45 : int32 = v0.IndexOf v44 
            let v46 : int32 = v45 - 1
            let v47 : bool = -2 = v46
            let v48 : int32 =
                if v47 then
                    v43
                else
                    v46
            let v49 : (int32 -> int32) = int32
            let v50 : int32 = v49 0
            let v51 : (int32 -> int32) = int32
            let v52 : int32 = v51 v48
            let v53 : string = v0.[int v50..int v52]
            let v54 : string = $"parsing.p_char / expected: '{'"'}' / line: {v2} / col: {v3}
{v1}{v53}"
            let v55 : int32 = v3 - 1
            let v56 : (int32 -> (string -> string)) = String.replicate
            let v57 : (string -> string) = v56 v55
            let v58 : string = " "
            let v59 : string = v57 v58
            let v62 : string = "^"
            let v63 : string = v59 + v62 
            let v64 : string = $"{v54}
{v63}
"
            US14_1(v64)
and closure34 () struct (v0 : string, v1 : System.Text.StringBuilder, v2 : int32, v3 : int32) : US14 =
    let v4 : bool = "" = v0
    if v4 then
        let v5 : string = $"parsing.p_char / unexpected end of input / s: %A{struct (v1, v2, v3)}"
        US14_1(v5)
    else
        let v7 : char = v0.[int 0]
        let v8 : bool = v7 = '''
        if v8 then
            let v9 : (string -> int32) = String.length
            let v10 : int32 = v9 v0
            let v11 : (int32 -> int32) = int32
            let v12 : int32 = v11 1
            let v13 : (int32 -> int32) = int32
            let v14 : int32 = v13 v10
            let v15 : string = v0.[int v12..int v14]
            let v16 : (char -> string) = _.ToString()
            let v17 : string = v16 v7
            let v20 : int32 = v17.Length
            let v21 : (char []) = Array.zeroCreate<char> (v20)
            let v22 : Mut6 = {l0 = 0} : Mut6
            while method48(v20, v22) do
                let v24 : int32 = v22.l0
                let v25 : char = v17.[int v24]
                v21.[int v24] <- v25
                let v26 : int32 = v24 + 1
                v22.l0 <- v26
                ()
            let v27 : char list = v21 |> Array.toList
            let v28 : ((char -> (UH0 -> UH0)) -> (char list -> (UH0 -> UH0))) = List.foldBack
            let v29 : (char -> (UH0 -> UH0)) = method70()
            let v30 : (char list -> (UH0 -> UH0)) = v28 v29
            let v31 : (UH0 -> UH0) = v30 v27
            let v32 : UH0 = UH0_0
            let v33 : UH0 = v31 v32
            let struct (v38 : System.Text.StringBuilder, v39 : int32, v40 : int32) = method71(v33, v1, v2, v3)
            US14_0(v7, v15, v38, v39, v40)
        else
            let v42 : (string -> int32) = String.length
            let v43 : int32 = v42 v0
            let v44 : string = "\n"
            let v45 : int32 = v0.IndexOf v44 
            let v46 : int32 = v45 - 1
            let v47 : bool = -2 = v46
            let v48 : int32 =
                if v47 then
                    v43
                else
                    v46
            let v49 : (int32 -> int32) = int32
            let v50 : int32 = v49 0
            let v51 : (int32 -> int32) = int32
            let v52 : int32 = v51 v48
            let v53 : string = v0.[int v50..int v52]
            let v54 : string = $"parsing.p_char / expected: '{'''}' / line: {v2} / col: {v3}
{v1}{v53}"
            let v55 : int32 = v3 - 1
            let v56 : (int32 -> (string -> string)) = String.replicate
            let v57 : (string -> string) = v56 v55
            let v58 : string = " "
            let v59 : string = v57 v58
            let v62 : string = "^"
            let v63 : string = v59 + v62 
            let v64 : string = $"{v54}
{v63}
"
            US14_1(v64)
and method72 (v0 : string, v1 : System.Text.StringBuilder, v2 : UH1) : US14 =
    match v2 with
    | UH1_1(v5, v6) -> (* Cons *)
        let v7 : US14 = v5 struct (v0, v1, 1, 1)
        match v7 with
        | US14_1(v13) -> (* Error *)
            method72(v0, v1, v6)
        | US14_0(v8, v9, v10, v11, v12) -> (* Ok *)
            v7
    | UH1_0 -> (* Nil *)
        let v3 : string = "choice / no parsers succeeded"
        US14_1(v3)
and method73 (v0 : char, v1 : int64) : bool =
    let v2 : bool = v1 >= 2L
    if v2 then
        false
    else
        let v3 : bool = v1 = 0L
        let v11 : US16 =
            if v3 then
                US16_0('"')
            else
                let v5 : int64 = v1 - 1L
                let v6 : bool = v5 = 0L
                if v6 then
                    US16_0(''')
                else
                    let v8 : int64 = v5 - 1L
                    US16_1
        let v15 : char =
            match v11 with
            | US16_1 -> (* None *)
                failwith<char> "Option does not have a value."
            | US16_0(v12) -> (* Some *)
                v12
        let v16 : bool = v0 = v15
        if v16 then
            true
        else
            let v17 : int64 = v1 + 1L
            method73(v0, v17)
and method74 (v0 : string, v1 : string, v2 : System.Text.StringBuilder, v3 : int32, v4 : int32) : US15 =
    let v5 : bool = "" = v1
    let v70 : US14 =
        if v5 then
            let v6 : char list = []
            let v7 : char list = ''' :: v6 
            let v10 : char list = '"' :: v7 
            let v13 : (char list -> (char [])) = List.toArray
            let v14 : (char []) = v13 v10
            let v17 : string = $"parsing.none_of / unexpected end of input / chars: %A{v14} / s: %A{struct (v2, v3, v4)}"
            US14_1(v17)
        else
            let v19 : char = v1.[int 0]
            let v20 : (string -> int32) = String.length
            let v21 : int32 = v20 v1
            let v22 : (int32 -> int32) = int32
            let v23 : int32 = v22 1
            let v24 : (int32 -> int32) = int32
            let v25 : int32 = v24 v21
            let v26 : string = v1.[int v23..int v25]
            let v27 : int64 = 0L
            let v28 : bool = method73(v19, v27)
            let v29 : bool = v28 = false
            if v29 then
                let v30 : (char -> string) = _.ToString()
                let v31 : string = v30 v19
                let v34 : int32 = v31.Length
                let v35 : (char []) = Array.zeroCreate<char> (v34)
                let v36 : Mut6 = {l0 = 0} : Mut6
                while method48(v34, v36) do
                    let v38 : int32 = v36.l0
                    let v39 : char = v31.[int v38]
                    v35.[int v38] <- v39
                    let v40 : int32 = v38 + 1
                    v36.l0 <- v40
                    ()
                let v41 : char list = v35 |> Array.toList
                let v42 : ((char -> (UH0 -> UH0)) -> (char list -> (UH0 -> UH0))) = List.foldBack
                let v43 : (char -> (UH0 -> UH0)) = method70()
                let v44 : (char list -> (UH0 -> UH0)) = v42 v43
                let v45 : (UH0 -> UH0) = v44 v41
                let v46 : UH0 = UH0_0
                let v47 : UH0 = v45 v46
                let struct (v52 : System.Text.StringBuilder, v53 : int32, v54 : int32) = method71(v47, v2, v3, v4)
                US14_0(v19, v26, v52, v53, v54)
            else
                let v56 : char list = []
                let v57 : char list = ''' :: v56 
                let v60 : char list = '"' :: v57 
                let v63 : (char list -> (char [])) = List.toArray
                let v64 : (char []) = v63 v60
                let v67 : string = $"parsing.none_of / unexpected char: '{v19}' / chars: %A{v64} / s: %A{struct (v2, v3, v4)}"
                US14_1(v67)
    let v82 : US14 =
        match v70 with
        | US14_1(v79) -> (* Error *)
            US14_1(v79)
        | US14_0(v71, v72, v73, v74, v75) -> (* Ok *)
            let v76 : bool = '\\' = v71
            let v77 : char =
                if v76 then
                    '/'
                else
                    v71
            US14_0(v77, v72, v73, v74, v75)
    match v82 with
    | US14_1(v94) -> (* Error *)
        US15_0(v0, v1, v2, v3, v4)
    | US14_0(v83, v84, v85, v86, v87) -> (* Ok *)
        let v88 : (char -> string) = _.ToString()
        let v89 : string = v88 v83
        let v92 : string = v0 + v89 
        method74(v92, v84, v85, v86, v87)
and method75 (v0 : string, v1 : System.Text.StringBuilder, v2 : int32, v3 : int32, v4 : UH1) : US14 =
    match v4 with
    | UH1_1(v7, v8) -> (* Cons *)
        let v9 : US14 = v7 struct (v0, v1, v2, v3)
        match v9 with
        | US14_1(v15) -> (* Error *)
            method75(v0, v1, v2, v3, v8)
        | US14_0(v10, v11, v12, v13, v14) -> (* Ok *)
            v9
    | UH1_0 -> (* Nil *)
        let v5 : string = "choice / no parsers succeeded"
        US14_1(v5)
and method76 (v0 : char, v1 : int64) : bool =
    let v2 : bool = v1 >= 3L
    if v2 then
        false
    else
        let v3 : bool = v1 = 0L
        let v15 : US16 =
            if v3 then
                US16_0('"')
            else
                let v5 : int64 = v1 - 1L
                let v6 : bool = v5 = 0L
                if v6 then
                    US16_0(''')
                else
                    let v8 : int64 = v5 - 1L
                    let v9 : bool = v8 = 0L
                    if v9 then
                        US16_0(' ')
                    else
                        let v11 : int64 = v8 - 1L
                        US16_1
        let v19 : char =
            match v15 with
            | US16_1 -> (* None *)
                failwith<char> "Option does not have a value."
            | US16_0(v16) -> (* Some *)
                v16
        let v20 : bool = v0 = v19
        if v20 then
            true
        else
            let v21 : int64 = v1 + 1L
            method76(v0, v21)
and method77 (v0 : string, v1 : string, v2 : System.Text.StringBuilder, v3 : int32, v4 : int32) : US15 =
    let v5 : bool = "" = v1
    let v76 : US14 =
        if v5 then
            let v6 : char list = []
            let v7 : char list = ' ' :: v6 
            let v10 : char list = ''' :: v7 
            let v13 : char list = '"' :: v10 
            let v16 : (char list -> (char [])) = List.toArray
            let v17 : (char []) = v16 v13
            let v20 : string = $"parsing.none_of / unexpected end of input / chars: %A{v17} / s: %A{struct (v2, v3, v4)}"
            US14_1(v20)
        else
            let v22 : char = v1.[int 0]
            let v23 : (string -> int32) = String.length
            let v24 : int32 = v23 v1
            let v25 : (int32 -> int32) = int32
            let v26 : int32 = v25 1
            let v27 : (int32 -> int32) = int32
            let v28 : int32 = v27 v24
            let v29 : string = v1.[int v26..int v28]
            let v30 : int64 = 0L
            let v31 : bool = method76(v22, v30)
            let v32 : bool = v31 = false
            if v32 then
                let v33 : (char -> string) = _.ToString()
                let v34 : string = v33 v22
                let v37 : int32 = v34.Length
                let v38 : (char []) = Array.zeroCreate<char> (v37)
                let v39 : Mut6 = {l0 = 0} : Mut6
                while method48(v37, v39) do
                    let v41 : int32 = v39.l0
                    let v42 : char = v34.[int v41]
                    v38.[int v41] <- v42
                    let v43 : int32 = v41 + 1
                    v39.l0 <- v43
                    ()
                let v44 : char list = v38 |> Array.toList
                let v45 : ((char -> (UH0 -> UH0)) -> (char list -> (UH0 -> UH0))) = List.foldBack
                let v46 : (char -> (UH0 -> UH0)) = method70()
                let v47 : (char list -> (UH0 -> UH0)) = v45 v46
                let v48 : (UH0 -> UH0) = v47 v44
                let v49 : UH0 = UH0_0
                let v50 : UH0 = v48 v49
                let struct (v55 : System.Text.StringBuilder, v56 : int32, v57 : int32) = method71(v50, v2, v3, v4)
                US14_0(v22, v29, v55, v56, v57)
            else
                let v59 : char list = []
                let v60 : char list = ' ' :: v59 
                let v63 : char list = ''' :: v60 
                let v66 : char list = '"' :: v63 
                let v69 : (char list -> (char [])) = List.toArray
                let v70 : (char []) = v69 v66
                let v73 : string = $"parsing.none_of / unexpected char: '{v22}' / chars: %A{v70} / s: %A{struct (v2, v3, v4)}"
                US14_1(v73)
    let v88 : US14 =
        match v76 with
        | US14_1(v85) -> (* Error *)
            US14_1(v85)
        | US14_0(v77, v78, v79, v80, v81) -> (* Ok *)
            let v82 : bool = '\\' = v77
            let v83 : char =
                if v82 then
                    '/'
                else
                    v77
            US14_0(v83, v78, v79, v80, v81)
    match v88 with
    | US14_1(v100) -> (* Error *)
        US15_0(v0, v1, v2, v3, v4)
    | US14_0(v89, v90, v91, v92, v93) -> (* Ok *)
        let v94 : (char -> string) = _.ToString()
        let v95 : string = v94 v89
        let v98 : string = v0 + v95 
        method77(v98, v90, v91, v92, v93)
and method78 (v0 : string, v1 : int32) : int32 =
    let v2 : int32 = v0.Length
    let v3 : bool = v1 >= v2
    if v3 then
        v1
    else
        let v4 : char = v0.[int v1]
        let v5 : bool = v4 = ' '
        if v5 then
            let v6 : int32 = v1 + 1
            method78(v0, v6)
        else
            v1
and method79 (v0 : string, v1 : string, v2 : System.Text.StringBuilder, v3 : int32, v4 : int32) : US15 =
    let v5 : bool = "" = v1
    let v42 : US14 =
        if v5 then
            let v6 : string = $"parsing.any_char / unexpected end of input / s: %A{struct (v2, v3, v4)}"
            US14_1(v6)
        else
            let v8 : char = v1.[int 0]
            let v9 : (string -> int32) = String.length
            let v10 : int32 = v9 v1
            let v11 : (int32 -> int32) = int32
            let v12 : int32 = v11 1
            let v13 : (int32 -> int32) = int32
            let v14 : int32 = v13 v10
            let v15 : string = v1.[int v12..int v14]
            let v16 : (char -> string) = _.ToString()
            let v17 : string = v16 v8
            let v20 : int32 = v17.Length
            let v21 : (char []) = Array.zeroCreate<char> (v20)
            let v22 : Mut6 = {l0 = 0} : Mut6
            while method48(v20, v22) do
                let v24 : int32 = v22.l0
                let v25 : char = v17.[int v24]
                v21.[int v24] <- v25
                let v26 : int32 = v24 + 1
                v22.l0 <- v26
                ()
            let v27 : char list = v21 |> Array.toList
            let v28 : ((char -> (UH0 -> UH0)) -> (char list -> (UH0 -> UH0))) = List.foldBack
            let v29 : (char -> (UH0 -> UH0)) = method70()
            let v30 : (char list -> (UH0 -> UH0)) = v28 v29
            let v31 : (UH0 -> UH0) = v30 v27
            let v32 : UH0 = UH0_0
            let v33 : UH0 = v31 v32
            let struct (v38 : System.Text.StringBuilder, v39 : int32, v40 : int32) = method71(v33, v2, v3, v4)
            US14_0(v8, v15, v38, v39, v40)
    match v42 with
    | US14_1(v54) -> (* Error *)
        US15_0(v0, v1, v2, v3, v4)
    | US14_0(v43, v44, v45, v46, v47) -> (* Ok *)
        let v48 : (char -> string) = _.ToString()
        let v49 : string = v48 v43
        let v52 : string = v0 + v49 
        method79(v52, v44, v45, v46, v47)
and method69 (v0 : string) : US13 =
    let mutable _v0 = None
    #if !FABLE_COMPILER && !WASM && !CONTRACT
    let v1 : (string -> string option) = Option.ofObj
    let v2 : string option = v1 v0
    v2 
    #else
    Some v0 
    #endif
    |> fun x -> _v0 <- Some x
    let v3 : string option = match _v0 with Some x -> x | None -> failwith "optionm'.of_obj / _v0=None"
    let v6 : string = ""
    let v7 : string = v3 |> Option.defaultValue v6 
    let v10 : (string -> System.Text.StringBuilder) = System.Text.StringBuilder 
    let v11 : System.Text.StringBuilder = v10 v6
    let v12 : (struct (string * System.Text.StringBuilder * int32 * int32) -> US14) = closure31()
    let v13 : (struct (string * System.Text.StringBuilder * int32 * int32) -> US14) = closure34()
    let v14 : UH1 = UH1_0
    let v15 : UH1 = UH1_1(v13, v14)
    let v16 : UH1 = UH1_1(v12, v15)
    let v17 : US14 = method72(v7, v11, v16)
    let v153 : US15 =
        match v17 with
        | US14_1(v150) -> (* Error *)
            US15_1(v150)
        | US14_0(v18, v19, v20, v21, v22) -> (* Ok *)
            let v23 : bool = "" = v19
            let v88 : US14 =
                if v23 then
                    let v24 : char list = []
                    let v25 : char list = ''' :: v24 
                    let v28 : char list = '"' :: v25 
                    let v31 : (char list -> (char [])) = List.toArray
                    let v32 : (char []) = v31 v28
                    let v35 : string = $"parsing.none_of / unexpected end of input / chars: %A{v32} / s: %A{struct (v20, v21, v22)}"
                    US14_1(v35)
                else
                    let v37 : char = v19.[int 0]
                    let v38 : (string -> int32) = String.length
                    let v39 : int32 = v38 v19
                    let v40 : (int32 -> int32) = int32
                    let v41 : int32 = v40 1
                    let v42 : (int32 -> int32) = int32
                    let v43 : int32 = v42 v39
                    let v44 : string = v19.[int v41..int v43]
                    let v45 : int64 = 0L
                    let v46 : bool = method73(v37, v45)
                    let v47 : bool = v46 = false
                    if v47 then
                        let v48 : (char -> string) = _.ToString()
                        let v49 : string = v48 v37
                        let v52 : int32 = v49.Length
                        let v53 : (char []) = Array.zeroCreate<char> (v52)
                        let v54 : Mut6 = {l0 = 0} : Mut6
                        while method48(v52, v54) do
                            let v56 : int32 = v54.l0
                            let v57 : char = v49.[int v56]
                            v53.[int v56] <- v57
                            let v58 : int32 = v56 + 1
                            v54.l0 <- v58
                            ()
                        let v59 : char list = v53 |> Array.toList
                        let v60 : ((char -> (UH0 -> UH0)) -> (char list -> (UH0 -> UH0))) = List.foldBack
                        let v61 : (char -> (UH0 -> UH0)) = method70()
                        let v62 : (char list -> (UH0 -> UH0)) = v60 v61
                        let v63 : (UH0 -> UH0) = v62 v59
                        let v64 : UH0 = UH0_0
                        let v65 : UH0 = v63 v64
                        let struct (v70 : System.Text.StringBuilder, v71 : int32, v72 : int32) = method71(v65, v20, v21, v22)
                        US14_0(v37, v44, v70, v71, v72)
                    else
                        let v74 : char list = []
                        let v75 : char list = ''' :: v74 
                        let v78 : char list = '"' :: v75 
                        let v81 : (char list -> (char [])) = List.toArray
                        let v82 : (char []) = v81 v78
                        let v85 : string = $"parsing.none_of / unexpected char: '{v37}' / chars: %A{v82} / s: %A{struct (v20, v21, v22)}"
                        US14_1(v85)
            let v100 : US14 =
                match v88 with
                | US14_1(v97) -> (* Error *)
                    US14_1(v97)
                | US14_0(v89, v90, v91, v92, v93) -> (* Ok *)
                    let v94 : bool = '\\' = v89
                    let v95 : char =
                        if v94 then
                            '/'
                        else
                            v89
                    US14_0(v95, v90, v91, v92, v93)
            let v114 : US15 =
                match v100 with
                | US14_1(v101) -> (* Error *)
                    US15_1(v101)
                | US14_0(v103, v104, v105, v106, v107) -> (* Ok *)
                    let v108 : (char -> string) = _.ToString()
                    let v109 : string = v108 v103
                    method74(v109, v104, v105, v106, v107)
            let v124 : US15 =
                match v114 with
                | US15_1(v121) -> (* Error *)
                    US15_0(v6, v19, v20, v21, v22)
                | US15_0(v115, v116, v117, v118, v119) -> (* Ok *)
                    US15_0(v115, v116, v117, v118, v119)
            match v124 with
            | US15_1(v145) -> (* Error *)
                let v146 : string = "between / expected content"
                US15_1(v146)
            | US15_0(v125, v126, v127, v128, v129) -> (* Ok *)
                let v130 : UH1 = UH1_0
                let v131 : UH1 = UH1_1(v13, v130)
                let v132 : UH1 = UH1_1(v12, v131)
                let v133 : US14 = method75(v126, v127, v128, v129, v132)
                match v133 with
                | US14_1(v140) -> (* Error *)
                    let v141 : string = $"between / expected closing delimiter / e: %A{v140} / input: %A{struct (v7, v11, 1, 1)} / rest1: %A{struct (v19, v20, v21, v22)} / rest2: %A{struct (v126, v127, v128, v129)}"
                    US15_1(v141)
                | US14_0(v134, v135, v136, v137, v138) -> (* Ok *)
                    US15_0(v125, v135, v136, v137, v138)
    let v303 : US15 =
        match v153 with
        | US15_1(v159) -> (* Error *)
            let v160 : bool = "" = v7
            let v233 : US14 =
                if v160 then
                    let v161 : char list = []
                    let v162 : char list = ' ' :: v161 
                    let v165 : char list = ''' :: v162 
                    let v168 : char list = '"' :: v165 
                    let v171 : (char list -> (char [])) = List.toArray
                    let v172 : (char []) = v171 v168
                    let v175 : string = $"parsing.none_of / unexpected end of input / chars: %A{v172} / s: %A{struct (v11, 1, 1)}"
                    US14_1(v175)
                else
                    let v177 : char = v7.[int 0]
                    let v178 : (string -> int32) = String.length
                    let v179 : int32 = v178 v7
                    let v180 : (int32 -> int32) = int32
                    let v181 : int32 = v180 1
                    let v182 : (int32 -> int32) = int32
                    let v183 : int32 = v182 v179
                    let v184 : string = v7.[int v181..int v183]
                    let v185 : int64 = 0L
                    let v186 : bool = method76(v177, v185)
                    let v187 : bool = v186 = false
                    if v187 then
                        let v188 : (char -> string) = _.ToString()
                        let v189 : string = v188 v177
                        let v192 : int32 = v189.Length
                        let v193 : (char []) = Array.zeroCreate<char> (v192)
                        let v194 : Mut6 = {l0 = 0} : Mut6
                        while method48(v192, v194) do
                            let v196 : int32 = v194.l0
                            let v197 : char = v189.[int v196]
                            v193.[int v196] <- v197
                            let v198 : int32 = v196 + 1
                            v194.l0 <- v198
                            ()
                        let v199 : char list = v193 |> Array.toList
                        let v200 : ((char -> (UH0 -> UH0)) -> (char list -> (UH0 -> UH0))) = List.foldBack
                        let v201 : (char -> (UH0 -> UH0)) = method70()
                        let v202 : (char list -> (UH0 -> UH0)) = v200 v201
                        let v203 : (UH0 -> UH0) = v202 v199
                        let v204 : UH0 = UH0_0
                        let v205 : UH0 = v203 v204
                        let v210 : int32 = 1
                        let v211 : int32 = 1
                        let struct (v212 : System.Text.StringBuilder, v213 : int32, v214 : int32) = method71(v205, v11, v210, v211)
                        US14_0(v177, v184, v212, v213, v214)
                    else
                        let v216 : char list = []
                        let v217 : char list = ' ' :: v216 
                        let v220 : char list = ''' :: v217 
                        let v223 : char list = '"' :: v220 
                        let v226 : (char list -> (char [])) = List.toArray
                        let v227 : (char []) = v226 v223
                        let v230 : string = $"parsing.none_of / unexpected char: '{v177}' / chars: %A{v227} / s: %A{struct (v11, 1, 1)}"
                        US14_1(v230)
            let v245 : US14 =
                match v233 with
                | US14_1(v242) -> (* Error *)
                    US14_1(v242)
                | US14_0(v234, v235, v236, v237, v238) -> (* Ok *)
                    let v239 : bool = '\\' = v234
                    let v240 : char =
                        if v239 then
                            '/'
                        else
                            v234
                    US14_0(v240, v235, v236, v237, v238)
            let v259 : US15 =
                match v245 with
                | US14_1(v246) -> (* Error *)
                    US15_1(v246)
                | US14_0(v248, v249, v250, v251, v252) -> (* Ok *)
                    let v253 : (char -> string) = _.ToString()
                    let v254 : string = v253 v248
                    method77(v254, v249, v250, v251, v252)
            match v259 with
            | US15_1(v265) -> (* Error *)
                let v266 : int32 = v7.Length
                let v267 : bool = v266 = 0
                let v271 : US17 =
                    if v267 then
                        US17_0(v7, v11, 1, 1)
                    else
                        let v269 : string = $"parsing.eof / expected end of input / input: %A{v7}"
                        US17_1(v269)
                let v280 : US15 =
                    match v271 with
                    | US17_1(v277) -> (* Error *)
                        US15_1(v277)
                    | US17_0(v272, v273, v274, v275) -> (* Ok *)
                        US15_0(v6, v272, v273, v274, v275)
                match v280 with
                | US15_1(v296) -> (* Error *)
                    US15_1(v296)
                | US15_0(v281, v282, v283, v284, v285) -> (* Ok *)
                    let v286 : int32 = 0
                    let v287 : int32 = method78(v282, v286)
                    let v288 : (string -> int32) = String.length
                    let v289 : int32 = v288 v282
                    let v290 : (int32 -> int32) = int32
                    let v291 : int32 = v290 v287
                    let v292 : (int32 -> int32) = int32
                    let v293 : int32 = v292 v289
                    let v294 : string = v282.[int v291..int v293]
                    US15_0(v281, v294, v283, v284, v285)
            | US15_0(v260, v261, v262, v263, v264) -> (* Ok *)
                v259
        | US15_0(v154, v155, v156, v157, v158) -> (* Ok *)
            v153
    let v471 : US18 =
        match v303 with
        | US15_1(v468) -> (* Error *)
            US18_1(v468)
        | US15_0(v304, v305, v306, v307, v308) -> (* Ok *)
            let v309 : bool = "" = v305
            let v372 : US14 =
                if v309 then
                    let v310 : string = $"parsing.p_char / unexpected end of input / s: %A{struct (v306, v307, v308)}"
                    US14_1(v310)
                else
                    let v312 : char = v305.[int 0]
                    let v313 : bool = v312 = ' '
                    if v313 then
                        let v314 : (string -> int32) = String.length
                        let v315 : int32 = v314 v305
                        let v316 : (int32 -> int32) = int32
                        let v317 : int32 = v316 1
                        let v318 : (int32 -> int32) = int32
                        let v319 : int32 = v318 v315
                        let v320 : string = v305.[int v317..int v319]
                        let v321 : (char -> string) = _.ToString()
                        let v322 : string = v321 v312
                        let v325 : int32 = v322.Length
                        let v326 : (char []) = Array.zeroCreate<char> (v325)
                        let v327 : Mut6 = {l0 = 0} : Mut6
                        while method48(v325, v327) do
                            let v329 : int32 = v327.l0
                            let v330 : char = v322.[int v329]
                            v326.[int v329] <- v330
                            let v331 : int32 = v329 + 1
                            v327.l0 <- v331
                            ()
                        let v332 : char list = v326 |> Array.toList
                        let v333 : ((char -> (UH0 -> UH0)) -> (char list -> (UH0 -> UH0))) = List.foldBack
                        let v334 : (char -> (UH0 -> UH0)) = method70()
                        let v335 : (char list -> (UH0 -> UH0)) = v333 v334
                        let v336 : (UH0 -> UH0) = v335 v332
                        let v337 : UH0 = UH0_0
                        let v338 : UH0 = v336 v337
                        let struct (v343 : System.Text.StringBuilder, v344 : int32, v345 : int32) = method71(v338, v306, v307, v308)
                        US14_0(v312, v320, v343, v344, v345)
                    else
                        let v347 : (string -> int32) = String.length
                        let v348 : int32 = v347 v305
                        let v349 : string = "\n"
                        let v350 : int32 = v305.IndexOf v349 
                        let v351 : int32 = v350 - 1
                        let v352 : bool = -2 = v351
                        let v353 : int32 =
                            if v352 then
                                v348
                            else
                                v351
                        let v354 : (int32 -> int32) = int32
                        let v355 : int32 = v354 0
                        let v356 : (int32 -> int32) = int32
                        let v357 : int32 = v356 v353
                        let v358 : string = v305.[int v355..int v357]
                        let v359 : string = $"parsing.p_char / expected: '{' '}' / line: {v307} / col: {v308}
{v306}{v358}"
                        let v360 : int32 = v308 - 1
                        let v361 : (int32 -> (string -> string)) = String.replicate
                        let v362 : (string -> string) = v361 v360
                        let v363 : string = " "
                        let v364 : string = v362 v363
                        let v367 : string = "^"
                        let v368 : string = v364 + v367 
                        let v369 : string = $"{v359}
{v368}
"
                        US14_1(v369)
            let v384 : US19 =
                match v372 with
                | US14_1(v380) -> (* Error *)
                    let v381 : US16 = US16_1
                    US19_0(v381, v305, v306, v307, v308)
                | US14_0(v373, v374, v375, v376, v377) -> (* Ok *)
                    let v378 : US16 = US16_0(v373)
                    US19_0(v378, v374, v375, v376, v377)
            let v445 : US15 =
                match v384 with
                | US19_1(v442) -> (* Error *)
                    US15_1(v442)
                | US19_0(v385, v386, v387, v388, v389) -> (* Ok *)
                    let v390 : bool = "" = v386
                    let v427 : US14 =
                        if v390 then
                            let v391 : string = $"parsing.any_char / unexpected end of input / s: %A{struct (v387, v388, v389)}"
                            US14_1(v391)
                        else
                            let v393 : char = v386.[int 0]
                            let v394 : (string -> int32) = String.length
                            let v395 : int32 = v394 v386
                            let v396 : (int32 -> int32) = int32
                            let v397 : int32 = v396 1
                            let v398 : (int32 -> int32) = int32
                            let v399 : int32 = v398 v395
                            let v400 : string = v386.[int v397..int v399]
                            let v401 : (char -> string) = _.ToString()
                            let v402 : string = v401 v393
                            let v405 : int32 = v402.Length
                            let v406 : (char []) = Array.zeroCreate<char> (v405)
                            let v407 : Mut6 = {l0 = 0} : Mut6
                            while method48(v405, v407) do
                                let v409 : int32 = v407.l0
                                let v410 : char = v402.[int v409]
                                v406.[int v409] <- v410
                                let v411 : int32 = v409 + 1
                                v407.l0 <- v411
                                ()
                            let v412 : char list = v406 |> Array.toList
                            let v413 : ((char -> (UH0 -> UH0)) -> (char list -> (UH0 -> UH0))) = List.foldBack
                            let v414 : (char -> (UH0 -> UH0)) = method70()
                            let v415 : (char list -> (UH0 -> UH0)) = v413 v414
                            let v416 : (UH0 -> UH0) = v415 v412
                            let v417 : UH0 = UH0_0
                            let v418 : UH0 = v416 v417
                            let struct (v423 : System.Text.StringBuilder, v424 : int32, v425 : int32) = method71(v418, v387, v388, v389)
                            US14_0(v393, v400, v423, v424, v425)
                    match v427 with
                    | US14_1(v428) -> (* Error *)
                        US15_1(v428)
                    | US14_0(v430, v431, v432, v433, v434) -> (* Ok *)
                        let v435 : (char -> string) = _.ToString()
                        let v436 : string = v435 v430
                        method79(v436, v431, v432, v433, v434)
            let v457 : US20 =
                match v445 with
                | US15_1(v453) -> (* Error *)
                    let v454 : US1 = US1_1
                    US20_0(v454, v305, v306, v307, v308)
                | US15_0(v446, v447, v448, v449, v450) -> (* Ok *)
                    let v451 : US1 = US1_0(v446)
                    US20_0(v451, v447, v448, v449, v450)
            match v457 with
            | US20_1(v464) -> (* Error *)
                US18_1(v464)
            | US20_0(v458, v459, v460, v461, v462) -> (* Ok *)
                US18_0(v304, v458, v459, v460, v461, v462)
    match v471 with
    | US18_1(v479) -> (* Error *)
        US13_1(v479)
    | US18_0(v472, v473, v474, v475, v476, v477) -> (* Ok *)
        US13_0(v472, v473)
and method82 (v0 : char, v1 : int64) : bool =
    let v2 : bool = v1 >= 4L
    if v2 then
        false
    else
        let v3 : bool = v1 = 0L
        let v19 : US16 =
            if v3 then
                US16_0('\\')
            else
                let v5 : int64 = v1 - 1L
                let v6 : bool = v5 = 0L
                if v6 then
                    US16_0('`')
                else
                    let v8 : int64 = v5 - 1L
                    let v9 : bool = v8 = 0L
                    if v9 then
                        US16_0('"')
                    else
                        let v11 : int64 = v8 - 1L
                        let v12 : bool = v11 = 0L
                        if v12 then
                            US16_0(' ')
                        else
                            let v14 : int64 = v11 - 1L
                            US16_1
        let v23 : char =
            match v19 with
            | US16_1 -> (* None *)
                failwith<char> "Option does not have a value."
            | US16_0(v20) -> (* Some *)
                v20
        let v24 : bool = v0 = v23
        if v24 then
            true
        else
            let v25 : int64 = v1 + 1L
            method82(v0, v25)
and method83 (v0 : string, v1 : string, v2 : System.Text.StringBuilder, v3 : int32, v4 : int32) : US15 =
    let v5 : bool = "" = v1
    let v82 : US14 =
        if v5 then
            let v6 : char list = []
            let v7 : char list = ' ' :: v6 
            let v10 : char list = '"' :: v7 
            let v13 : char list = '`' :: v10 
            let v16 : char list = '\\' :: v13 
            let v19 : (char list -> (char [])) = List.toArray
            let v20 : (char []) = v19 v16
            let v23 : string = $"parsing.none_of / unexpected end of input / chars: %A{v20} / s: %A{struct (v2, v3, v4)}"
            US14_1(v23)
        else
            let v25 : char = v1.[int 0]
            let v26 : (string -> int32) = String.length
            let v27 : int32 = v26 v1
            let v28 : (int32 -> int32) = int32
            let v29 : int32 = v28 1
            let v30 : (int32 -> int32) = int32
            let v31 : int32 = v30 v27
            let v32 : string = v1.[int v29..int v31]
            let v33 : int64 = 0L
            let v34 : bool = method82(v25, v33)
            let v35 : bool = v34 = false
            if v35 then
                let v36 : (char -> string) = _.ToString()
                let v37 : string = v36 v25
                let v40 : int32 = v37.Length
                let v41 : (char []) = Array.zeroCreate<char> (v40)
                let v42 : Mut6 = {l0 = 0} : Mut6
                while method48(v40, v42) do
                    let v44 : int32 = v42.l0
                    let v45 : char = v37.[int v44]
                    v41.[int v44] <- v45
                    let v46 : int32 = v44 + 1
                    v42.l0 <- v46
                    ()
                let v47 : char list = v41 |> Array.toList
                let v48 : ((char -> (UH0 -> UH0)) -> (char list -> (UH0 -> UH0))) = List.foldBack
                let v49 : (char -> (UH0 -> UH0)) = method70()
                let v50 : (char list -> (UH0 -> UH0)) = v48 v49
                let v51 : (UH0 -> UH0) = v50 v47
                let v52 : UH0 = UH0_0
                let v53 : UH0 = v51 v52
                let struct (v58 : System.Text.StringBuilder, v59 : int32, v60 : int32) = method71(v53, v2, v3, v4)
                US14_0(v25, v32, v58, v59, v60)
            else
                let v62 : char list = []
                let v63 : char list = ' ' :: v62 
                let v66 : char list = '"' :: v63 
                let v69 : char list = '`' :: v66 
                let v72 : char list = '\\' :: v69 
                let v75 : (char list -> (char [])) = List.toArray
                let v76 : (char []) = v75 v72
                let v79 : string = $"parsing.none_of / unexpected char: '{v25}' / chars: %A{v76} / s: %A{struct (v2, v3, v4)}"
                US14_1(v79)
    match v82 with
    | US14_1(v94) -> (* Error *)
        US15_0(v0, v1, v2, v3, v4)
    | US14_0(v83, v84, v85, v86, v87) -> (* Ok *)
        let v88 : (char -> string) = _.ToString()
        let v89 : string = v88 v83
        let v92 : string = v0 + v89 
        method83(v92, v84, v85, v86, v87)
and method85 (v0 : char, v1 : int64) : bool =
    let v2 : bool = v1 >= 3L
    if v2 then
        false
    else
        let v3 : bool = v1 = 0L
        let v15 : US16 =
            if v3 then
                US16_0('\\')
            else
                let v5 : int64 = v1 - 1L
                let v6 : bool = v5 = 0L
                if v6 then
                    US16_0('`')
                else
                    let v8 : int64 = v5 - 1L
                    let v9 : bool = v8 = 0L
                    if v9 then
                        US16_0('"')
                    else
                        let v11 : int64 = v8 - 1L
                        US16_1
        let v19 : char =
            match v15 with
            | US16_1 -> (* None *)
                failwith<char> "Option does not have a value."
            | US16_0(v16) -> (* Some *)
                v16
        let v20 : bool = v0 = v19
        if v20 then
            true
        else
            let v21 : int64 = v1 + 1L
            method85(v0, v21)
and closure35 () struct (v0 : string, v1 : System.Text.StringBuilder, v2 : int32, v3 : int32) : US15 =
    let v4 : bool = "" = v0
    let v67 : US14 =
        if v4 then
            let v5 : string = $"parsing.p_char / unexpected end of input / s: %A{struct (v1, v2, v3)}"
            US14_1(v5)
        else
            let v7 : char = v0.[int 0]
            let v8 : bool = v7 = '\\'
            if v8 then
                let v9 : (string -> int32) = String.length
                let v10 : int32 = v9 v0
                let v11 : (int32 -> int32) = int32
                let v12 : int32 = v11 1
                let v13 : (int32 -> int32) = int32
                let v14 : int32 = v13 v10
                let v15 : string = v0.[int v12..int v14]
                let v16 : (char -> string) = _.ToString()
                let v17 : string = v16 v7
                let v20 : int32 = v17.Length
                let v21 : (char []) = Array.zeroCreate<char> (v20)
                let v22 : Mut6 = {l0 = 0} : Mut6
                while method48(v20, v22) do
                    let v24 : int32 = v22.l0
                    let v25 : char = v17.[int v24]
                    v21.[int v24] <- v25
                    let v26 : int32 = v24 + 1
                    v22.l0 <- v26
                    ()
                let v27 : char list = v21 |> Array.toList
                let v28 : ((char -> (UH0 -> UH0)) -> (char list -> (UH0 -> UH0))) = List.foldBack
                let v29 : (char -> (UH0 -> UH0)) = method70()
                let v30 : (char list -> (UH0 -> UH0)) = v28 v29
                let v31 : (UH0 -> UH0) = v30 v27
                let v32 : UH0 = UH0_0
                let v33 : UH0 = v31 v32
                let struct (v38 : System.Text.StringBuilder, v39 : int32, v40 : int32) = method71(v33, v1, v2, v3)
                US14_0(v7, v15, v38, v39, v40)
            else
                let v42 : (string -> int32) = String.length
                let v43 : int32 = v42 v0
                let v44 : string = "\n"
                let v45 : int32 = v0.IndexOf v44 
                let v46 : int32 = v45 - 1
                let v47 : bool = -2 = v46
                let v48 : int32 =
                    if v47 then
                        v43
                    else
                        v46
                let v49 : (int32 -> int32) = int32
                let v50 : int32 = v49 0
                let v51 : (int32 -> int32) = int32
                let v52 : int32 = v51 v48
                let v53 : string = v0.[int v50..int v52]
                let v54 : string = $"parsing.p_char / expected: '{'\\'}' / line: {v2} / col: {v3}
{v1}{v53}"
                let v55 : int32 = v3 - 1
                let v56 : (int32 -> (string -> string)) = String.replicate
                let v57 : (string -> string) = v56 v55
                let v58 : string = " "
                let v59 : string = v57 v58
                let v62 : string = "^"
                let v63 : string = v59 + v62 
                let v64 : string = $"{v54}
{v63}
"
                US14_1(v64)
    let v114 : US14 =
        match v67 with
        | US14_1(v111) -> (* Error *)
            US14_1(v111)
        | US14_0(v68, v69, v70, v71, v72) -> (* Ok *)
            let v73 : bool = "" = v69
            if v73 then
                let v74 : string = $"parsing.any_char / unexpected end of input / s: %A{struct (v70, v71, v72)}"
                US14_1(v74)
            else
                let v76 : char = v69.[int 0]
                let v77 : (string -> int32) = String.length
                let v78 : int32 = v77 v69
                let v79 : (int32 -> int32) = int32
                let v80 : int32 = v79 1
                let v81 : (int32 -> int32) = int32
                let v82 : int32 = v81 v78
                let v83 : string = v69.[int v80..int v82]
                let v84 : (char -> string) = _.ToString()
                let v85 : string = v84 v76
                let v88 : int32 = v85.Length
                let v89 : (char []) = Array.zeroCreate<char> (v88)
                let v90 : Mut6 = {l0 = 0} : Mut6
                while method48(v88, v90) do
                    let v92 : int32 = v90.l0
                    let v93 : char = v85.[int v92]
                    v89.[int v92] <- v93
                    let v94 : int32 = v92 + 1
                    v90.l0 <- v94
                    ()
                let v95 : char list = v89 |> Array.toList
                let v96 : ((char -> (UH0 -> UH0)) -> (char list -> (UH0 -> UH0))) = List.foldBack
                let v97 : (char -> (UH0 -> UH0)) = method70()
                let v98 : (char list -> (UH0 -> UH0)) = v96 v97
                let v99 : (UH0 -> UH0) = v98 v95
                let v100 : UH0 = UH0_0
                let v101 : UH0 = v99 v100
                let struct (v106 : System.Text.StringBuilder, v107 : int32, v108 : int32) = method71(v101, v70, v71, v72)
                US14_0(v76, v83, v106, v107, v108)
    match v114 with
    | US14_1(v122) -> (* Error *)
        US15_1(v122)
    | US14_0(v115, v116, v117, v118, v119) -> (* Ok *)
        let v120 : string = $"{'\\'}{v115}"
        US15_0(v120, v116, v117, v118, v119)
and closure36 () struct (v0 : string, v1 : System.Text.StringBuilder, v2 : int32, v3 : int32) : US15 =
    let v4 : bool = "" = v0
    let v67 : US14 =
        if v4 then
            let v5 : string = $"parsing.p_char / unexpected end of input / s: %A{struct (v1, v2, v3)}"
            US14_1(v5)
        else
            let v7 : char = v0.[int 0]
            let v8 : bool = v7 = '`'
            if v8 then
                let v9 : (string -> int32) = String.length
                let v10 : int32 = v9 v0
                let v11 : (int32 -> int32) = int32
                let v12 : int32 = v11 1
                let v13 : (int32 -> int32) = int32
                let v14 : int32 = v13 v10
                let v15 : string = v0.[int v12..int v14]
                let v16 : (char -> string) = _.ToString()
                let v17 : string = v16 v7
                let v20 : int32 = v17.Length
                let v21 : (char []) = Array.zeroCreate<char> (v20)
                let v22 : Mut6 = {l0 = 0} : Mut6
                while method48(v20, v22) do
                    let v24 : int32 = v22.l0
                    let v25 : char = v17.[int v24]
                    v21.[int v24] <- v25
                    let v26 : int32 = v24 + 1
                    v22.l0 <- v26
                    ()
                let v27 : char list = v21 |> Array.toList
                let v28 : ((char -> (UH0 -> UH0)) -> (char list -> (UH0 -> UH0))) = List.foldBack
                let v29 : (char -> (UH0 -> UH0)) = method70()
                let v30 : (char list -> (UH0 -> UH0)) = v28 v29
                let v31 : (UH0 -> UH0) = v30 v27
                let v32 : UH0 = UH0_0
                let v33 : UH0 = v31 v32
                let struct (v38 : System.Text.StringBuilder, v39 : int32, v40 : int32) = method71(v33, v1, v2, v3)
                US14_0(v7, v15, v38, v39, v40)
            else
                let v42 : (string -> int32) = String.length
                let v43 : int32 = v42 v0
                let v44 : string = "\n"
                let v45 : int32 = v0.IndexOf v44 
                let v46 : int32 = v45 - 1
                let v47 : bool = -2 = v46
                let v48 : int32 =
                    if v47 then
                        v43
                    else
                        v46
                let v49 : (int32 -> int32) = int32
                let v50 : int32 = v49 0
                let v51 : (int32 -> int32) = int32
                let v52 : int32 = v51 v48
                let v53 : string = v0.[int v50..int v52]
                let v54 : string = $"parsing.p_char / expected: '{'`'}' / line: {v2} / col: {v3}
{v1}{v53}"
                let v55 : int32 = v3 - 1
                let v56 : (int32 -> (string -> string)) = String.replicate
                let v57 : (string -> string) = v56 v55
                let v58 : string = " "
                let v59 : string = v57 v58
                let v62 : string = "^"
                let v63 : string = v59 + v62 
                let v64 : string = $"{v54}
{v63}
"
                US14_1(v64)
    let v114 : US14 =
        match v67 with
        | US14_1(v111) -> (* Error *)
            US14_1(v111)
        | US14_0(v68, v69, v70, v71, v72) -> (* Ok *)
            let v73 : bool = "" = v69
            if v73 then
                let v74 : string = $"parsing.any_char / unexpected end of input / s: %A{struct (v70, v71, v72)}"
                US14_1(v74)
            else
                let v76 : char = v69.[int 0]
                let v77 : (string -> int32) = String.length
                let v78 : int32 = v77 v69
                let v79 : (int32 -> int32) = int32
                let v80 : int32 = v79 1
                let v81 : (int32 -> int32) = int32
                let v82 : int32 = v81 v78
                let v83 : string = v69.[int v80..int v82]
                let v84 : (char -> string) = _.ToString()
                let v85 : string = v84 v76
                let v88 : int32 = v85.Length
                let v89 : (char []) = Array.zeroCreate<char> (v88)
                let v90 : Mut6 = {l0 = 0} : Mut6
                while method48(v88, v90) do
                    let v92 : int32 = v90.l0
                    let v93 : char = v85.[int v92]
                    v89.[int v92] <- v93
                    let v94 : int32 = v92 + 1
                    v90.l0 <- v94
                    ()
                let v95 : char list = v89 |> Array.toList
                let v96 : ((char -> (UH0 -> UH0)) -> (char list -> (UH0 -> UH0))) = List.foldBack
                let v97 : (char -> (UH0 -> UH0)) = method70()
                let v98 : (char list -> (UH0 -> UH0)) = v96 v97
                let v99 : (UH0 -> UH0) = v98 v95
                let v100 : UH0 = UH0_0
                let v101 : UH0 = v99 v100
                let struct (v106 : System.Text.StringBuilder, v107 : int32, v108 : int32) = method71(v101, v70, v71, v72)
                US14_0(v76, v83, v106, v107, v108)
    match v114 with
    | US14_1(v122) -> (* Error *)
        US15_1(v122)
    | US14_0(v115, v116, v117, v118, v119) -> (* Ok *)
        let v120 : string = $"{'`'}{v115}"
        US15_0(v120, v116, v117, v118, v119)
and method86 (v0 : string, v1 : System.Text.StringBuilder, v2 : int32, v3 : int32, v4 : UH3) : US15 =
    match v4 with
    | UH3_1(v7, v8) -> (* Cons *)
        let v9 : US15 = v7 struct (v0, v1, v2, v3)
        match v9 with
        | US15_1(v15) -> (* Error *)
            method86(v0, v1, v2, v3, v8)
        | US15_0(v10, v11, v12, v13, v14) -> (* Ok *)
            v9
    | UH3_0 -> (* Nil *)
        let v5 : string = "choice / no parsers succeeded"
        US15_1(v5)
and method87 (v0 : UH2, v1 : UH2) : UH2 =
    match v0 with
    | UH2_1(v2, v3) -> (* Cons *)
        let v4 : UH2 = UH2_1(v2, v1)
        method87(v3, v4)
    | UH2_0 -> (* Nil *)
        v1
and method84 (v0 : UH2, v1 : string, v2 : System.Text.StringBuilder, v3 : int32, v4 : int32) : US22 =
    let v5 : bool = "" = v1
    let v76 : US14 =
        if v5 then
            let v6 : char list = []
            let v7 : char list = '"' :: v6 
            let v10 : char list = '`' :: v7 
            let v13 : char list = '\\' :: v10 
            let v16 : (char list -> (char [])) = List.toArray
            let v17 : (char []) = v16 v13
            let v20 : string = $"parsing.none_of / unexpected end of input / chars: %A{v17} / s: %A{struct (v2, v3, v4)}"
            US14_1(v20)
        else
            let v22 : char = v1.[int 0]
            let v23 : (string -> int32) = String.length
            let v24 : int32 = v23 v1
            let v25 : (int32 -> int32) = int32
            let v26 : int32 = v25 1
            let v27 : (int32 -> int32) = int32
            let v28 : int32 = v27 v24
            let v29 : string = v1.[int v26..int v28]
            let v30 : int64 = 0L
            let v31 : bool = method85(v22, v30)
            let v32 : bool = v31 = false
            if v32 then
                let v33 : (char -> string) = _.ToString()
                let v34 : string = v33 v22
                let v37 : int32 = v34.Length
                let v38 : (char []) = Array.zeroCreate<char> (v37)
                let v39 : Mut6 = {l0 = 0} : Mut6
                while method48(v37, v39) do
                    let v41 : int32 = v39.l0
                    let v42 : char = v34.[int v41]
                    v38.[int v41] <- v42
                    let v43 : int32 = v41 + 1
                    v39.l0 <- v43
                    ()
                let v44 : char list = v38 |> Array.toList
                let v45 : ((char -> (UH0 -> UH0)) -> (char list -> (UH0 -> UH0))) = List.foldBack
                let v46 : (char -> (UH0 -> UH0)) = method70()
                let v47 : (char list -> (UH0 -> UH0)) = v45 v46
                let v48 : (UH0 -> UH0) = v47 v44
                let v49 : UH0 = UH0_0
                let v50 : UH0 = v48 v49
                let struct (v55 : System.Text.StringBuilder, v56 : int32, v57 : int32) = method71(v50, v2, v3, v4)
                US14_0(v22, v29, v55, v56, v57)
            else
                let v59 : char list = []
                let v60 : char list = '"' :: v59 
                let v63 : char list = '`' :: v60 
                let v66 : char list = '\\' :: v63 
                let v69 : (char list -> (char [])) = List.toArray
                let v70 : (char []) = v69 v66
                let v73 : string = $"parsing.none_of / unexpected char: '{v22}' / chars: %A{v70} / s: %A{struct (v2, v3, v4)}"
                US14_1(v73)
    let v90 : US15 =
        match v76 with
        | US14_1(v87) -> (* Error *)
            US15_1(v87)
        | US14_0(v77, v78, v79, v80, v81) -> (* Ok *)
            let v82 : (char -> string) = _.ToString()
            let v83 : string = v82 v77
            US15_0(v83, v78, v79, v80, v81)
    let v104 : US15 =
        match v90 with
        | US15_1(v96) -> (* Error *)
            let v97 : (struct (string * System.Text.StringBuilder * int32 * int32) -> US15) = closure35()
            let v98 : (struct (string * System.Text.StringBuilder * int32 * int32) -> US15) = closure36()
            let v99 : UH3 = UH3_0
            let v100 : UH3 = UH3_1(v98, v99)
            let v101 : UH3 = UH3_1(v97, v100)
            method86(v1, v2, v3, v4, v101)
        | US15_0(v91, v92, v93, v94, v95) -> (* Ok *)
            v90
    match v104 with
    | US15_1(v112) -> (* Error *)
        let v113 : UH2 = UH2_0
        let v114 : UH2 = method87(v0, v113)
        US22_0(v114, v1, v2, v3, v4)
    | US15_0(v105, v106, v107, v108, v109) -> (* Ok *)
        let v110 : UH2 = UH2_1(v105, v0)
        method84(v110, v106, v107, v108, v109)
and method88 (v0 : UH2, v1 : string list) : string list =
    match v0 with
    | UH2_1(v2, v3) -> (* Cons *)
        let v4 : string list = method88(v3, v1)
        let v5 : string list = v2 :: v4 
        v5
    | UH2_0 -> (* Nil *)
        v1
and method89 (v0 : UH2, v1 : string, v2 : System.Text.StringBuilder, v3 : int32, v4 : int32) : US22 =
    let v5 : bool = "" = v1
    let v76 : US14 =
        if v5 then
            let v6 : char list = []
            let v7 : char list = '"' :: v6 
            let v10 : char list = '`' :: v7 
            let v13 : char list = '\\' :: v10 
            let v16 : (char list -> (char [])) = List.toArray
            let v17 : (char []) = v16 v13
            let v20 : string = $"parsing.none_of / unexpected end of input / chars: %A{v17} / s: %A{struct (v2, v3, v4)}"
            US14_1(v20)
        else
            let v22 : char = v1.[int 0]
            let v23 : (string -> int32) = String.length
            let v24 : int32 = v23 v1
            let v25 : (int32 -> int32) = int32
            let v26 : int32 = v25 1
            let v27 : (int32 -> int32) = int32
            let v28 : int32 = v27 v24
            let v29 : string = v1.[int v26..int v28]
            let v30 : int64 = 0L
            let v31 : bool = method85(v22, v30)
            let v32 : bool = v31 = false
            if v32 then
                let v33 : (char -> string) = _.ToString()
                let v34 : string = v33 v22
                let v37 : int32 = v34.Length
                let v38 : (char []) = Array.zeroCreate<char> (v37)
                let v39 : Mut6 = {l0 = 0} : Mut6
                while method48(v37, v39) do
                    let v41 : int32 = v39.l0
                    let v42 : char = v34.[int v41]
                    v38.[int v41] <- v42
                    let v43 : int32 = v41 + 1
                    v39.l0 <- v43
                    ()
                let v44 : char list = v38 |> Array.toList
                let v45 : ((char -> (UH0 -> UH0)) -> (char list -> (UH0 -> UH0))) = List.foldBack
                let v46 : (char -> (UH0 -> UH0)) = method70()
                let v47 : (char list -> (UH0 -> UH0)) = v45 v46
                let v48 : (UH0 -> UH0) = v47 v44
                let v49 : UH0 = UH0_0
                let v50 : UH0 = v48 v49
                let struct (v55 : System.Text.StringBuilder, v56 : int32, v57 : int32) = method71(v50, v2, v3, v4)
                US14_0(v22, v29, v55, v56, v57)
            else
                let v59 : char list = []
                let v60 : char list = '"' :: v59 
                let v63 : char list = '`' :: v60 
                let v66 : char list = '\\' :: v63 
                let v69 : (char list -> (char [])) = List.toArray
                let v70 : (char []) = v69 v66
                let v73 : string = $"parsing.none_of / unexpected char: '{v22}' / chars: %A{v70} / s: %A{struct (v2, v3, v4)}"
                US14_1(v73)
    let v90 : US15 =
        match v76 with
        | US14_1(v87) -> (* Error *)
            US15_1(v87)
        | US14_0(v77, v78, v79, v80, v81) -> (* Ok *)
            let v82 : (char -> string) = _.ToString()
            let v83 : string = v82 v77
            US15_0(v83, v78, v79, v80, v81)
    match v90 with
    | US15_1(v98) -> (* Error *)
        let v99 : UH2 = UH2_0
        let v100 : UH2 = method87(v0, v99)
        US22_0(v100, v1, v2, v3, v4)
    | US15_0(v91, v92, v93, v94, v95) -> (* Ok *)
        let v96 : UH2 = UH2_1(v91, v0)
        method89(v96, v92, v93, v94, v95)
and method90 (v0 : string, v1 : int32) : int32 =
    let v2 : int32 = v0.Length
    let v3 : bool = v1 >= v2
    if v3 then
        v1
    else
        let v4 : char = v0.[int v1]
        let v5 : bool = v4 = ' '
        if v5 then
            let v6 : int32 = v1 + 1
            method90(v0, v6)
        else
            v1
and method81 (v0 : UH2, v1 : string, v2 : System.Text.StringBuilder, v3 : int32, v4 : int32) : US22 =
    let v5 : bool = "" = v1
    let v82 : US14 =
        if v5 then
            let v6 : char list = []
            let v7 : char list = ' ' :: v6 
            let v10 : char list = '"' :: v7 
            let v13 : char list = '`' :: v10 
            let v16 : char list = '\\' :: v13 
            let v19 : (char list -> (char [])) = List.toArray
            let v20 : (char []) = v19 v16
            let v23 : string = $"parsing.none_of / unexpected end of input / chars: %A{v20} / s: %A{struct (v2, v3, v4)}"
            US14_1(v23)
        else
            let v25 : char = v1.[int 0]
            let v26 : (string -> int32) = String.length
            let v27 : int32 = v26 v1
            let v28 : (int32 -> int32) = int32
            let v29 : int32 = v28 1
            let v30 : (int32 -> int32) = int32
            let v31 : int32 = v30 v27
            let v32 : string = v1.[int v29..int v31]
            let v33 : int64 = 0L
            let v34 : bool = method82(v25, v33)
            let v35 : bool = v34 = false
            if v35 then
                let v36 : (char -> string) = _.ToString()
                let v37 : string = v36 v25
                let v40 : int32 = v37.Length
                let v41 : (char []) = Array.zeroCreate<char> (v40)
                let v42 : Mut6 = {l0 = 0} : Mut6
                while method48(v40, v42) do
                    let v44 : int32 = v42.l0
                    let v45 : char = v37.[int v44]
                    v41.[int v44] <- v45
                    let v46 : int32 = v44 + 1
                    v42.l0 <- v46
                    ()
                let v47 : char list = v41 |> Array.toList
                let v48 : ((char -> (UH0 -> UH0)) -> (char list -> (UH0 -> UH0))) = List.foldBack
                let v49 : (char -> (UH0 -> UH0)) = method70()
                let v50 : (char list -> (UH0 -> UH0)) = v48 v49
                let v51 : (UH0 -> UH0) = v50 v47
                let v52 : UH0 = UH0_0
                let v53 : UH0 = v51 v52
                let struct (v58 : System.Text.StringBuilder, v59 : int32, v60 : int32) = method71(v53, v2, v3, v4)
                US14_0(v25, v32, v58, v59, v60)
            else
                let v62 : char list = []
                let v63 : char list = ' ' :: v62 
                let v66 : char list = '"' :: v63 
                let v69 : char list = '`' :: v66 
                let v72 : char list = '\\' :: v69 
                let v75 : (char list -> (char [])) = List.toArray
                let v76 : (char []) = v75 v72
                let v79 : string = $"parsing.none_of / unexpected char: '{v25}' / chars: %A{v76} / s: %A{struct (v2, v3, v4)}"
                US14_1(v79)
    let v96 : US15 =
        match v82 with
        | US14_1(v83) -> (* Error *)
            US15_1(v83)
        | US14_0(v85, v86, v87, v88, v89) -> (* Ok *)
            let v90 : (char -> string) = _.ToString()
            let v91 : string = v90 v85
            method83(v91, v86, v87, v88, v89)
    let v341 : US15 =
        match v96 with
        | US15_1(v102) -> (* Error *)
            let v165 : US14 =
                if v5 then
                    let v103 : string = $"parsing.p_char / unexpected end of input / s: %A{struct (v2, v3, v4)}"
                    US14_1(v103)
                else
                    let v105 : char = v1.[int 0]
                    let v106 : bool = v105 = '"'
                    if v106 then
                        let v107 : (string -> int32) = String.length
                        let v108 : int32 = v107 v1
                        let v109 : (int32 -> int32) = int32
                        let v110 : int32 = v109 1
                        let v111 : (int32 -> int32) = int32
                        let v112 : int32 = v111 v108
                        let v113 : string = v1.[int v110..int v112]
                        let v114 : (char -> string) = _.ToString()
                        let v115 : string = v114 v105
                        let v118 : int32 = v115.Length
                        let v119 : (char []) = Array.zeroCreate<char> (v118)
                        let v120 : Mut6 = {l0 = 0} : Mut6
                        while method48(v118, v120) do
                            let v122 : int32 = v120.l0
                            let v123 : char = v115.[int v122]
                            v119.[int v122] <- v123
                            let v124 : int32 = v122 + 1
                            v120.l0 <- v124
                            ()
                        let v125 : char list = v119 |> Array.toList
                        let v126 : ((char -> (UH0 -> UH0)) -> (char list -> (UH0 -> UH0))) = List.foldBack
                        let v127 : (char -> (UH0 -> UH0)) = method70()
                        let v128 : (char list -> (UH0 -> UH0)) = v126 v127
                        let v129 : (UH0 -> UH0) = v128 v125
                        let v130 : UH0 = UH0_0
                        let v131 : UH0 = v129 v130
                        let struct (v136 : System.Text.StringBuilder, v137 : int32, v138 : int32) = method71(v131, v2, v3, v4)
                        US14_0(v105, v113, v136, v137, v138)
                    else
                        let v140 : (string -> int32) = String.length
                        let v141 : int32 = v140 v1
                        let v142 : string = "\n"
                        let v143 : int32 = v1.IndexOf v142 
                        let v144 : int32 = v143 - 1
                        let v145 : bool = -2 = v144
                        let v146 : int32 =
                            if v145 then
                                v141
                            else
                                v144
                        let v147 : (int32 -> int32) = int32
                        let v148 : int32 = v147 0
                        let v149 : (int32 -> int32) = int32
                        let v150 : int32 = v149 v146
                        let v151 : string = v1.[int v148..int v150]
                        let v152 : string = $"parsing.p_char / expected: '{'"'}' / line: {v3} / col: {v4}
{v2}{v151}"
                        let v153 : int32 = v4 - 1
                        let v154 : (int32 -> (string -> string)) = String.replicate
                        let v155 : (string -> string) = v154 v153
                        let v156 : string = " "
                        let v157 : string = v155 v156
                        let v160 : string = "^"
                        let v161 : string = v157 + v160 
                        let v162 : string = $"{v152}
{v161}
"
                        US14_1(v162)
            let v282 : US15 =
                match v165 with
                | US14_1(v279) -> (* Error *)
                    US15_1(v279)
                | US14_0(v166, v167, v168, v169, v170) -> (* Ok *)
                    let v171 : UH2 = UH2_0
                    let v172 : US22 = method84(v171, v167, v168, v169, v170)
                    let v193 : US15 =
                        match v172 with
                        | US22_1(v190) -> (* Error *)
                            US15_1(v190)
                        | US22_0(v173, v174, v175, v176, v177) -> (* Ok *)
                            let v178 : string list = []
                            let v179 : string list = method88(v173, v178)
                            let v180 : string seq = seq { for i = 0 to v179.Length - 1 do yield v179.[i] }
                            let v183 : (string -> (string seq -> string)) = String.concat
                            let v184 : string = ""
                            let v185 : (string seq -> string) = v183 v184
                            let v186 : string = v185 v180
                            US15_0(v186, v174, v175, v176, v177)
                    match v193 with
                    | US15_1(v274) -> (* Error *)
                        let v275 : string = "between / expected content"
                        US15_1(v275)
                    | US15_0(v194, v195, v196, v197, v198) -> (* Ok *)
                        let v199 : bool = "" = v195
                        let v262 : US14 =
                            if v199 then
                                let v200 : string = $"parsing.p_char / unexpected end of input / s: %A{struct (v196, v197, v198)}"
                                US14_1(v200)
                            else
                                let v202 : char = v195.[int 0]
                                let v203 : bool = v202 = '"'
                                if v203 then
                                    let v204 : (string -> int32) = String.length
                                    let v205 : int32 = v204 v195
                                    let v206 : (int32 -> int32) = int32
                                    let v207 : int32 = v206 1
                                    let v208 : (int32 -> int32) = int32
                                    let v209 : int32 = v208 v205
                                    let v210 : string = v195.[int v207..int v209]
                                    let v211 : (char -> string) = _.ToString()
                                    let v212 : string = v211 v202
                                    let v215 : int32 = v212.Length
                                    let v216 : (char []) = Array.zeroCreate<char> (v215)
                                    let v217 : Mut6 = {l0 = 0} : Mut6
                                    while method48(v215, v217) do
                                        let v219 : int32 = v217.l0
                                        let v220 : char = v212.[int v219]
                                        v216.[int v219] <- v220
                                        let v221 : int32 = v219 + 1
                                        v217.l0 <- v221
                                        ()
                                    let v222 : char list = v216 |> Array.toList
                                    let v223 : ((char -> (UH0 -> UH0)) -> (char list -> (UH0 -> UH0))) = List.foldBack
                                    let v224 : (char -> (UH0 -> UH0)) = method70()
                                    let v225 : (char list -> (UH0 -> UH0)) = v223 v224
                                    let v226 : (UH0 -> UH0) = v225 v222
                                    let v227 : UH0 = UH0_0
                                    let v228 : UH0 = v226 v227
                                    let struct (v233 : System.Text.StringBuilder, v234 : int32, v235 : int32) = method71(v228, v196, v197, v198)
                                    US14_0(v202, v210, v233, v234, v235)
                                else
                                    let v237 : (string -> int32) = String.length
                                    let v238 : int32 = v237 v195
                                    let v239 : string = "\n"
                                    let v240 : int32 = v195.IndexOf v239 
                                    let v241 : int32 = v240 - 1
                                    let v242 : bool = -2 = v241
                                    let v243 : int32 =
                                        if v242 then
                                            v238
                                        else
                                            v241
                                    let v244 : (int32 -> int32) = int32
                                    let v245 : int32 = v244 0
                                    let v246 : (int32 -> int32) = int32
                                    let v247 : int32 = v246 v243
                                    let v248 : string = v195.[int v245..int v247]
                                    let v249 : string = $"parsing.p_char / expected: '{'"'}' / line: {v197} / col: {v198}
{v196}{v248}"
                                    let v250 : int32 = v198 - 1
                                    let v251 : (int32 -> (string -> string)) = String.replicate
                                    let v252 : (string -> string) = v251 v250
                                    let v253 : string = " "
                                    let v254 : string = v252 v253
                                    let v257 : string = "^"
                                    let v258 : string = v254 + v257 
                                    let v259 : string = $"{v249}
{v258}
"
                                    US14_1(v259)
                        match v262 with
                        | US14_1(v269) -> (* Error *)
                            let v270 : string = $"between / expected closing delimiter / e: %A{v269} / input: %A{struct (v1, v2, v3, v4)} / rest1: %A{struct (v167, v168, v169, v170)} / rest2: %A{struct (v195, v196, v197, v198)}"
                            US15_1(v270)
                        | US14_0(v263, v264, v265, v266, v267) -> (* Ok *)
                            US15_0(v194, v264, v265, v266, v267)
            match v282 with
            | US15_1(v288) -> (* Error *)
                let v289 : (struct (string * System.Text.StringBuilder * int32 * int32) -> US15) = closure35()
                let v290 : (struct (string * System.Text.StringBuilder * int32 * int32) -> US15) = closure36()
                let v291 : UH3 = UH3_0
                let v292 : UH3 = UH3_1(v290, v291)
                let v293 : UH3 = UH3_1(v289, v292)
                let v294 : US15 = method86(v1, v2, v3, v4, v293)
                let v305 : US15 =
                    match v294 with
                    | US15_1(v302) -> (* Error *)
                        US15_1(v302)
                    | US15_0(v295, v296, v297, v298, v299) -> (* Ok *)
                        let v300 : string = ""
                        US15_0(v300, v296, v297, v298, v299)
                let v316 : US22 =
                    match v305 with
                    | US15_1(v313) -> (* Error *)
                        US22_1(v313)
                    | US15_0(v306, v307, v308, v309, v310) -> (* Ok *)
                        let v311 : UH2 = UH2_0
                        method89(v311, v307, v308, v309, v310)
                match v316 with
                | US22_1(v334) -> (* Error *)
                    US15_1(v334)
                | US22_0(v317, v318, v319, v320, v321) -> (* Ok *)
                    let v322 : string list = []
                    let v323 : string list = method88(v317, v322)
                    let v324 : string seq = seq { for i = 0 to v323.Length - 1 do yield v323.[i] }
                    let v327 : (string -> (string seq -> string)) = String.concat
                    let v328 : string = ""
                    let v329 : (string seq -> string) = v327 v328
                    let v330 : string = v329 v324
                    US15_0(v330, v318, v319, v320, v321)
            | US15_0(v283, v284, v285, v286, v287) -> (* Ok *)
                v282
        | US15_0(v97, v98, v99, v100, v101) -> (* Ok *)
            v96
    match v341 with
    | US15_1(v342) -> (* Error *)
        let v343 : UH2 = UH2_0
        let v344 : UH2 = method87(v0, v343)
        US22_0(v344, v1, v2, v3, v4)
    | US15_0(v346, v347, v348, v349, v350) -> (* Ok *)
        let v351 : int32 = 0
        let v352 : int32 = method90(v347, v351)
        let v353 : bool = 0 = v352
        let v364 : US17 =
            if v353 then
                let v354 : string = "spaces1 / expected at least one space"
                US17_1(v354)
            else
                let v356 : (string -> int32) = String.length
                let v357 : int32 = v356 v347
                let v358 : (int32 -> int32) = int32
                let v359 : int32 = v358 v352
                let v360 : (int32 -> int32) = int32
                let v361 : int32 = v360 v357
                let v362 : string = v347.[int v359..int v361]
                US17_0(v362, v348, v349, v350)
        match v364 with
        | US17_1(v365) -> (* Error *)
            let v366 : UH2 = UH2_0
            let v367 : UH2 = UH2_1(v346, v366)
            let v368 : UH2 = method87(v0, v367)
            US22_0(v368, v347, v348, v349, v350)
        | US17_0(v370, v371, v372, v373) -> (* Ok *)
            let v374 : UH2 = UH2_1(v346, v0)
            method81(v374, v370, v371, v372, v373)
and method80 (v0 : string) : US21 =
    let mutable _v0 = None
    #if !FABLE_COMPILER && !WASM && !CONTRACT
    let v1 : (string -> string option) = Option.ofObj
    let v2 : string option = v1 v0
    v2 
    #else
    Some v0 
    #endif
    |> fun x -> _v0 <- Some x
    let v3 : string option = match _v0 with Some x -> x | None -> failwith "optionm'.of_obj / _v0=None"
    let v6 : string = ""
    let v7 : string = v3 |> Option.defaultValue v6 
    let v10 : (string -> System.Text.StringBuilder) = System.Text.StringBuilder 
    let v11 : System.Text.StringBuilder = v10 v6
    let v12 : UH2 = UH2_0
    let v13 : int32 = 1
    let v14 : int32 = 1
    let v15 : US22 = method81(v12, v7, v11, v13, v14)
    match v15 with
    | US22_1(v28) -> (* Error *)
        US21_1(v28)
    | US22_0(v16, v17, v18, v19, v20) -> (* Ok *)
        let v21 : string list = []
        let v22 : string list = method88(v16, v21)
        let v23 : (string list -> (string [])) = List.toArray
        let v24 : (string []) = v23 v22
        US21_0(v24)
and method92 (v0 : string, v1 : string, v2 : string, v3 : System.Threading.CancellationToken option, v4 : (struct (string * string) []), v5 : (struct (int32 * string * bool) -> Async<unit>) option, v6 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit) option, v7 : bool, v8 : string option) : string =
    let v9 : string = method14()
    let v10 : Mut3 = {l0 = v9} : Mut3
    let v11 : string = "{ "
    let v12 : string = $"{v11}"
    let v15 : unit = ()
    let v16 : (unit -> unit) = closure8(v10, v12)
    let v17 : unit = (fun () -> v16 (); v15) ()
    let v20 : string = "file_name"
    let v21 : string = $"{v20}"
    let v24 : unit = ()
    let v25 : (unit -> unit) = closure8(v10, v21)
    let v26 : unit = (fun () -> v25 (); v24) ()
    let v29 : string = " = "
    let v30 : string = $"{v29}"
    let v33 : unit = ()
    let v34 : (unit -> unit) = closure8(v10, v30)
    let v35 : unit = (fun () -> v34 (); v33) ()
    let v38 : string = $"{v0}"
    let v41 : unit = ()
    let v42 : (unit -> unit) = closure8(v10, v38)
    let v43 : unit = (fun () -> v42 (); v41) ()
    let v46 : string = "; "
    let v47 : string = $"{v46}"
    let v50 : unit = ()
    let v51 : (unit -> unit) = closure8(v10, v47)
    let v52 : unit = (fun () -> v51 (); v50) ()
    let v55 : string = "arguments"
    let v56 : string = $"{v55}"
    let v59 : unit = ()
    let v60 : (unit -> unit) = closure8(v10, v56)
    let v61 : unit = (fun () -> v60 (); v59) ()
    let v64 : string = $"{v29}"
    let v67 : unit = ()
    let v68 : (unit -> unit) = closure8(v10, v64)
    let v69 : unit = (fun () -> v68 (); v67) ()
    let v72 : string = $"{v1}"
    let v75 : unit = ()
    let v76 : (unit -> unit) = closure8(v10, v72)
    let v77 : unit = (fun () -> v76 (); v75) ()
    let v80 : string = $"{v46}"
    let v83 : unit = ()
    let v84 : (unit -> unit) = closure8(v10, v80)
    let v85 : unit = (fun () -> v84 (); v83) ()
    let v88 : string = "options"
    let v89 : string = $"{v88}"
    let v92 : unit = ()
    let v93 : (unit -> unit) = closure8(v10, v89)
    let v94 : unit = (fun () -> v93 (); v92) ()
    let v97 : string = $"{v29}"
    let v100 : unit = ()
    let v101 : (unit -> unit) = closure8(v10, v97)
    let v102 : unit = (fun () -> v101 (); v100) ()
    let v105 : string = $"{v11}"
    let v108 : unit = ()
    let v109 : (unit -> unit) = closure8(v10, v105)
    let v110 : unit = (fun () -> v109 (); v108) ()
    let v113 : string = "command"
    let v114 : string = $"{v113}"
    let v117 : unit = ()
    let v118 : (unit -> unit) = closure8(v10, v114)
    let v119 : unit = (fun () -> v118 (); v117) ()
    let v122 : string = $"{v29}"
    let v125 : unit = ()
    let v126 : (unit -> unit) = closure8(v10, v122)
    let v127 : unit = (fun () -> v126 (); v125) ()
    let v130 : string = $"{v2}"
    let v133 : unit = ()
    let v134 : (unit -> unit) = closure8(v10, v130)
    let v135 : unit = (fun () -> v134 (); v133) ()
    let v138 : string = $"{v46}"
    let v141 : unit = ()
    let v142 : (unit -> unit) = closure8(v10, v138)
    let v143 : unit = (fun () -> v142 (); v141) ()
    let v146 : string = "cancellation_token"
    let v147 : string = $"{v146}"
    let v150 : unit = ()
    let v151 : (unit -> unit) = closure8(v10, v147)
    let v152 : unit = (fun () -> v151 (); v150) ()
    let v155 : string = $"{v29}"
    let v158 : unit = ()
    let v159 : (unit -> unit) = closure8(v10, v155)
    let v160 : unit = (fun () -> v159 (); v158) ()
    let v163 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v164 : string = "format!(\"{:#?}\", $0)"
    let v165 : std_string_String = Fable.Core.RustInterop.emitRustExpr v3 v164 
    let v166 : string = "fable_library_rust::String_::fromString($0)"
    let v167 : string = Fable.Core.RustInterop.emitRustExpr v165 v166 
    let _v163 = v167 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v168 : string = "format!(\"{:#?}\", $0)"
    let v169 : std_string_String = Fable.Core.RustInterop.emitRustExpr v3 v168 
    let v170 : string = "fable_library_rust::String_::fromString($0)"
    let v171 : string = Fable.Core.RustInterop.emitRustExpr v169 v170 
    let _v163 = v171 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v172 : string = "format!(\"{:#?}\", $0)"
    let v173 : std_string_String = Fable.Core.RustInterop.emitRustExpr v3 v172 
    let v174 : string = "fable_library_rust::String_::fromString($0)"
    let v175 : string = Fable.Core.RustInterop.emitRustExpr v173 v174 
    let _v163 = v175 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v176 : string = $"%A{v3}"
    let _v163 = v176 
    #endif
#if FABLE_COMPILER_PYTHON
    let v179 : string = $"%A{v3}"
    let _v163 = v179 
    #endif
#else
    let v182 : string = $"%A{v3}"
    let _v163 = v182 
    #endif
    let v185 : string = _v163 
    let v190 : string = $"{v185}"
    let v193 : unit = ()
    let v194 : (unit -> unit) = closure8(v10, v190)
    let v195 : unit = (fun () -> v194 (); v193) ()
    let v198 : string = $"{v46}"
    let v201 : unit = ()
    let v202 : (unit -> unit) = closure8(v10, v198)
    let v203 : unit = (fun () -> v202 (); v201) ()
    let v206 : string = "environment_variables"
    let v207 : string = $"{v206}"
    let v210 : unit = ()
    let v211 : (unit -> unit) = closure8(v10, v207)
    let v212 : unit = (fun () -> v211 (); v210) ()
    let v215 : string = $"{v29}"
    let v218 : unit = ()
    let v219 : (unit -> unit) = closure8(v10, v215)
    let v220 : unit = (fun () -> v219 (); v218) ()
    let v223 : string = $"%A{v4}"
    let v226 : string = $"{v223}"
    let v229 : unit = ()
    let v230 : (unit -> unit) = closure8(v10, v226)
    let v231 : unit = (fun () -> v230 (); v229) ()
    let v234 : string = $"{v46}"
    let v237 : unit = ()
    let v238 : (unit -> unit) = closure8(v10, v234)
    let v239 : unit = (fun () -> v238 (); v237) ()
    let v242 : string = "on_line"
    let v243 : string = $"{v242}"
    let v246 : unit = ()
    let v247 : (unit -> unit) = closure8(v10, v243)
    let v248 : unit = (fun () -> v247 (); v246) ()
    let v251 : string = $"{v29}"
    let v254 : unit = ()
    let v255 : (unit -> unit) = closure8(v10, v251)
    let v256 : unit = (fun () -> v255 (); v254) ()
    let v259 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v260 : string = "format!(\"{:#?}\", $0)"
    let v261 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5 v260 
    let v262 : string = "fable_library_rust::String_::fromString($0)"
    let v263 : string = Fable.Core.RustInterop.emitRustExpr v261 v262 
    let _v259 = v263 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v264 : string = "format!(\"{:#?}\", $0)"
    let v265 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5 v264 
    let v266 : string = "fable_library_rust::String_::fromString($0)"
    let v267 : string = Fable.Core.RustInterop.emitRustExpr v265 v266 
    let _v259 = v267 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v268 : string = "format!(\"{:#?}\", $0)"
    let v269 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5 v268 
    let v270 : string = "fable_library_rust::String_::fromString($0)"
    let v271 : string = Fable.Core.RustInterop.emitRustExpr v269 v270 
    let _v259 = v271 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v272 : string = $"%A{v5}"
    let _v259 = v272 
    #endif
#if FABLE_COMPILER_PYTHON
    let v275 : string = $"%A{v5}"
    let _v259 = v275 
    #endif
#else
    let v278 : string = $"%A{v5}"
    let _v259 = v278 
    #endif
    let v281 : string = _v259 
    let v286 : string = $"{v281}"
    let v289 : unit = ()
    let v290 : (unit -> unit) = closure8(v10, v286)
    let v291 : unit = (fun () -> v290 (); v289) ()
    let v294 : string = $"{v46}"
    let v297 : unit = ()
    let v298 : (unit -> unit) = closure8(v10, v294)
    let v299 : unit = (fun () -> v298 (); v297) ()
    let v302 : string = "stdin"
    let v303 : string = $"{v302}"
    let v306 : unit = ()
    let v307 : (unit -> unit) = closure8(v10, v303)
    let v308 : unit = (fun () -> v307 (); v306) ()
    let v311 : string = $"{v29}"
    let v314 : unit = ()
    let v315 : (unit -> unit) = closure8(v10, v311)
    let v316 : unit = (fun () -> v315 (); v314) ()
    let v319 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v320 : string = "format!(\"{:#?}\", $0)"
    let v321 : std_string_String = Fable.Core.RustInterop.emitRustExpr v6 v320 
    let v322 : string = "fable_library_rust::String_::fromString($0)"
    let v323 : string = Fable.Core.RustInterop.emitRustExpr v321 v322 
    let _v319 = v323 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v324 : string = "format!(\"{:#?}\", $0)"
    let v325 : std_string_String = Fable.Core.RustInterop.emitRustExpr v6 v324 
    let v326 : string = "fable_library_rust::String_::fromString($0)"
    let v327 : string = Fable.Core.RustInterop.emitRustExpr v325 v326 
    let _v319 = v327 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v328 : string = "format!(\"{:#?}\", $0)"
    let v329 : std_string_String = Fable.Core.RustInterop.emitRustExpr v6 v328 
    let v330 : string = "fable_library_rust::String_::fromString($0)"
    let v331 : string = Fable.Core.RustInterop.emitRustExpr v329 v330 
    let _v319 = v331 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v332 : string = $"%A{v6}"
    let _v319 = v332 
    #endif
#if FABLE_COMPILER_PYTHON
    let v335 : string = $"%A{v6}"
    let _v319 = v335 
    #endif
#else
    let v338 : string = $"%A{v6}"
    let _v319 = v338 
    #endif
    let v341 : string = _v319 
    let v346 : string = $"{v341}"
    let v349 : unit = ()
    let v350 : (unit -> unit) = closure8(v10, v346)
    let v351 : unit = (fun () -> v350 (); v349) ()
    let v354 : string = $"{v46}"
    let v357 : unit = ()
    let v358 : (unit -> unit) = closure8(v10, v354)
    let v359 : unit = (fun () -> v358 (); v357) ()
    let v362 : string = "trace"
    let v363 : string = $"{v362}"
    let v366 : unit = ()
    let v367 : (unit -> unit) = closure8(v10, v363)
    let v368 : unit = (fun () -> v367 (); v366) ()
    let v371 : string = $"{v29}"
    let v374 : unit = ()
    let v375 : (unit -> unit) = closure8(v10, v371)
    let v376 : unit = (fun () -> v375 (); v374) ()
    let v381 : string =
        if v7 then
            let v379 : string = "true"
            v379
        else
            let v380 : string = "false"
            v380
    let v382 : string = $"{v381}"
    let v385 : unit = ()
    let v386 : (unit -> unit) = closure8(v10, v382)
    let v387 : unit = (fun () -> v386 (); v385) ()
    let v390 : string = $"{v46}"
    let v393 : unit = ()
    let v394 : (unit -> unit) = closure8(v10, v390)
    let v395 : unit = (fun () -> v394 (); v393) ()
    let v398 : string = "working_directory"
    let v399 : string = $"{v398}"
    let v402 : unit = ()
    let v403 : (unit -> unit) = closure8(v10, v399)
    let v404 : unit = (fun () -> v403 (); v402) ()
    let v407 : string = $"{v29}"
    let v410 : unit = ()
    let v411 : (unit -> unit) = closure8(v10, v407)
    let v412 : unit = (fun () -> v411 (); v410) ()
    let v415 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v416 : string = "format!(\"{:#?}\", $0)"
    let v417 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8 v416 
    let v418 : string = "fable_library_rust::String_::fromString($0)"
    let v419 : string = Fable.Core.RustInterop.emitRustExpr v417 v418 
    let _v415 = v419 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v420 : string = "format!(\"{:#?}\", $0)"
    let v421 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8 v420 
    let v422 : string = "fable_library_rust::String_::fromString($0)"
    let v423 : string = Fable.Core.RustInterop.emitRustExpr v421 v422 
    let _v415 = v423 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v424 : string = "format!(\"{:#?}\", $0)"
    let v425 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8 v424 
    let v426 : string = "fable_library_rust::String_::fromString($0)"
    let v427 : string = Fable.Core.RustInterop.emitRustExpr v425 v426 
    let _v415 = v427 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v428 : string = $"%A{v8}"
    let _v415 = v428 
    #endif
#if FABLE_COMPILER_PYTHON
    let v431 : string = $"%A{v8}"
    let _v415 = v431 
    #endif
#else
    let v434 : string = $"%A{v8}"
    let _v415 = v434 
    #endif
    let v437 : string = _v415 
    let v442 : string = $"{v437}"
    let v445 : unit = ()
    let v446 : (unit -> unit) = closure8(v10, v442)
    let v447 : unit = (fun () -> v446 (); v445) ()
    let v450 : string = " }"
    let v451 : string = $"{v450}"
    let v454 : unit = ()
    let v455 : (unit -> unit) = closure8(v10, v451)
    let v456 : unit = (fun () -> v455 (); v454) ()
    let v459 : string = $"{v450}"
    let v462 : unit = ()
    let v463 : (unit -> unit) = closure8(v10, v459)
    let v464 : unit = (fun () -> v463 (); v462) ()
    let v467 : string = v10.l0
    v467
and method91 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : string, v9 : string, v10 : string, v11 : System.Threading.CancellationToken option, v12 : (struct (string * string) []), v13 : (struct (int32 * string * bool) -> Async<unit>) option, v14 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit) option, v15 : bool, v16 : string option) : string =
    let v17 : string = method92(v8, v9, v10, v11, v12, v13, v14, v15, v16)
    let v18 : int64 = v0.l0
    let v19 : string = "runtime.execute_with_options"
    let v20 : string = $"{v6} {v7} #{v18} %s{v19} / {v17}"
    method18(v20)
and closure37 (v0 : string, v1 : System.Threading.CancellationToken option, v2 : (struct (string * string) []), v3 : (struct (int32 * string * bool) -> Async<unit>) option, v4 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit) option, v5 : bool, v6 : string option, v7 : string, v8 : Vec<std_string_String>) () : unit =
    let v9 : US0 = US0_1
    let v10 : bool = method7(v9)
    if v10 then
        let v11 : unit = ()
        let v12 : (unit -> unit) = closure6()
        let v13 : unit = (fun () -> v12 (); v11) ()
        let struct (v27 : Mut0, v28 : Mut1, v29 : Mut2, v30 : Mut3, v31 : Mut4, v32 : int64 option) = TraceState.trace_state.Value
        let v45 : string = method8(v27, v28, v29, v30, v31, v32)
        let v46 : string = method50()
        let v47 : string = $"%A{v8}"
        let v50 : string = method91(v27, v28, v29, v30, v31, v32, v45, v46, v7, v47, v0, v1, v2, v3, v4, v5, v6)
        method19(v50)
and closure38 () (v0 : std_process_Child option) : std_process_Child option =
    v0
and method93 () : (std_process_Child option -> std_process_Child option) =
    closure38()
and closure39 () (v0 : std_sync_Arc<std_sync_Mutex<std_process_Child option>>) : US23 =
    US23_0(v0)
and method94 () : (std_sync_Arc<std_sync_Mutex<std_process_Child option>> -> US23) =
    closure39()
and closure40 () (v0 : std_string_String) : US23 =
    US23_1(v0)
and method95 () : (std_string_String -> US23) =
    closure40()
and method96 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : std_string_String) : string =
    let v9 : string = method62(v8)
    let v10 : int64 = v0.l0
    let v11 : string = "runtime.execute_with_options / child error"
    let v12 : string = $"{v6} {v7} #{v10} %s{v11} / {v9}"
    method18(v12)
and closure41 (v0 : std_string_String) () : unit =
    let v1 : US0 = US0_4
    let v2 : bool = method7(v1)
    if v2 then
        let v3 : unit = ()
        let v4 : (unit -> unit) = closure6()
        let v5 : unit = (fun () -> v4 (); v3) ()
        let struct (v19 : Mut0, v20 : Mut1, v21 : Mut2, v22 : Mut3, v23 : Mut4, v24 : int64 option) = TraceState.trace_state.Value
        let v37 : string = method8(v19, v20, v21, v22, v23, v24)
        let v38 : string = method60()
        let v39 : string = method96(v19, v20, v21, v22, v23, v24, v37, v38, v0)
        method19(v39)
and method97 (v0 : std_sync_MutexGuard<std_process_Child option>) : std_sync_MutexGuard<std_process_Child option> =
    v0
and closure42 () (v0 : std_process_ChildStdin option) : std_process_ChildStdin option =
    v0
and method98 () : (std_process_ChildStdin option -> std_process_ChildStdin option) =
    closure42()
and closure43 () (v0 : std_sync_mpsc_Sender<std_string_String>) : std_sync_mpsc_Sender<std_string_String> =
    v0
and method99 () : (std_sync_mpsc_Sender<std_string_String> -> std_sync_mpsc_Sender<std_string_String>) =
    closure43()
and method100 () : (std_sync_mpsc_Sender<std_string_String> -> std_sync_mpsc_Sender<std_string_String>) =
    closure43()
and closure44 () (v0 : std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>) : std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>> =
    v0
and method101 () : (std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>> -> std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>) =
    closure44()
and closure45 () (v0 : std_string_String) : US25 =
    US25_0(v0)
and method102 () : (std_string_String -> US25) =
    closure45()
and closure46 () (v0 : std_string_String) : US25 =
    US25_1(v0)
and method103 () : (std_string_String -> US25) =
    closure46()
and method105 (v0 : std_string_String) : string =
    let v1 : string = method14()
    let v2 : Mut3 = {l0 = v1} : Mut3
    let v3 : string = "{ "
    let v4 : string = $"{v3}"
    let v7 : unit = ()
    let v8 : (unit -> unit) = closure8(v2, v4)
    let v9 : unit = (fun () -> v8 (); v7) ()
    let v12 : string = "e"
    let v13 : string = $"{v12}"
    let v16 : unit = ()
    let v17 : (unit -> unit) = closure8(v2, v13)
    let v18 : unit = (fun () -> v17 (); v16) ()
    let v21 : string = " = "
    let v22 : string = $"{v21}"
    let v25 : unit = ()
    let v26 : (unit -> unit) = closure8(v2, v22)
    let v27 : unit = (fun () -> v26 (); v25) ()
    let v30 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v31 : string = "format!(\"{:#?}\", $0)"
    let v32 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v31 
    let v33 : string = "fable_library_rust::String_::fromString($0)"
    let v34 : string = Fable.Core.RustInterop.emitRustExpr v32 v33 
    let _v30 = v34 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v35 : string = "format!(\"{:#?}\", $0)"
    let v36 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v35 
    let v37 : string = "fable_library_rust::String_::fromString($0)"
    let v38 : string = Fable.Core.RustInterop.emitRustExpr v36 v37 
    let _v30 = v38 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v39 : string = "format!(\"{:#?}\", $0)"
    let v40 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v39 
    let v41 : string = "fable_library_rust::String_::fromString($0)"
    let v42 : string = Fable.Core.RustInterop.emitRustExpr v40 v41 
    let _v30 = v42 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v43 : string = $"%A{v0}"
    let _v30 = v43 
    #endif
#if FABLE_COMPILER_PYTHON
    let v46 : string = $"%A{v0}"
    let _v30 = v46 
    #endif
#else
    let v49 : string = $"%A{v0}"
    let _v30 = v49 
    #endif
    let v52 : string = _v30 
    let v57 : string = $"{v52}"
    let v60 : unit = ()
    let v61 : (unit -> unit) = closure8(v2, v57)
    let v62 : unit = (fun () -> v61 (); v60) ()
    let v65 : string = " }"
    let v66 : string = $"{v65}"
    let v69 : unit = ()
    let v70 : (unit -> unit) = closure8(v2, v66)
    let v71 : unit = (fun () -> v70 (); v69) ()
    let v74 : string = v2.l0
    v74
and method104 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : string, v9 : std_string_String) : string =
    let v10 : string = method105(v9)
    let v11 : int64 = v0.l0
    let v12 : string = $"{v6} {v7} #{v11} %s{v8} / {v10}"
    method18(v12)
and closure47 (v0 : std_string_String) () : unit =
    let v1 : US0 = US0_4
    let v2 : bool = method7(v1)
    if v2 then
        let v3 : unit = ()
        let v4 : (unit -> unit) = closure6()
        let v5 : unit = (fun () -> v4 (); v3) ()
        let struct (v19 : Mut0, v20 : Mut1, v21 : Mut2, v22 : Mut3, v23 : Mut4, v24 : int64 option) = TraceState.trace_state.Value
        let v37 : string = method8(v19, v20, v21, v22, v23, v24)
        let v38 : string = method60()
        let v39 : string = $"runtime.stdio_line"
        let v40 : bool = v39 = ""
        let v43 : string =
            if v40 then
                let v41 : string = ""
                v41
            else
                method104(v19, v20, v21, v22, v23, v24, v37, v38, v39, v0)
        method19(v43)
and method106 () : string =
    
    
    
    
    
    let v0 : string = "Verbose"
    let v1 : (unit -> string) = v0.ToLower
    let v2 : string = v1 ()
    let v5 : char = v2.[int 0]
    let v6 : string = method13(v5)
    let v7 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v8 : string = "inline_colorization::color_bright_black"
    let v9 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v8 
    let v10 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v11 : string = "&*$0"
    let v12 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v11 
    let _v10 = v12 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v13 : string = "&*$0"
    let v14 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v13 
    let _v10 = v14 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v15 : string = "&*$0"
    let v16 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v15 
    let _v10 = v16 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v17 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v10 = v17 
    #endif
#if FABLE_COMPILER_PYTHON
    let v20 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v10 = v20 
    #endif
#else
    let v23 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v10 = v23 
    #endif
    let v26 : Ref<Str> = _v10 
    let v31 : string = "inline_colorization::color_reset"
    let v32 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v31 
    let v33 : string = $"format!(\"{{}}{{}}{{}}\", $0, $1, $2)"
    let v34 : std_string_String = Fable.Core.RustInterop.emitRustExpr struct (v9, v26, v32) v33 
    let v35 : string = "fable_library_rust::String_::fromString($0)"
    let v36 : string = Fable.Core.RustInterop.emitRustExpr v34 v35 
    let _v7 = v36 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v37 : string = "inline_colorization::color_bright_black"
    let v38 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v37 
    let v39 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v40 : string = "&*$0"
    let v41 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v40 
    let _v39 = v41 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v42 : string = "&*$0"
    let v43 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v42 
    let _v39 = v43 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v44 : string = "&*$0"
    let v45 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v44 
    let _v39 = v45 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v46 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v39 = v46 
    #endif
#if FABLE_COMPILER_PYTHON
    let v49 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v39 = v49 
    #endif
#else
    let v52 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v39 = v52 
    #endif
    let v55 : Ref<Str> = _v39 
    let v60 : string = "inline_colorization::color_reset"
    let v61 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v60 
    let v62 : string = $"format!(\"{{}}{{}}{{}}\", $0, $1, $2)"
    let v63 : std_string_String = Fable.Core.RustInterop.emitRustExpr struct (v38, v55, v61) v62 
    let v64 : string = "fable_library_rust::String_::fromString($0)"
    let v65 : string = Fable.Core.RustInterop.emitRustExpr v63 v64 
    let _v7 = v65 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v66 : string = "inline_colorization::color_bright_black"
    let v67 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v66 
    let v68 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v69 : string = "&*$0"
    let v70 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v69 
    let _v68 = v70 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v71 : string = "&*$0"
    let v72 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v71 
    let _v68 = v72 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v73 : string = "&*$0"
    let v74 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v73 
    let _v68 = v74 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v75 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v68 = v75 
    #endif
#if FABLE_COMPILER_PYTHON
    let v78 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v68 = v78 
    #endif
#else
    let v81 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v68 = v81 
    #endif
    let v84 : Ref<Str> = _v68 
    let v89 : string = "inline_colorization::color_reset"
    let v90 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v89 
    let v91 : string = $"format!(\"{{}}{{}}{{}}\", $0, $1, $2)"
    let v92 : std_string_String = Fable.Core.RustInterop.emitRustExpr struct (v67, v84, v90) v91 
    let v93 : string = "fable_library_rust::String_::fromString($0)"
    let v94 : string = Fable.Core.RustInterop.emitRustExpr v92 v93 
    let _v7 = v94 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v95 : string = "\u001b[90m"
    let v96 : string = method15()
    let v97 : string = v95 + v6 
    let v98 : string = v97 + v96 
    let _v7 = v98 
    #endif
#if FABLE_COMPILER_PYTHON
    let v99 : string = "\u001b[90m"
    let v100 : string = method15()
    let v101 : string = v99 + v6 
    let v102 : string = v101 + v100 
    let _v7 = v102 
    #endif
#else
    let v103 : string = "\u001b[90m"
    let v104 : string = method15()
    let v105 : string = v103 + v6 
    let v106 : string = v105 + v104 
    let _v7 = v106 
    #endif
    let v107 : string = _v7 
    v107
and method108 () : string =
    let v0 : string = method14()
    let v1 : Mut3 = {l0 = v0} : Mut3
    let v2 : string = v1.l0
    v2
and method107 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : string) : string =
    let v9 : string = method108()
    let v10 : int64 = v0.l0
    let v11 : string = $"{v6} {v7} #{v10} %s{v8} / {v9}"
    method18(v11)
and closure48 (v0 : string) () : unit =
    let v1 : US0 = US0_0
    let v2 : bool = method7(v1)
    if v2 then
        let v3 : unit = ()
        let v4 : (unit -> unit) = closure6()
        let v5 : unit = (fun () -> v4 (); v3) ()
        let struct (v19 : Mut0, v20 : Mut1, v21 : Mut2, v22 : Mut3, v23 : Mut4, v24 : int64 option) = TraceState.trace_state.Value
        let v37 : string = method8(v19, v20, v21, v22, v23, v24)
        let v38 : string = method106()
        let v39 : bool = v0 = ""
        let v42 : string =
            if v39 then
                let v40 : string = ""
                v40
            else
                method107(v19, v20, v21, v22, v23, v24, v37, v38, v0)
        method19(v42)
and closure49 () (v0 : std_sync_mpsc_SendError<std_string_String>) : std_string_String =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : string = "format!(\"{}\", $0)"
    let v3 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v2 
    let _v1 = v3 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v4 : string = "format!(\"{}\", $0)"
    let v5 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v4 
    let _v1 = v5 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v6 : string = "format!(\"{}\", $0)"
    let v7 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v6 
    let _v1 = v7 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v8 : std_string_String = null |> unbox<std_string_String>
    let _v1 = v8 
    #endif
#if FABLE_COMPILER_PYTHON
    let v11 : std_string_String = null |> unbox<std_string_String>
    let _v1 = v11 
    #endif
#else
    let v14 : std_string_String = null |> unbox<std_string_String>
    let _v1 = v14 
    #endif
    let v17 : std_string_String = _v1 
    v17
and method109 () : (std_sync_mpsc_SendError<std_string_String> -> std_string_String) =
    closure49()
and method110 (v0 : Result<unit, string>) : Result<unit, string> =
    v0
and closure50 () (v0 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit)) : US26 =
    US26_0(v0)
and method111 () : ((std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit) -> US26) =
    closure50()
and method112 (v0 : std_sync_MutexGuard<std_process_ChildStdin option>) : std_sync_MutexGuard<std_process_ChildStdin option> =
    v0
and closure51 () (v0 : std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>>) : US27 =
    US27_0(v0)
and method113 () : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> US27) =
    closure51()
and method114 (v0 : std_sync_MutexGuard<std_process_ChildStdin>) : std_sync_MutexGuard<std_process_ChildStdin> =
    v0
and method115 (v0 : std_thread_JoinHandle<Result<unit, string>>) : std_thread_JoinHandle<Result<unit, string>> =
    v0
and closure52 () (v0 : std_process_Output) : US28 =
    US28_0(v0)
and closure53 () (v0 : std_string_String) : US28 =
    US28_1(v0)
and method116 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : std_string_String) : string =
    let v9 : string = method62(v8)
    let v10 : int64 = v0.l0
    let v11 : string = "runtime.execute_with_options / output error"
    let v12 : string = $"{v6} {v7} #{v10} %s{v11} / {v9}"
    method18(v12)
and closure54 (v0 : std_string_String) () : unit =
    let v1 : US0 = US0_4
    let v2 : bool = method7(v1)
    if v2 then
        let v3 : unit = ()
        let v4 : (unit -> unit) = closure6()
        let v5 : unit = (fun () -> v4 (); v3) ()
        let struct (v19 : Mut0, v20 : Mut1, v21 : Mut2, v22 : Mut3, v23 : Mut4, v24 : int64 option) = TraceState.trace_state.Value
        let v37 : string = method8(v19, v20, v21, v22, v23, v24)
        let v38 : string = method60()
        let v39 : string = method116(v19, v20, v21, v22, v23, v24, v37, v38, v0)
        method19(v39)
and closure55 () (v0 : int32) : US29 =
    US29_0(v0)
and method117 () : (int32 -> US29) =
    closure55()
and method119 (v0 : int32, v1 : int32) : string =
    let v2 : string = method14()
    let v3 : Mut3 = {l0 = v2} : Mut3
    let v4 : string = "{ "
    let v5 : string = $"{v4}"
    let v8 : unit = ()
    let v9 : (unit -> unit) = closure8(v3, v5)
    let v10 : unit = (fun () -> v9 (); v8) ()
    let v13 : string = "exit_code"
    let v14 : string = $"{v13}"
    let v17 : unit = ()
    let v18 : (unit -> unit) = closure8(v3, v14)
    let v19 : unit = (fun () -> v18 (); v17) ()
    let v22 : string = " = "
    let v23 : string = $"{v22}"
    let v26 : unit = ()
    let v27 : (unit -> unit) = closure8(v3, v23)
    let v28 : unit = (fun () -> v27 (); v26) ()
    let v31 : string = $"{v0}"
    let v34 : unit = ()
    let v35 : (unit -> unit) = closure8(v3, v31)
    let v36 : unit = (fun () -> v35 (); v34) ()
    let v39 : string = "; "
    let v40 : string = $"{v39}"
    let v43 : unit = ()
    let v44 : (unit -> unit) = closure8(v3, v40)
    let v45 : unit = (fun () -> v44 (); v43) ()
    let v48 : string = "std_trace_length"
    let v49 : string = $"{v48}"
    let v52 : unit = ()
    let v53 : (unit -> unit) = closure8(v3, v49)
    let v54 : unit = (fun () -> v53 (); v52) ()
    let v57 : string = $"{v22}"
    let v60 : unit = ()
    let v61 : (unit -> unit) = closure8(v3, v57)
    let v62 : unit = (fun () -> v61 (); v60) ()
    let v65 : string = $"{v1}"
    let v68 : unit = ()
    let v69 : (unit -> unit) = closure8(v3, v65)
    let v70 : unit = (fun () -> v69 (); v68) ()
    let v73 : string = " }"
    let v74 : string = $"{v73}"
    let v77 : unit = ()
    let v78 : (unit -> unit) = closure8(v3, v74)
    let v79 : unit = (fun () -> v78 (); v77) ()
    let v82 : string = v3.l0
    v82
and method118 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : int32, v9 : int32) : string =
    let v10 : string = method119(v8, v9)
    let v11 : int64 = v0.l0
    let v12 : string = "runtime.execute_with_options / result"
    let v13 : string = $"{v6} {v7} #{v11} %s{v12} / {v10}"
    method18(v13)
and closure56 (v0 : int32, v1 : string) () : unit =
    let v2 : US0 = US0_0
    let v3 : bool = method7(v2)
    if v3 then
        let v4 : unit = ()
        let v5 : (unit -> unit) = closure6()
        let v6 : unit = (fun () -> v5 (); v4) ()
        let struct (v20 : Mut0, v21 : Mut1, v22 : Mut2, v23 : Mut3, v24 : Mut4, v25 : int64 option) = TraceState.trace_state.Value
        let v38 : string = method8(v20, v21, v22, v23, v24, v25)
        let v39 : string = method106()
        let v40 : int32 = v1.Length
        let v41 : string = method118(v20, v21, v22, v23, v24, v25, v38, v39, v0, v40)
        method19(v41)
and method122 (v0 : string, v1 : US1, v2 : string, v3 : System.Threading.CancellationToken option, v4 : (struct (string * string) []), v5 : (struct (int32 * string * bool) -> Async<unit>) option, v6 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit) option, v7 : bool, v8 : string option) : string =
    let v9 : string = method14()
    let v10 : Mut3 = {l0 = v9} : Mut3
    let v11 : string = "{ "
    let v12 : string = $"{v11}"
    let v15 : unit = ()
    let v16 : (unit -> unit) = closure8(v10, v12)
    let v17 : unit = (fun () -> v16 (); v15) ()
    let v20 : string = "file_name"
    let v21 : string = $"{v20}"
    let v24 : unit = ()
    let v25 : (unit -> unit) = closure8(v10, v21)
    let v26 : unit = (fun () -> v25 (); v24) ()
    let v29 : string = " = "
    let v30 : string = $"{v29}"
    let v33 : unit = ()
    let v34 : (unit -> unit) = closure8(v10, v30)
    let v35 : unit = (fun () -> v34 (); v33) ()
    let v38 : string = $"{v0}"
    let v41 : unit = ()
    let v42 : (unit -> unit) = closure8(v10, v38)
    let v43 : unit = (fun () -> v42 (); v41) ()
    let v46 : string = "; "
    let v47 : string = $"{v46}"
    let v50 : unit = ()
    let v51 : (unit -> unit) = closure8(v10, v47)
    let v52 : unit = (fun () -> v51 (); v50) ()
    let v55 : string = "arguments"
    let v56 : string = $"{v55}"
    let v59 : unit = ()
    let v60 : (unit -> unit) = closure8(v10, v56)
    let v61 : unit = (fun () -> v60 (); v59) ()
    let v64 : string = $"{v29}"
    let v67 : unit = ()
    let v68 : (unit -> unit) = closure8(v10, v64)
    let v69 : unit = (fun () -> v68 (); v67) ()
    let v72 : string = $"%A{v1}"
    let v75 : string = $"{v72}"
    let v78 : unit = ()
    let v79 : (unit -> unit) = closure8(v10, v75)
    let v80 : unit = (fun () -> v79 (); v78) ()
    let v83 : string = $"{v46}"
    let v86 : unit = ()
    let v87 : (unit -> unit) = closure8(v10, v83)
    let v88 : unit = (fun () -> v87 (); v86) ()
    let v91 : string = "options"
    let v92 : string = $"{v91}"
    let v95 : unit = ()
    let v96 : (unit -> unit) = closure8(v10, v92)
    let v97 : unit = (fun () -> v96 (); v95) ()
    let v100 : string = $"{v29}"
    let v103 : unit = ()
    let v104 : (unit -> unit) = closure8(v10, v100)
    let v105 : unit = (fun () -> v104 (); v103) ()
    let v108 : string = $"{v11}"
    let v111 : unit = ()
    let v112 : (unit -> unit) = closure8(v10, v108)
    let v113 : unit = (fun () -> v112 (); v111) ()
    let v116 : string = "command"
    let v117 : string = $"{v116}"
    let v120 : unit = ()
    let v121 : (unit -> unit) = closure8(v10, v117)
    let v122 : unit = (fun () -> v121 (); v120) ()
    let v125 : string = $"{v29}"
    let v128 : unit = ()
    let v129 : (unit -> unit) = closure8(v10, v125)
    let v130 : unit = (fun () -> v129 (); v128) ()
    let v133 : string = $"{v2}"
    let v136 : unit = ()
    let v137 : (unit -> unit) = closure8(v10, v133)
    let v138 : unit = (fun () -> v137 (); v136) ()
    let v141 : string = $"{v46}"
    let v144 : unit = ()
    let v145 : (unit -> unit) = closure8(v10, v141)
    let v146 : unit = (fun () -> v145 (); v144) ()
    let v149 : string = "cancellation_token"
    let v150 : string = $"{v149}"
    let v153 : unit = ()
    let v154 : (unit -> unit) = closure8(v10, v150)
    let v155 : unit = (fun () -> v154 (); v153) ()
    let v158 : string = $"{v29}"
    let v161 : unit = ()
    let v162 : (unit -> unit) = closure8(v10, v158)
    let v163 : unit = (fun () -> v162 (); v161) ()
    let v166 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v167 : string = "format!(\"{:#?}\", $0)"
    let v168 : std_string_String = Fable.Core.RustInterop.emitRustExpr v3 v167 
    let v169 : string = "fable_library_rust::String_::fromString($0)"
    let v170 : string = Fable.Core.RustInterop.emitRustExpr v168 v169 
    let _v166 = v170 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v171 : string = "format!(\"{:#?}\", $0)"
    let v172 : std_string_String = Fable.Core.RustInterop.emitRustExpr v3 v171 
    let v173 : string = "fable_library_rust::String_::fromString($0)"
    let v174 : string = Fable.Core.RustInterop.emitRustExpr v172 v173 
    let _v166 = v174 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v175 : string = "format!(\"{:#?}\", $0)"
    let v176 : std_string_String = Fable.Core.RustInterop.emitRustExpr v3 v175 
    let v177 : string = "fable_library_rust::String_::fromString($0)"
    let v178 : string = Fable.Core.RustInterop.emitRustExpr v176 v177 
    let _v166 = v178 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v179 : string = $"%A{v3}"
    let _v166 = v179 
    #endif
#if FABLE_COMPILER_PYTHON
    let v182 : string = $"%A{v3}"
    let _v166 = v182 
    #endif
#else
    let v185 : string = $"%A{v3}"
    let _v166 = v185 
    #endif
    let v188 : string = _v166 
    let v193 : string = $"{v188}"
    let v196 : unit = ()
    let v197 : (unit -> unit) = closure8(v10, v193)
    let v198 : unit = (fun () -> v197 (); v196) ()
    let v201 : string = $"{v46}"
    let v204 : unit = ()
    let v205 : (unit -> unit) = closure8(v10, v201)
    let v206 : unit = (fun () -> v205 (); v204) ()
    let v209 : string = "environment_variables"
    let v210 : string = $"{v209}"
    let v213 : unit = ()
    let v214 : (unit -> unit) = closure8(v10, v210)
    let v215 : unit = (fun () -> v214 (); v213) ()
    let v218 : string = $"{v29}"
    let v221 : unit = ()
    let v222 : (unit -> unit) = closure8(v10, v218)
    let v223 : unit = (fun () -> v222 (); v221) ()
    let v226 : string = $"%A{v4}"
    let v229 : string = $"{v226}"
    let v232 : unit = ()
    let v233 : (unit -> unit) = closure8(v10, v229)
    let v234 : unit = (fun () -> v233 (); v232) ()
    let v237 : string = $"{v46}"
    let v240 : unit = ()
    let v241 : (unit -> unit) = closure8(v10, v237)
    let v242 : unit = (fun () -> v241 (); v240) ()
    let v245 : string = "on_line"
    let v246 : string = $"{v245}"
    let v249 : unit = ()
    let v250 : (unit -> unit) = closure8(v10, v246)
    let v251 : unit = (fun () -> v250 (); v249) ()
    let v254 : string = $"{v29}"
    let v257 : unit = ()
    let v258 : (unit -> unit) = closure8(v10, v254)
    let v259 : unit = (fun () -> v258 (); v257) ()
    let v262 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v263 : string = "format!(\"{:#?}\", $0)"
    let v264 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5 v263 
    let v265 : string = "fable_library_rust::String_::fromString($0)"
    let v266 : string = Fable.Core.RustInterop.emitRustExpr v264 v265 
    let _v262 = v266 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v267 : string = "format!(\"{:#?}\", $0)"
    let v268 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5 v267 
    let v269 : string = "fable_library_rust::String_::fromString($0)"
    let v270 : string = Fable.Core.RustInterop.emitRustExpr v268 v269 
    let _v262 = v270 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v271 : string = "format!(\"{:#?}\", $0)"
    let v272 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5 v271 
    let v273 : string = "fable_library_rust::String_::fromString($0)"
    let v274 : string = Fable.Core.RustInterop.emitRustExpr v272 v273 
    let _v262 = v274 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v275 : string = $"%A{v5}"
    let _v262 = v275 
    #endif
#if FABLE_COMPILER_PYTHON
    let v278 : string = $"%A{v5}"
    let _v262 = v278 
    #endif
#else
    let v281 : string = $"%A{v5}"
    let _v262 = v281 
    #endif
    let v284 : string = _v262 
    let v289 : string = $"{v284}"
    let v292 : unit = ()
    let v293 : (unit -> unit) = closure8(v10, v289)
    let v294 : unit = (fun () -> v293 (); v292) ()
    let v297 : string = $"{v46}"
    let v300 : unit = ()
    let v301 : (unit -> unit) = closure8(v10, v297)
    let v302 : unit = (fun () -> v301 (); v300) ()
    let v305 : string = "stdin"
    let v306 : string = $"{v305}"
    let v309 : unit = ()
    let v310 : (unit -> unit) = closure8(v10, v306)
    let v311 : unit = (fun () -> v310 (); v309) ()
    let v314 : string = $"{v29}"
    let v317 : unit = ()
    let v318 : (unit -> unit) = closure8(v10, v314)
    let v319 : unit = (fun () -> v318 (); v317) ()
    let v322 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v323 : string = "format!(\"{:#?}\", $0)"
    let v324 : std_string_String = Fable.Core.RustInterop.emitRustExpr v6 v323 
    let v325 : string = "fable_library_rust::String_::fromString($0)"
    let v326 : string = Fable.Core.RustInterop.emitRustExpr v324 v325 
    let _v322 = v326 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v327 : string = "format!(\"{:#?}\", $0)"
    let v328 : std_string_String = Fable.Core.RustInterop.emitRustExpr v6 v327 
    let v329 : string = "fable_library_rust::String_::fromString($0)"
    let v330 : string = Fable.Core.RustInterop.emitRustExpr v328 v329 
    let _v322 = v330 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v331 : string = "format!(\"{:#?}\", $0)"
    let v332 : std_string_String = Fable.Core.RustInterop.emitRustExpr v6 v331 
    let v333 : string = "fable_library_rust::String_::fromString($0)"
    let v334 : string = Fable.Core.RustInterop.emitRustExpr v332 v333 
    let _v322 = v334 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v335 : string = $"%A{v6}"
    let _v322 = v335 
    #endif
#if FABLE_COMPILER_PYTHON
    let v338 : string = $"%A{v6}"
    let _v322 = v338 
    #endif
#else
    let v341 : string = $"%A{v6}"
    let _v322 = v341 
    #endif
    let v344 : string = _v322 
    let v349 : string = $"{v344}"
    let v352 : unit = ()
    let v353 : (unit -> unit) = closure8(v10, v349)
    let v354 : unit = (fun () -> v353 (); v352) ()
    let v357 : string = $"{v46}"
    let v360 : unit = ()
    let v361 : (unit -> unit) = closure8(v10, v357)
    let v362 : unit = (fun () -> v361 (); v360) ()
    let v365 : string = "trace"
    let v366 : string = $"{v365}"
    let v369 : unit = ()
    let v370 : (unit -> unit) = closure8(v10, v366)
    let v371 : unit = (fun () -> v370 (); v369) ()
    let v374 : string = $"{v29}"
    let v377 : unit = ()
    let v378 : (unit -> unit) = closure8(v10, v374)
    let v379 : unit = (fun () -> v378 (); v377) ()
    let v384 : string =
        if v7 then
            let v382 : string = "true"
            v382
        else
            let v383 : string = "false"
            v383
    let v385 : string = $"{v384}"
    let v388 : unit = ()
    let v389 : (unit -> unit) = closure8(v10, v385)
    let v390 : unit = (fun () -> v389 (); v388) ()
    let v393 : string = $"{v46}"
    let v396 : unit = ()
    let v397 : (unit -> unit) = closure8(v10, v393)
    let v398 : unit = (fun () -> v397 (); v396) ()
    let v401 : string = "working_directory"
    let v402 : string = $"{v401}"
    let v405 : unit = ()
    let v406 : (unit -> unit) = closure8(v10, v402)
    let v407 : unit = (fun () -> v406 (); v405) ()
    let v410 : string = $"{v29}"
    let v413 : unit = ()
    let v414 : (unit -> unit) = closure8(v10, v410)
    let v415 : unit = (fun () -> v414 (); v413) ()
    let v418 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v419 : string = "format!(\"{:#?}\", $0)"
    let v420 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8 v419 
    let v421 : string = "fable_library_rust::String_::fromString($0)"
    let v422 : string = Fable.Core.RustInterop.emitRustExpr v420 v421 
    let _v418 = v422 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v423 : string = "format!(\"{:#?}\", $0)"
    let v424 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8 v423 
    let v425 : string = "fable_library_rust::String_::fromString($0)"
    let v426 : string = Fable.Core.RustInterop.emitRustExpr v424 v425 
    let _v418 = v426 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v427 : string = "format!(\"{:#?}\", $0)"
    let v428 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8 v427 
    let v429 : string = "fable_library_rust::String_::fromString($0)"
    let v430 : string = Fable.Core.RustInterop.emitRustExpr v428 v429 
    let _v418 = v430 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v431 : string = $"%A{v8}"
    let _v418 = v431 
    #endif
#if FABLE_COMPILER_PYTHON
    let v434 : string = $"%A{v8}"
    let _v418 = v434 
    #endif
#else
    let v437 : string = $"%A{v8}"
    let _v418 = v437 
    #endif
    let v440 : string = _v418 
    let v445 : string = $"{v440}"
    let v448 : unit = ()
    let v449 : (unit -> unit) = closure8(v10, v445)
    let v450 : unit = (fun () -> v449 (); v448) ()
    let v453 : string = " }"
    let v454 : string = $"{v453}"
    let v457 : unit = ()
    let v458 : (unit -> unit) = closure8(v10, v454)
    let v459 : unit = (fun () -> v458 (); v457) ()
    let v462 : string = $"{v453}"
    let v465 : unit = ()
    let v466 : (unit -> unit) = closure8(v10, v462)
    let v467 : unit = (fun () -> v466 (); v465) ()
    let v470 : string = v10.l0
    v470
and method121 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : string, v9 : US1, v10 : string, v11 : System.Threading.CancellationToken option, v12 : (struct (string * string) []), v13 : (struct (int32 * string * bool) -> Async<unit>) option, v14 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit) option, v15 : bool, v16 : string option) : string =
    let v17 : string = method122(v8, v9, v10, v11, v12, v13, v14, v15, v16)
    let v18 : int64 = v0.l0
    let v19 : string = "runtime.execute_with_options_async"
    let v20 : string = $"{v6} {v7} #{v18} %s{v19} / {v17}"
    method18(v20)
and closure57 (v0 : string, v1 : System.Threading.CancellationToken option, v2 : (struct (string * string) []), v3 : (struct (int32 * string * bool) -> Async<unit>) option, v4 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit) option, v5 : bool, v6 : string option, v7 : US1, v8 : string) () : unit =
    let v9 : US0 = US0_1
    let v10 : bool = method7(v9)
    if v10 then
        let v11 : unit = ()
        let v12 : (unit -> unit) = closure6()
        let v13 : unit = (fun () -> v12 (); v11) ()
        let struct (v27 : Mut0, v28 : Mut1, v29 : Mut2, v30 : Mut3, v31 : Mut4, v32 : int64 option) = TraceState.trace_state.Value
        let v45 : string = method8(v27, v28, v29, v30, v31, v32)
        let v46 : string = method50()
        let v47 : string = method121(v27, v28, v29, v30, v31, v32, v45, v46, v8, v7, v0, v1, v2, v3, v4, v5, v6)
        method19(v47)
and closure59 () (v0 : (struct (int32 * string * bool) -> Async<unit>)) : US30 =
    US30_0(v0)
and method123 () : ((struct (int32 * string * bool) -> Async<unit>) -> US30) =
    closure59()
and closure60 (v0 : string) () : unit =
    let v1 : US0 = US0_0
    let v2 : bool = method7(v1)
    if v2 then
        let v3 : unit = ()
        let v4 : (unit -> unit) = closure6()
        let v5 : unit = (fun () -> v4 (); v3) ()
        let struct (v19 : Mut0, v20 : Mut1, v21 : Mut2, v22 : Mut3, v23 : Mut4, v24 : int64 option) = TraceState.trace_state.Value
        let v37 : string = method8(v19, v20, v21, v22, v23, v24)
        let v38 : string = method106()
        let v39 : bool = v0 = ""
        let v42 : string =
            if v39 then
                let v40 : string = ""
                v40
            else
                method107(v19, v20, v21, v22, v23, v24, v37, v38, v0)
        method19(v42)
and closure58 (v0 : string, v1 : System.Threading.CancellationToken option, v2 : (struct (string * string) []), v3 : (struct (int32 * string * bool) -> Async<unit>) option, v4 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit) option, v5 : bool, v6 : string option, v7 : System.Diagnostics.Process, v8 : System.Collections.Concurrent.ConcurrentStack<string>) (v9 : System.Diagnostics.DataReceivedEventArgs) : unit =
    let v10 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v11 : Async<unit> = null |> unbox<Async<unit>>
    let _v10 = v11 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v14 : Async<unit> = null |> unbox<Async<unit>>
    let _v10 = v14 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v17 : Async<unit> = null |> unbox<Async<unit>>
    let _v10 = v17 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v20 : Async<unit> = null |> unbox<Async<unit>>
    let _v10 = v20 
    #endif
#if FABLE_COMPILER_PYTHON
    let v23 : Async<unit> = null |> unbox<Async<unit>>
    let _v10 = v23 
    #endif
#else
    let v26 : Async<unit> option = None
    let mutable _v26 = v26 
    async {
    let v27 : string = v9.Data
    let v28 : string = null |> unbox<string>
    let v31 : bool = v27 = v28
    let v32 : bool = v31 <> true
    if v32 then
        let v33 : ((struct (int32 * string * bool) -> Async<unit>) -> US30) = method123()
        let v34 : US30 option = v3 |> Option.map v33 
        let v45 : US30 = US30_1
        let v46 : US30 = v34 |> Option.defaultValue v45 
        match v46 with
        | US30_1 -> (* None *)
            ()
        | US30_0(v50) -> (* Some *)
            let v51 : int32 = v7.Id
            let v52 : Async<unit> = v50 struct (v51, v27, false)
            do! v52 
            ()
        let v53 : string = $"> {v27}"
        if v5 then
            let v54 : unit = ()
            let v55 : (unit -> unit) = closure60(v53)
            let v56 : unit = (fun () -> v55 (); v54) ()
            ()
        else
            let v99 : unit = ()
            let v100 : (unit -> unit) = closure11(v53)
            let v101 : unit = (fun () -> v100 (); v99) ()
            ()
        let v103 : string = ""
        let v104 : string = $"{v103}{v27}{v103}"
        let v105 : (string -> unit) = v8.Push
        v105 v104
    ()
    }
    |> fun x -> _v26 <- Some x
    let v106 : Async<unit> = match _v26 with Some x -> x | None -> failwith "async.new_async_unit / _v26=None"
    let _v10 = v106 
    #endif
    let v107 : Async<unit> = _v10 
    let v112 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    null |> unbox<unit>
    let _v112 = () 
    #endif
#if FABLE_COMPILER_RUST && WASM
    null |> unbox<unit>
    let _v112 = () 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    null |> unbox<unit>
    let _v112 = () 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    null |> unbox<unit>
    let _v112 = () 
    #endif
#if FABLE_COMPILER_PYTHON
    null |> unbox<unit>
    let _v112 = () 
    #endif
#else
    let v113 : (Async<unit> -> unit) = Async.StartImmediate
    v113 v107
    let _v112 = () 
    #endif
    _v112 
    ()
and closure61 (v0 : string, v1 : System.Threading.CancellationToken option, v2 : (struct (string * string) []), v3 : (struct (int32 * string * bool) -> Async<unit>) option, v4 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit) option, v5 : bool, v6 : string option, v7 : System.Diagnostics.Process, v8 : System.Collections.Concurrent.ConcurrentStack<string>) (v9 : System.Diagnostics.DataReceivedEventArgs) : unit =
    let v10 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v11 : Async<unit> = null |> unbox<Async<unit>>
    let _v10 = v11 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v14 : Async<unit> = null |> unbox<Async<unit>>
    let _v10 = v14 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v17 : Async<unit> = null |> unbox<Async<unit>>
    let _v10 = v17 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v20 : Async<unit> = null |> unbox<Async<unit>>
    let _v10 = v20 
    #endif
#if FABLE_COMPILER_PYTHON
    let v23 : Async<unit> = null |> unbox<Async<unit>>
    let _v10 = v23 
    #endif
#else
    let v26 : Async<unit> option = None
    let mutable _v26 = v26 
    async {
    let v27 : string = v9.Data
    let v28 : string = null |> unbox<string>
    let v31 : bool = v27 = v28
    let v32 : bool = v31 <> true
    if v32 then
        let v33 : ((struct (int32 * string * bool) -> Async<unit>) -> US30) = method123()
        let v34 : US30 option = v3 |> Option.map v33 
        let v45 : US30 = US30_1
        let v46 : US30 = v34 |> Option.defaultValue v45 
        match v46 with
        | US30_1 -> (* None *)
            ()
        | US30_0(v50) -> (* Some *)
            let v51 : int32 = v7.Id
            let v52 : Async<unit> = v50 struct (v51, v27, true)
            do! v52 
            ()
        let v53 : string = $"! {v27}"
        if v5 then
            let v54 : unit = ()
            let v55 : (unit -> unit) = closure60(v53)
            let v56 : unit = (fun () -> v55 (); v54) ()
            ()
        else
            let v99 : unit = ()
            let v100 : (unit -> unit) = closure11(v53)
            let v101 : unit = (fun () -> v100 (); v99) ()
            ()
        let v103 : string = "\u001b[7;4m"
        let v104 : string = "\u001b[0m"
        let v105 : string = $"{v103}{v27}{v104}"
        let v106 : (string -> unit) = v8.Push
        v106 v105
    ()
    }
    |> fun x -> _v26 <- Some x
    let v107 : Async<unit> = match _v26 with Some x -> x | None -> failwith "async.new_async_unit / _v26=None"
    let _v10 = v107 
    #endif
    let v108 : Async<unit> = _v10 
    let v113 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    null |> unbox<unit>
    let _v113 = () 
    #endif
#if FABLE_COMPILER_RUST && WASM
    null |> unbox<unit>
    let _v113 = () 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    null |> unbox<unit>
    let _v113 = () 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    null |> unbox<unit>
    let _v113 = () 
    #endif
#if FABLE_COMPILER_PYTHON
    null |> unbox<unit>
    let _v113 = () 
    #endif
#else
    let v114 : (Async<unit> -> unit) = Async.StartImmediate
    v114 v108
    let _v113 = () 
    #endif
    _v113 
    ()
and closure62 () (v0 : System.Threading.CancellationToken) : US31 =
    US31_0(v0)
and method124 () : (System.Threading.CancellationToken -> US31) =
    closure62()
and closure63 (v0 : System.Diagnostics.Process) () : unit =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : bool = null |> unbox<bool>
    let _v1 = v2 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v5 : bool = null |> unbox<bool>
    let _v1 = v5 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v8 : bool = null |> unbox<bool>
    let _v1 = v8 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v11 : bool = null |> unbox<bool>
    let _v1 = v11 
    #endif
#if FABLE_COMPILER_PYTHON
    let v14 : bool = null |> unbox<bool>
    let _v1 = v14 
    #endif
#else
    let v17 : bool = v0.HasExited
    let _v1 = v17 
    #endif
    let v18 : bool = _v1 
    let v23 : bool = v18 = false
    if v23 then
        let v24 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let _v24 = () 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let _v24 = () 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let _v24 = () 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let _v24 = () 
        #endif
#if FABLE_COMPILER_PYTHON
        let _v24 = () 
        #endif
#else
        let v25 : (unit -> unit) = v0.Kill
        v25 ()
        let _v24 = () 
        #endif
        _v24 
        ()
and method126 (v0 : System.Threading.Tasks.TaskCanceledException) : string =
    let v1 : string = method14()
    let v2 : Mut3 = {l0 = v1} : Mut3
    let v3 : string = "{ "
    let v4 : string = $"{v3}"
    let v7 : unit = ()
    let v8 : (unit -> unit) = closure8(v2, v4)
    let v9 : unit = (fun () -> v8 (); v7) ()
    let v12 : string = "ex"
    let v13 : string = $"{v12}"
    let v16 : unit = ()
    let v17 : (unit -> unit) = closure8(v2, v13)
    let v18 : unit = (fun () -> v17 (); v16) ()
    let v21 : string = " = "
    let v22 : string = $"{v21}"
    let v25 : unit = ()
    let v26 : (unit -> unit) = closure8(v2, v22)
    let v27 : unit = (fun () -> v26 (); v25) ()
    let v30 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v31 : string = "format!(\"{:#?}\", $0)"
    let v32 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v31 
    let v33 : string = "fable_library_rust::String_::fromString($0)"
    let v34 : string = Fable.Core.RustInterop.emitRustExpr v32 v33 
    let _v30 = v34 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v35 : string = "format!(\"{:#?}\", $0)"
    let v36 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v35 
    let v37 : string = "fable_library_rust::String_::fromString($0)"
    let v38 : string = Fable.Core.RustInterop.emitRustExpr v36 v37 
    let _v30 = v38 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v39 : string = "format!(\"{:#?}\", $0)"
    let v40 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v39 
    let v41 : string = "fable_library_rust::String_::fromString($0)"
    let v42 : string = Fable.Core.RustInterop.emitRustExpr v40 v41 
    let _v30 = v42 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v43 : string = $"%A{v0}"
    let _v30 = v43 
    #endif
#if FABLE_COMPILER_PYTHON
    let v46 : string = $"%A{v0}"
    let _v30 = v46 
    #endif
#else
    let v49 : string = $"%A{v0}"
    let _v30 = v49 
    #endif
    let v52 : string = _v30 
    let v57 : string = $"{v52}"
    let v60 : unit = ()
    let v61 : (unit -> unit) = closure8(v2, v57)
    let v62 : unit = (fun () -> v61 (); v60) ()
    let v65 : string = " }"
    let v66 : string = $"{v65}"
    let v69 : unit = ()
    let v70 : (unit -> unit) = closure8(v2, v66)
    let v71 : unit = (fun () -> v70 (); v69) ()
    let v74 : string = v2.l0
    v74
and method125 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : System.Threading.Tasks.TaskCanceledException) : string =
    let v9 : string = method126(v8)
    let v10 : int64 = v0.l0
    let v11 : string = "runtime.execute_with_options_async / WaitForExitAsync"
    let v12 : string = $"{v6} {v7} #{v10} %s{v11} / {v9}"
    method18(v12)
and closure64 (v0 : System.Threading.Tasks.TaskCanceledException) () : unit =
    let v1 : US0 = US0_3
    let v2 : bool = method7(v1)
    if v2 then
        let v3 : unit = ()
        let v4 : (unit -> unit) = closure6()
        let v5 : unit = (fun () -> v4 (); v3) ()
        let struct (v19 : Mut0, v20 : Mut1, v21 : Mut2, v22 : Mut3, v23 : Mut4, v24 : int64 option) = TraceState.trace_state.Value
        let v37 : string = method8(v19, v20, v21, v22, v23, v24)
        let v38 : string = method35()
        let v39 : string = method125(v19, v20, v21, v22, v23, v24, v37, v38, v0)
        method19(v39)
and method128 (v0 : int32, v1 : int32) : string =
    let v2 : string = method14()
    let v3 : Mut3 = {l0 = v2} : Mut3
    let v4 : string = "{ "
    let v5 : string = $"{v4}"
    let v8 : unit = ()
    let v9 : (unit -> unit) = closure8(v3, v5)
    let v10 : unit = (fun () -> v9 (); v8) ()
    let v13 : string = "exit_code"
    let v14 : string = $"{v13}"
    let v17 : unit = ()
    let v18 : (unit -> unit) = closure8(v3, v14)
    let v19 : unit = (fun () -> v18 (); v17) ()
    let v22 : string = " = "
    let v23 : string = $"{v22}"
    let v26 : unit = ()
    let v27 : (unit -> unit) = closure8(v3, v23)
    let v28 : unit = (fun () -> v27 (); v26) ()
    let v31 : string = $"{v0}"
    let v34 : unit = ()
    let v35 : (unit -> unit) = closure8(v3, v31)
    let v36 : unit = (fun () -> v35 (); v34) ()
    let v39 : string = "; "
    let v40 : string = $"{v39}"
    let v43 : unit = ()
    let v44 : (unit -> unit) = closure8(v3, v40)
    let v45 : unit = (fun () -> v44 (); v43) ()
    let v48 : string = "output_length"
    let v49 : string = $"{v48}"
    let v52 : unit = ()
    let v53 : (unit -> unit) = closure8(v3, v49)
    let v54 : unit = (fun () -> v53 (); v52) ()
    let v57 : string = $"{v22}"
    let v60 : unit = ()
    let v61 : (unit -> unit) = closure8(v3, v57)
    let v62 : unit = (fun () -> v61 (); v60) ()
    let v65 : string = $"{v1}"
    let v68 : unit = ()
    let v69 : (unit -> unit) = closure8(v3, v65)
    let v70 : unit = (fun () -> v69 (); v68) ()
    let v73 : string = " }"
    let v74 : string = $"{v73}"
    let v77 : unit = ()
    let v78 : (unit -> unit) = closure8(v3, v74)
    let v79 : unit = (fun () -> v78 (); v77) ()
    let v82 : string = v3.l0
    v82
and method127 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : int32, v9 : int32) : string =
    let v10 : string = method128(v8, v9)
    let v11 : int64 = v0.l0
    let v12 : string = "runtime.execute_with_options_async"
    let v13 : string = $"{v6} {v7} #{v11} %s{v12} / {v10}"
    method18(v13)
and closure65 (v0 : int32, v1 : string) () : unit =
    let v2 : US0 = US0_1
    let v3 : bool = method7(v2)
    if v3 then
        let v4 : unit = ()
        let v5 : (unit -> unit) = closure6()
        let v6 : unit = (fun () -> v5 (); v4) ()
        let struct (v20 : Mut0, v21 : Mut1, v22 : Mut2, v23 : Mut3, v24 : Mut4, v25 : int64 option) = TraceState.trace_state.Value
        let v38 : string = method8(v20, v21, v22, v23, v24, v25)
        let v39 : string = method50()
        let v40 : int32 = v1.Length
        let v41 : string = method127(v20, v21, v22, v23, v24, v25, v38, v39, v0, v40)
        method19(v41)
and method120 (v0 : string, v1 : System.Threading.CancellationToken option, v2 : (struct (string * string) []), v3 : (struct (int32 * string * bool) -> Async<unit>) option, v4 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit) option, v5 : bool, v6 : string option) : Async<struct (int32 * string)> =
    let v7 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v8 : Async<struct (int32 * string)> = null |> unbox<Async<struct (int32 * string)>>
    let _v7 = v8 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v11 : Async<struct (int32 * string)> = null |> unbox<Async<struct (int32 * string)>>
    let _v7 = v11 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v14 : Async<struct (int32 * string)> = null |> unbox<Async<struct (int32 * string)>>
    let _v7 = v14 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v17 : Async<struct (int32 * string)> = null |> unbox<Async<struct (int32 * string)>>
    let _v7 = v17 
    #endif
#if FABLE_COMPILER_PYTHON
    let v20 : Async<struct (int32 * string)> = null |> unbox<Async<struct (int32 * string)>>
    let _v7 = v20 
    #endif
#else
    let v23 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v24 : Async<struct (int32 * string)> = null |> unbox<Async<struct (int32 * string)>>
    let _v23 = v24 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v27 : Async<struct (int32 * string)> = null |> unbox<Async<struct (int32 * string)>>
    let _v23 = v27 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v30 : Async<struct (int32 * string)> = null |> unbox<Async<struct (int32 * string)>>
    let _v23 = v30 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v33 : Async<struct (int32 * string)> = null |> unbox<Async<struct (int32 * string)>>
    let _v23 = v33 
    #endif
#if FABLE_COMPILER_PYTHON
    let v36 : Async<struct (int32 * string)> = null |> unbox<Async<struct (int32 * string)>>
    let _v23 = v36 
    #endif
#else
    let v39 : Async<struct (int32 * string)> option = None
    let mutable _v39 = v39 
    async {
    let v40 : US13 = method69(v0)
    let struct (v49 : string, v50 : US1) =
        match v40 with
        | US13_1(v43) -> (* Error *)
            let v44 : string = $"resultm.get / Result value was Error: {v43}"
            failwith<struct (string * US1)> v44
        | US13_0(v41, v42) -> (* Ok *)
            struct (v41, v42)
    let v51 : (string -> US1) = method5()
    let v52 : US1 option = v6 |> Option.map v51 
    let v63 : US1 = US1_1
    let v64 : US1 = v52 |> Option.defaultValue v63 
    let v71 : string =
        match v64 with
        | US1_1 -> (* None *)
            let v69 : string = ""
            v69
        | US1_0(v68) -> (* Some *)
            v68
    let v72 : unit = ()
    let v73 : (unit -> unit) = closure57(v0, v1, v2, v3, v4, v5, v6, v50, v49)
    let v74 : unit = (fun () -> v73 (); v72) ()
    let v114 : System.Text.Encoding = System.Text.Encoding.UTF8
    let v118 : string =
        match v50 with
        | US1_1 -> (* None *)
            let v116 : string = ""
            v116
        | US1_0(v115) -> (* Some *)
            v115
    let start_info = System.Diagnostics.ProcessStartInfo (
      Arguments = v118,
      StandardOutputEncoding = v114,
      WorkingDirectory = v71,
      FileName = v49,
      CreateNoWindow = true,
      RedirectStandardError = true,
      RedirectStandardOutput = true,
      UseShellExecute = false
    )
    let v119 : System.Diagnostics.ProcessStartInfo = start_info
    let v120 : int32 = v2.Length
    let v121 : Mut6 = {l0 = 0} : Mut6
    while method48(v120, v121) do
        let v123 : int32 = v121.l0
        let struct (v124 : string, v125 : string) = v2.[int v123]
        v119.EnvironmentVariables.[v124] <- v125 
        let v126 : int32 = v123 + 1
        v121.l0 <- v126
        ()
    let v127 : System.Diagnostics.Process = new System.Diagnostics.Process (StartInfo = v119)
    use v127 = v127 
    let v128 : System.Diagnostics.Process = v127 
    let v129 : (unit -> System.Collections.Concurrent.ConcurrentStack<string>) = System.Collections.Concurrent.ConcurrentStack<string>
    let v130 : System.Collections.Concurrent.ConcurrentStack<string> = v129 ()
    let v131 : (System.Diagnostics.DataReceivedEventArgs -> unit) = closure58(v0, v1, v2, v3, v4, v5, v6, v128, v130)
    v128.OutputDataReceived.Add v131 
    let v132 : (System.Diagnostics.DataReceivedEventArgs -> unit) = closure61(v0, v1, v2, v3, v4, v5, v6, v128, v130)
    v128.ErrorDataReceived.Add v132 
    let v133 : (unit -> bool) = v128.Start
    let v134 : bool = v133 ()
    let v135 : bool = v134 = false
    if v135 then
        let v136 : string = $"runtime.execute_with_options_async / process_start error"
        failwith<unit> v136
    let v137 : (unit -> unit) = v128.BeginErrorReadLine
    v137 ()
    let v138 : (unit -> unit) = v128.BeginOutputReadLine
    v138 ()
    let v139 : (System.Threading.CancellationToken -> US31) = method124()
    let v140 : US31 option = v1 |> Option.map v139 
    let v151 : US31 = US31_1
    let v152 : US31 = v140 |> Option.defaultValue v151 
    let v159 : System.Threading.CancellationToken =
        match v152 with
        | US31_1 -> (* None *)
            let v157 : System.Threading.CancellationToken = System.Threading.CancellationToken.None
            v157
        | US31_0(v156) -> (* Some *)
            v156
    let v160 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v161 : Async<System.Threading.CancellationToken> = null |> unbox<Async<System.Threading.CancellationToken>>
    let _v160 = v161 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v164 : Async<System.Threading.CancellationToken> = null |> unbox<Async<System.Threading.CancellationToken>>
    let _v160 = v164 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v167 : Async<System.Threading.CancellationToken> = null |> unbox<Async<System.Threading.CancellationToken>>
    let _v160 = v167 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v170 : Async<System.Threading.CancellationToken> = null |> unbox<Async<System.Threading.CancellationToken>>
    let _v160 = v170 
    #endif
#if FABLE_COMPILER_PYTHON
    let v173 : Async<System.Threading.CancellationToken> = null |> unbox<Async<System.Threading.CancellationToken>>
    let _v160 = v173 
    #endif
#else
    let v176 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v177 : Async<System.Threading.CancellationToken> = null |> unbox<Async<System.Threading.CancellationToken>>
    let _v176 = v177 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v180 : Async<System.Threading.CancellationToken> = null |> unbox<Async<System.Threading.CancellationToken>>
    let _v176 = v180 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v183 : Async<System.Threading.CancellationToken> = null |> unbox<Async<System.Threading.CancellationToken>>
    let _v176 = v183 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v186 : Async<System.Threading.CancellationToken> = null |> unbox<Async<System.Threading.CancellationToken>>
    let _v176 = v186 
    #endif
#if FABLE_COMPILER_PYTHON
    let v189 : Async<System.Threading.CancellationToken> = null |> unbox<Async<System.Threading.CancellationToken>>
    let _v176 = v189 
    #endif
#else
    let v192 : Async<System.Threading.CancellationToken> option = None
    let mutable _v192 = v192 
    async {
    let v193 : Async<System.Threading.CancellationToken> = Async.CancellationToken
    let! v193 = v193 
    let v194 : System.Threading.CancellationToken = v193 
    let v195 : System.Threading.CancellationToken = Async.DefaultCancellationToken
    let v196 : (System.Threading.CancellationToken []) = [|v194; v195; v159|]
    let v197 : ((System.Threading.CancellationToken []) -> System.Threading.CancellationTokenSource) = System.Threading.CancellationTokenSource.CreateLinkedTokenSource
    let v198 : System.Threading.CancellationTokenSource = v197 v196
    let v199 : System.Threading.CancellationToken = v198.Token
    return v199 
    }
    |> fun x -> _v192 <- Some x
    let v200 : Async<System.Threading.CancellationToken> = match _v192 with Some x -> x | None -> failwith "async.new_async_unit / _v192=None"
    let _v176 = v200 
    #endif
    let v201 : Async<System.Threading.CancellationToken> = _v176 
    let _v160 = v201 
    #endif
    let v206 : Async<System.Threading.CancellationToken> = _v160 
    let! v206 = v206 
    let v211 : System.Threading.CancellationToken = v206 
    let v212 : ((unit -> unit) -> System.Threading.CancellationTokenRegistration) = v211.Register
    let v213 : (unit -> unit) = closure63(v128)
    let v214 : System.Threading.CancellationTokenRegistration = v212 v213
    use v214 = v214 
    let v215 : System.Threading.CancellationTokenRegistration = v214 
    let v216 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v217 : Async<int32> = null |> unbox<Async<int32>>
    let _v216 = v217 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v220 : Async<int32> = null |> unbox<Async<int32>>
    let _v216 = v220 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v223 : Async<int32> = null |> unbox<Async<int32>>
    let _v216 = v223 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v226 : Async<int32> = null |> unbox<Async<int32>>
    let _v216 = v226 
    #endif
#if FABLE_COMPILER_PYTHON
    let v229 : Async<int32> = null |> unbox<Async<int32>>
    let _v216 = v229 
    #endif
#else
    let v232 : Async<int32> option = None
    let mutable _v232 = v232 
    async {
    try
    let v233 : System.Threading.Tasks.Task = v128.WaitForExitAsync v211 
    let v234 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v235 : Async<unit> = null |> unbox<Async<unit>>
    let _v234 = v235 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v238 : Async<unit> = null |> unbox<Async<unit>>
    let _v234 = v238 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v241 : Async<unit> = null |> unbox<Async<unit>>
    let _v234 = v241 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v244 : Async<unit> = null |> unbox<Async<unit>>
    let _v234 = v244 
    #endif
#if FABLE_COMPILER_PYTHON
    let v247 : Async<unit> = null |> unbox<Async<unit>>
    let _v234 = v247 
    #endif
#else
    let v250 : (System.Threading.Tasks.Task -> Async<unit>) = Async.AwaitTask
    let v251 : Async<unit> = v250 v233
    let _v234 = v251 
    #endif
    let v252 : Async<unit> = _v234 
    do! v252 
    let v257 : int32 = v128.ExitCode
    return v257 
    with ex ->
    let v258 : exn = ex
    let v259 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v260 : string = $"%A{v258}"
    let _v259 = v260 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v263 : string = $"%A{v258}"
    let _v259 = v263 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v266 : string = $"%A{v258}"
    let _v259 = v266 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v269 : string = $"%A{v258}"
    let _v259 = v269 
    #endif
#if FABLE_COMPILER_PYTHON
    let v272 : string = $"%A{v258}"
    let _v259 = v272 
    #endif
#else
    let v275 : string = $"{v258.GetType ()}: {v258.Message}"
    let _v259 = v275 
    #endif
    let v276 : string = _v259 
    let v281 : (string -> unit) = v130.Push
    v281 v276
    let v282 : System.Threading.Tasks.TaskCanceledException = v258 |> unbox<System.Threading.Tasks.TaskCanceledException>
    let v285 : unit = ()
    let v286 : (unit -> unit) = closure64(v282)
    let v287 : unit = (fun () -> v286 (); v285) ()
    return -2147483648 
    (*
    *)
    }
    |> fun x -> _v232 <- Some x
    let v327 : Async<int32> = match _v232 with Some x -> x | None -> failwith "async.new_async_unit / _v232=None"
    let _v216 = v327 
    #endif
    let v328 : Async<int32> = _v216 
    let! v328 = v328 
    let v333 : int32 = v328 
    let v334 : (System.Collections.Concurrent.ConcurrentStack<string> -> string seq) = Seq.rev
    let v335 : string seq = v334 v130
    let v338 : (string -> (string seq -> string)) = String.concat
    let v339 : string = "\n"
    let v340 : (string seq -> string) = v338 v339
    let v341 : string = v340 v335
    let v344 : unit = ()
    let v345 : (unit -> unit) = closure65(v333, v341)
    let v346 : unit = (fun () -> v345 (); v344) ()
    return struct (v333, v341) 
    }
    |> fun x -> _v39 <- Some x
    let v387 : Async<struct (int32 * string)> = match _v39 with Some x -> x | None -> failwith "async.new_async_unit / _v39=None"
    let _v23 = v387 
    #endif
    let v388 : Async<struct (int32 * string)> = _v23 
    let _v7 = v388 
    #endif
    let v393 : Async<struct (int32 * string)> = _v7 
    v393
and method67 (v0 : string, v1 : System.Threading.CancellationToken option, v2 : (struct (string * string) []), v3 : (struct (int32 * string * bool) -> Async<unit>) option, v4 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit) option, v5 : bool, v6 : string option) : struct (int32 * string) =
    let v7 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v8 : string = method68(v0, v1, v2, v3, v4, v5, v6)
    let v9 : US13 = method69(v8)
    let struct (v18 : string, v19 : US1) =
        match v9 with
        | US13_1(v12) -> (* Error *)
            let v13 : string = $"resultm.get / Result value was Error: {v12}"
            failwith<struct (string * US1)> v13
        | US13_0(v10, v11) -> (* Ok *)
            struct (v10, v11)
    let v23 : string =
        match v19 with
        | US1_1 -> (* None *)
            let v21 : string = ""
            v21
        | US1_0(v20) -> (* Some *)
            v20
    let v24 : US21 = method80(v23)
    let v30 : (string []) =
        match v24 with
        | US21_1(v26) -> (* Error *)
            let v27 : string = $"resultm.get / Result value was Error: {v26}"
            failwith<(string [])> v27
        | US21_0(v25) -> (* Ok *)
            v25
    let v31 : string = "$0.to_vec()"
    let v32 : Vec<string> = Fable.Core.RustInterop.emitRustExpr v30 v31 
    let v33 : string = "true; let _vec_map : Vec<_> = $0.into_iter().map(|x| { //"
    let v34 : bool = Fable.Core.RustInterop.emitRustExpr v32 v33 
    let v35 : string = "x"
    let v36 : string = Fable.Core.RustInterop.emitRustExpr () v35 
    let v37 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v38 : string = "&*$0"
    let v39 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v36 v38 
    let _v37 = v39 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v40 : string = "&*$0"
    let v41 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v36 v40 
    let _v37 = v41 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v42 : string = "&*$0"
    let v43 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v36 v42 
    let _v37 = v43 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v44 : Ref<Str> = v36 |> unbox<Ref<Str>>
    let _v37 = v44 
    #endif
#if FABLE_COMPILER_PYTHON
    let v47 : Ref<Str> = v36 |> unbox<Ref<Str>>
    let _v37 = v47 
    #endif
#else
    let v50 : Ref<Str> = v36 |> unbox<Ref<Str>>
    let _v37 = v50 
    #endif
    let v53 : Ref<Str> = _v37 
    let v58 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v59 : string = "String::from($0)"
    let v60 : std_string_String = Fable.Core.RustInterop.emitRustExpr v53 v59 
    let _v58 = v60 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v61 : string = "String::from($0)"
    let v62 : std_string_String = Fable.Core.RustInterop.emitRustExpr v53 v61 
    let _v58 = v62 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v63 : string = "String::from($0)"
    let v64 : std_string_String = Fable.Core.RustInterop.emitRustExpr v53 v63 
    let _v58 = v64 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v65 : std_string_String = v53 |> unbox<std_string_String>
    let _v58 = v65 
    #endif
#if FABLE_COMPILER_PYTHON
    let v68 : std_string_String = v53 |> unbox<std_string_String>
    let _v58 = v68 
    #endif
#else
    let v71 : std_string_String = v53 |> unbox<std_string_String>
    let _v58 = v71 
    #endif
    let v74 : std_string_String = _v58 
    let v79 : string = "true; $0 }).collect::<Vec<_>>()"
    let v80 : bool = Fable.Core.RustInterop.emitRustExpr v74 v79 
    let v81 : string = "_vec_map"
    let v82 : Vec<std_string_String> = Fable.Core.RustInterop.emitRustExpr () v81 
    let v83 : unit = ()
    let v84 : (unit -> unit) = closure37(v0, v1, v2, v3, v4, v5, v6, v18, v82)
    let v85 : unit = (fun () -> v84 (); v83) ()
    let v128 : bool = true
    let mutable _v128 : (int32 * string) option = None 
    (
    (fun () ->
    (fun () ->
    let v129 : string = "std::process::Command::new(&*$0)"
    let v130 : std_process_Command = Fable.Core.RustInterop.emitRustExpr v18 v129 
    let v131 : string = "true; let mut v130 = v130"
    let v132 : bool = Fable.Core.RustInterop.emitRustExpr () v131 
    let v133 : string = "std::process::Command::args(&mut $0, &*$1)"
    let v134 : Ref<Mut<std_process_Command>> = Fable.Core.RustInterop.emitRustExpr struct (v130, v82) v133 
    let v135 : string = "std::process::Stdio::piped()"
    let v136 : std_process_Stdio = Fable.Core.RustInterop.emitRustExpr () v135 
    let v137 : string = "std::process::Command::stdout($0, std::process::Stdio::piped())"
    let v138 : Ref<Mut<std_process_Command>> = Fable.Core.RustInterop.emitRustExpr v134 v137 
    let v139 : string = "std::process::Stdio::piped()"
    let v140 : std_process_Stdio = Fable.Core.RustInterop.emitRustExpr () v139 
    let v141 : string = "std::process::Command::stderr($0, std::process::Stdio::piped())"
    let v142 : Ref<Mut<std_process_Command>> = Fable.Core.RustInterop.emitRustExpr v138 v141 
    let v143 : string = "std::process::Stdio::piped()"
    let v144 : std_process_Stdio = Fable.Core.RustInterop.emitRustExpr () v143 
    let v145 : string = "std::process::Command::stdin($0, std::process::Stdio::piped())"
    let v146 : Ref<Mut<std_process_Command>> = Fable.Core.RustInterop.emitRustExpr v142 v145 
    let v147 : (string -> US1) = method5()
    let v148 : US1 option = v6 |> Option.map v147 
    let v159 : US1 = US1_1
    let v160 : US1 = v148 |> Option.defaultValue v159 
    let v168 : Ref<Mut<std_process_Command>> =
        match v160 with
        | US1_1 -> (* None *)
            v146
        | US1_0(v164) -> (* Some *)
            let v165 : string = "std::process::Command::current_dir(v146, &*$0)"
            let v166 : Ref<Mut<std_process_Command>> = Fable.Core.RustInterop.emitRustExpr v164 v165 
            v166
    let v169 : uint64 = System.Convert.ToUInt64 v2.Length
    let v170 : bool = v169 = 0UL
    let v186 : Ref<Mut<std_process_Command>> =
        if v170 then
            v168
        else
            let v171 : string = "$0.to_vec()"
            let v172 : Vec<struct (string * string)> = Fable.Core.RustInterop.emitRustExpr v2 v171 
            let v173 : string = "true; let _vec_fold_ = $0.into_iter().fold(v168, |acc, x| { //"
            let v174 : bool = Fable.Core.RustInterop.emitRustExpr v172 v173 
            let v175 : string = "acc"
            let v176 : Ref<Mut<std_process_Command>> = Fable.Core.RustInterop.emitRustExpr () v175 
            let v177 : string = "x"
            let struct (v178 : string, v179 : string) = Fable.Core.RustInterop.emitRustExpr () v177 
            let v180 : string = "std::process::Command::env(v176, &*$0, &*$1)"
            let v181 : Ref<Mut<std_process_Command>> = Fable.Core.RustInterop.emitRustExpr struct (v178, v179) v180 
            let v182 : string = "true; $0 })"
            let v183 : bool = Fable.Core.RustInterop.emitRustExpr v181 v182 
            let v184 : string = "_vec_fold_"
            let v185 : Ref<Mut<std_process_Command>> = Fable.Core.RustInterop.emitRustExpr () v184 
            v185
    let v187 : string = "std::process::Command::spawn($0)"
    let v188 : Result<std_process_Child, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v186 v187 
    let v189 : (std_io_Error -> std_string_String) = method54()
    let v190 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v191 : string = "$0.map_err(|x| $1(x))"
    let v192 : Result<std_process_Child, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v188, v189) v191 
    let _v190 = v192 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v193 : string = "$0.map_err(|x| $1(x))"
    let v194 : Result<std_process_Child, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v188, v189) v193 
    let _v190 = v194 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v195 : string = "$0.map_err(|x| $1(x))"
    let v196 : Result<std_process_Child, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v188, v189) v195 
    let _v190 = v196 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v197 : Result<std_process_Child, std_string_String> = match v188 with Ok x -> Ok x | Error x -> Error (v189 x)
    let _v190 = v197 
    #endif
#if FABLE_COMPILER_PYTHON
    let v198 : Result<std_process_Child, std_string_String> = match v188 with Ok x -> Ok x | Error x -> Error (v189 x)
    let _v190 = v198 
    #endif
#else
    let v199 : Result<std_process_Child, std_string_String> = match v188 with Ok x -> Ok x | Error x -> Error (v189 x)
    let _v190 = v199 
    #endif
    let v200 : Result<std_process_Child, std_string_String> = _v190 
    let v203 : (std_process_Child option -> std_process_Child option) = method93()
    let v204 : string = "true; let _result_map_ = $0.map(|x| { //"
    let v205 : bool = Fable.Core.RustInterop.emitRustExpr v200 v204 
    let v206 : string = "x"
    let v207 : std_process_Child = Fable.Core.RustInterop.emitRustExpr () v206 
    let v208 : std_process_Child option = Some v207 
    let v211 : std_process_Child option = v203 v208
    let v212 : string = "std::sync::Mutex::new(v211)"
    let v213 : std_sync_Mutex<std_process_Child option> = Fable.Core.RustInterop.emitRustExpr () v212 
    let v214 : string = "std::sync::Arc::new(v213)"
    let v215 : std_sync_Arc<std_sync_Mutex<std_process_Child option>> = Fable.Core.RustInterop.emitRustExpr () v214 
    let v216 : string = "true; $0 })"
    let v217 : bool = Fable.Core.RustInterop.emitRustExpr v215 v216 
    let v218 : string = "_result_map_"
    let v219 : Result<std_sync_Arc<std_sync_Mutex<std_process_Child option>>, std_string_String> = Fable.Core.RustInterop.emitRustExpr () v218 
    let v220 : (std_sync_Arc<std_sync_Mutex<std_process_Child option>> -> US23) = method94()
    let v221 : (std_string_String -> US23) = method95()
    let v222 : string = "match $2 { Ok(x) => $0(x), Err(e) => $1(e) }"
    let v223 : US23 = Fable.Core.RustInterop.emitRustExpr struct (v220, v221, v219) v222 
    let struct (v1328 : int32, v1329 : US4, v1330 : US24) =
        match v223 with
        | US23_1(v1280) -> (* Error *)
            let v1281 : unit = ()
            let v1282 : (unit -> unit) = closure41(v1280)
            let v1283 : unit = (fun () -> v1282 (); v1281) ()
            let v1323 : US4 = US4_0(v1280)
            let v1324 : US24 = US24_1
            struct (-1, v1323, v1324)
        | US23_0(v224) -> (* Ok *)
            let v225 : string = "true; let _capture = (|| { //"
            let v226 : bool = Fable.Core.RustInterop.emitRustExpr () v225 
            let v227 : string = "$0"
            let v228 : std_sync_Arc<std_sync_Mutex<std_process_Child option>> = Fable.Core.RustInterop.emitRustExpr v224 v227 
            let v229 : string = "v228.lock()"
            let v230 : Result<std_sync_MutexGuard<std_process_Child option>, std_sync_PoisonError<std_sync_MutexGuard<std_process_Child option>>> = Fable.Core.RustInterop.emitRustExpr () v229 
            let v231 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v232 : string = "$0.unwrap()"
            let v233 : std_sync_MutexGuard<std_process_Child option> = Fable.Core.RustInterop.emitRustExpr v230 v232 
            let _v231 = v233 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v234 : string = "$0.unwrap()"
            let v235 : std_sync_MutexGuard<std_process_Child option> = Fable.Core.RustInterop.emitRustExpr v230 v234 
            let _v231 = v235 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v236 : string = "$0.unwrap()"
            let v237 : std_sync_MutexGuard<std_process_Child option> = Fable.Core.RustInterop.emitRustExpr v230 v236 
            let _v231 = v237 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v238 : std_sync_MutexGuard<std_process_Child option> = match v230 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v231 = v238 
            #endif
#if FABLE_COMPILER_PYTHON
            let v239 : std_sync_MutexGuard<std_process_Child option> = match v230 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v231 = v239 
            #endif
#else
            let v240 : std_sync_MutexGuard<std_process_Child option> = match v230 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v231 = v240 
            #endif
            let v241 : std_sync_MutexGuard<std_process_Child option> = _v231 
            let v244 : std_sync_MutexGuard<std_process_Child option> = method97(v241)
            let v245 : string = "true; let mut v244 = v244"
            let v246 : bool = Fable.Core.RustInterop.emitRustExpr () v245 
            let v247 : string = "&mut $0"
            let v248 : Ref<Mut<std_process_Child option>> = Fable.Core.RustInterop.emitRustExpr v244 v247 
            let v249 : string = "$0.as_mut()"
            let v250 : Ref<Mut<std_process_Child>> option = Fable.Core.RustInterop.emitRustExpr v248 v249 
            let v251 : string = "$0.unwrap()"
            let v252 : Ref<Mut<std_process_Child>> = Fable.Core.RustInterop.emitRustExpr v250 v251 
            let v253 : string = "&mut $0.stdout"
            let v254 : Ref<Mut<std_process_ChildStdout option>> = Fable.Core.RustInterop.emitRustExpr v252 v253 
            let v255 : string = "Option::take($0)"
            let v256 : std_process_ChildStdout option = Fable.Core.RustInterop.emitRustExpr v254 v255 
            let v257 : string = "$0.unwrap()"
            let v258 : std_process_ChildStdout = Fable.Core.RustInterop.emitRustExpr v256 v257 
            let v259 : string = "true; $0 })()"
            let v260 : bool = Fable.Core.RustInterop.emitRustExpr v258 v259 
            let v261 : string = "_capture"
            let v262 : std_process_ChildStdout = Fable.Core.RustInterop.emitRustExpr () v261 
            let v263 : string = "true; let _capture = (|| { //"
            let v264 : bool = Fable.Core.RustInterop.emitRustExpr () v263 
            let v265 : string = "$0"
            let v266 : std_sync_Arc<std_sync_Mutex<std_process_Child option>> = Fable.Core.RustInterop.emitRustExpr v224 v265 
            let v267 : string = "v266.lock()"
            let v268 : Result<std_sync_MutexGuard<std_process_Child option>, std_sync_PoisonError<std_sync_MutexGuard<std_process_Child option>>> = Fable.Core.RustInterop.emitRustExpr () v267 
            let v269 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v270 : string = "$0.unwrap()"
            let v271 : std_sync_MutexGuard<std_process_Child option> = Fable.Core.RustInterop.emitRustExpr v268 v270 
            let _v269 = v271 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v272 : string = "$0.unwrap()"
            let v273 : std_sync_MutexGuard<std_process_Child option> = Fable.Core.RustInterop.emitRustExpr v268 v272 
            let _v269 = v273 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v274 : string = "$0.unwrap()"
            let v275 : std_sync_MutexGuard<std_process_Child option> = Fable.Core.RustInterop.emitRustExpr v268 v274 
            let _v269 = v275 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v276 : std_sync_MutexGuard<std_process_Child option> = match v268 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v269 = v276 
            #endif
#if FABLE_COMPILER_PYTHON
            let v277 : std_sync_MutexGuard<std_process_Child option> = match v268 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v269 = v277 
            #endif
#else
            let v278 : std_sync_MutexGuard<std_process_Child option> = match v268 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v269 = v278 
            #endif
            let v279 : std_sync_MutexGuard<std_process_Child option> = _v269 
            let v282 : std_sync_MutexGuard<std_process_Child option> = method97(v279)
            let v283 : string = "true; let mut v282 = v282"
            let v284 : bool = Fable.Core.RustInterop.emitRustExpr () v283 
            let v285 : string = "&mut $0"
            let v286 : Ref<Mut<std_process_Child option>> = Fable.Core.RustInterop.emitRustExpr v282 v285 
            let v287 : string = "$0.as_mut()"
            let v288 : Ref<Mut<std_process_Child>> option = Fable.Core.RustInterop.emitRustExpr v286 v287 
            let v289 : string = "$0.unwrap()"
            let v290 : Ref<Mut<std_process_Child>> = Fable.Core.RustInterop.emitRustExpr v288 v289 
            let v291 : string = "&mut $0.stderr"
            let v292 : Ref<Mut<std_process_ChildStderr option>> = Fable.Core.RustInterop.emitRustExpr v290 v291 
            let v293 : string = "Option::take($0)"
            let v294 : std_process_ChildStderr option = Fable.Core.RustInterop.emitRustExpr v292 v293 
            let v295 : string = "$0.unwrap()"
            let v296 : std_process_ChildStderr = Fable.Core.RustInterop.emitRustExpr v294 v295 
            let v297 : string = "true; $0 })()"
            let v298 : bool = Fable.Core.RustInterop.emitRustExpr v296 v297 
            let v299 : string = "_capture"
            let v300 : std_process_ChildStderr = Fable.Core.RustInterop.emitRustExpr () v299 
            let v301 : string = "true; let _capture = (|| { //"
            let v302 : bool = Fable.Core.RustInterop.emitRustExpr () v301 
            let v303 : string = "$0"
            let v304 : std_sync_Arc<std_sync_Mutex<std_process_Child option>> = Fable.Core.RustInterop.emitRustExpr v224 v303 
            let v305 : string = "v304.lock()"
            let v306 : Result<std_sync_MutexGuard<std_process_Child option>, std_sync_PoisonError<std_sync_MutexGuard<std_process_Child option>>> = Fable.Core.RustInterop.emitRustExpr () v305 
            let v307 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v308 : string = "$0.unwrap()"
            let v309 : std_sync_MutexGuard<std_process_Child option> = Fable.Core.RustInterop.emitRustExpr v306 v308 
            let _v307 = v309 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v310 : string = "$0.unwrap()"
            let v311 : std_sync_MutexGuard<std_process_Child option> = Fable.Core.RustInterop.emitRustExpr v306 v310 
            let _v307 = v311 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v312 : string = "$0.unwrap()"
            let v313 : std_sync_MutexGuard<std_process_Child option> = Fable.Core.RustInterop.emitRustExpr v306 v312 
            let _v307 = v313 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v314 : std_sync_MutexGuard<std_process_Child option> = match v306 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v307 = v314 
            #endif
#if FABLE_COMPILER_PYTHON
            let v315 : std_sync_MutexGuard<std_process_Child option> = match v306 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v307 = v315 
            #endif
#else
            let v316 : std_sync_MutexGuard<std_process_Child option> = match v306 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v307 = v316 
            #endif
            let v317 : std_sync_MutexGuard<std_process_Child option> = _v307 
            let v320 : std_sync_MutexGuard<std_process_Child option> = method97(v317)
            let v321 : string = "true; let mut v320 = v320"
            let v322 : bool = Fable.Core.RustInterop.emitRustExpr () v321 
            let v323 : string = "&mut $0"
            let v324 : Ref<Mut<std_process_Child option>> = Fable.Core.RustInterop.emitRustExpr v320 v323 
            let v325 : string = "$0.as_mut()"
            let v326 : Ref<Mut<std_process_Child>> option = Fable.Core.RustInterop.emitRustExpr v324 v325 
            let v327 : string = "$0.unwrap()"
            let v328 : Ref<Mut<std_process_Child>> = Fable.Core.RustInterop.emitRustExpr v326 v327 
            let v329 : string = "&mut $0.stdin"
            let v330 : Ref<Mut<std_process_ChildStdin option>> = Fable.Core.RustInterop.emitRustExpr v328 v329 
            let v331 : string = "Option::take($0)"
            let v332 : std_process_ChildStdin option = Fable.Core.RustInterop.emitRustExpr v330 v331 
            let v333 : string = "$0.unwrap()"
            let v334 : std_process_ChildStdin = Fable.Core.RustInterop.emitRustExpr v332 v333 
            let v335 : std_process_ChildStdin option = Some v334 
            let v338 : (std_process_ChildStdin option -> std_process_ChildStdin option) = method98()
            let v339 : std_process_ChildStdin option = v338 v335
            let v340 : string = "std::sync::Mutex::new(v339)"
            let v341 : std_sync_Mutex<std_process_ChildStdin option> = Fable.Core.RustInterop.emitRustExpr () v340 
            let v342 : string = "std::sync::Arc::new(v341)"
            let v343 : std_sync_Arc<std_sync_Mutex<std_process_ChildStdin option>> = Fable.Core.RustInterop.emitRustExpr () v342 
            let v344 : string = "true; $0 })()"
            let v345 : bool = Fable.Core.RustInterop.emitRustExpr v343 v344 
            let v346 : string = "_capture"
            let v347 : std_sync_Arc<std_sync_Mutex<std_process_ChildStdin option>> = Fable.Core.RustInterop.emitRustExpr () v346 
            let v348 : string = "{ let (sender, receiver) = std::sync::mpsc::channel(); (sender, std::sync::Arc::new(receiver)) }"
            let struct (v349 : std_sync_mpsc_Sender<std_string_String>, v350 : std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>) = Fable.Core.RustInterop.emitRustExpr () v348 
            let v351 : (std_sync_mpsc_Sender<std_string_String> -> std_sync_mpsc_Sender<std_string_String>) = method99()
            let v352 : std_sync_mpsc_Sender<std_string_String> = v351 v349
            let v353 : string = "std::sync::Mutex::new(v352)"
            let v354 : std_sync_Mutex<std_sync_mpsc_Sender<std_string_String>> = Fable.Core.RustInterop.emitRustExpr () v353 
            let v355 : string = "std::sync::Arc::new(v354)"
            let v356 : std_sync_Arc<std_sync_Mutex<std_sync_mpsc_Sender<std_string_String>>> = Fable.Core.RustInterop.emitRustExpr () v355 
            let v357 : (std_sync_mpsc_Sender<std_string_String> -> std_sync_mpsc_Sender<std_string_String>) = method100()
            let v358 : std_sync_mpsc_Sender<std_string_String> = v357 v349
            let v359 : string = "std::sync::Mutex::new(v358)"
            let v360 : std_sync_Mutex<std_sync_mpsc_Sender<std_string_String>> = Fable.Core.RustInterop.emitRustExpr () v359 
            let v361 : string = "std::sync::Arc::new(v360)"
            let v362 : std_sync_Arc<std_sync_Mutex<std_sync_mpsc_Sender<std_string_String>>> = Fable.Core.RustInterop.emitRustExpr () v361 
            let v363 : (std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>> -> std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>) = method101()
            let v364 : std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>> = v363 v350
            let v365 : string = "std::sync::Mutex::new(v364)"
            let v366 : std_sync_Mutex<std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>> = Fable.Core.RustInterop.emitRustExpr () v365 
            let v367 : string = "std::sync::Arc::new(v366)"
            let v368 : std_sync_Arc<std_sync_Mutex<std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>>> = Fable.Core.RustInterop.emitRustExpr () v367 
            let v369 : string = "true; let __spawn = std::thread::spawn(move || { //"
            let v370 : bool = Fable.Core.RustInterop.emitRustExpr () v369 
            let v371 : string = "encoding_rs_io::DecodeReaderBytesBuilder::new().utf8_passthru(true).build($0)"
            let v372 : encoding_rs_io_DecodeReaderBytes<std_process_ChildStdout, Vec<uint8>> = Fable.Core.RustInterop.emitRustExpr v262 v371 
            let v373 : string = "std::io::BufReader::new($0)"
            let v374 : std_io_BufReader<encoding_rs_io_DecodeReaderBytes<std_process_ChildStdout, Vec<uint8>>> = Fable.Core.RustInterop.emitRustExpr v372 v373 
            let v375 : string = "std::io::BufRead::lines(v374)"
            let v376 : std_io_Lines<std_io_BufReader<encoding_rs_io_DecodeReaderBytes<std_process_ChildStdout, Vec<uint8>>>> = Fable.Core.RustInterop.emitRustExpr () v375 
            let v377 : string = "true; let mut v376 = v376; let _iter_try_for_each = v376.try_for_each(|x| { //"
            let v378 : bool = Fable.Core.RustInterop.emitRustExpr () v377 
            let v379 : string = "x"
            let v380 : Result<std_string_String, std_io_Error> = Fable.Core.RustInterop.emitRustExpr () v379 
            let v381 : string = "$0.clone()"
            let v382 : std_sync_Arc<std_sync_Mutex<std_sync_mpsc_Sender<std_string_String>>> = Fable.Core.RustInterop.emitRustExpr v356 v381 
            let v383 : (std_io_Error -> std_string_String) = method54()
            let v384 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v385 : string = "$0.map_err(|x| $1(x))"
            let v386 : Result<std_string_String, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v380, v383) v385 
            let _v384 = v386 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v387 : string = "$0.map_err(|x| $1(x))"
            let v388 : Result<std_string_String, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v380, v383) v387 
            let _v384 = v388 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v389 : string = "$0.map_err(|x| $1(x))"
            let v390 : Result<std_string_String, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v380, v383) v389 
            let _v384 = v390 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v391 : Result<std_string_String, std_string_String> = match v380 with Ok x -> Ok x | Error x -> Error (v383 x)
            let _v384 = v391 
            #endif
#if FABLE_COMPILER_PYTHON
            let v392 : Result<std_string_String, std_string_String> = match v380 with Ok x -> Ok x | Error x -> Error (v383 x)
            let _v384 = v392 
            #endif
#else
            let v393 : Result<std_string_String, std_string_String> = match v380 with Ok x -> Ok x | Error x -> Error (v383 x)
            let _v384 = v393 
            #endif
            let v394 : Result<std_string_String, std_string_String> = _v384 
            let v397 : (std_string_String -> US25) = method102()
            let v398 : (std_string_String -> US25) = method103()
            let v399 : string = "match $2 { Ok(x) => $0(x), Err(e) => $1(e) }"
            let v400 : US25 = Fable.Core.RustInterop.emitRustExpr struct (v397, v398, v394) v399 
            let v589 : std_string_String =
                match v400 with
                | US25_1(v498) -> (* Error *)
                    let v499 : unit = ()
                    let v500 : (unit -> unit) = closure47(v498)
                    let v501 : unit = (fun () -> v500 (); v499) ()
                    let v545 : string = $"\u001b[4;7m{v498}\u001b[0m"
                    let v546 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v547 : string = "&*$0"
                    let v548 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v545 v547 
                    let _v546 = v548 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v549 : string = "&*$0"
                    let v550 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v545 v549 
                    let _v546 = v550 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v551 : string = "&*$0"
                    let v552 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v545 v551 
                    let _v546 = v552 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v553 : Ref<Str> = v545 |> unbox<Ref<Str>>
                    let _v546 = v553 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v556 : Ref<Str> = v545 |> unbox<Ref<Str>>
                    let _v546 = v556 
                    #endif
#else
                    let v559 : Ref<Str> = v545 |> unbox<Ref<Str>>
                    let _v546 = v559 
                    #endif
                    let v562 : Ref<Str> = _v546 
                    let v567 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v568 : string = "String::from($0)"
                    let v569 : std_string_String = Fable.Core.RustInterop.emitRustExpr v562 v568 
                    let _v567 = v569 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v570 : string = "String::from($0)"
                    let v571 : std_string_String = Fable.Core.RustInterop.emitRustExpr v562 v570 
                    let _v567 = v571 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v572 : string = "String::from($0)"
                    let v573 : std_string_String = Fable.Core.RustInterop.emitRustExpr v562 v572 
                    let _v567 = v573 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v574 : std_string_String = v562 |> unbox<std_string_String>
                    let _v567 = v574 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v577 : std_string_String = v562 |> unbox<std_string_String>
                    let _v567 = v577 
                    #endif
#else
                    let v580 : std_string_String = v562 |> unbox<std_string_String>
                    let _v567 = v580 
                    #endif
                    let v583 : std_string_String = _v567 
                    v583
                | US25_0(v401) -> (* Ok *)
                    let v402 : string = "fable_library_rust::String_::fromString($0)"
                    let v403 : string = Fable.Core.RustInterop.emitRustExpr v401 v402 
                    let v404 : string = "encoding_rs::UTF_8"
                    let v405 : Ref<encoding_rs_Encoding> = Fable.Core.RustInterop.emitRustExpr () v404 
                    let v406 : string = "$0.encode(&*$1).0"
                    let v407 : std_borrow_Cow<Slice<uint8>> = Fable.Core.RustInterop.emitRustExpr struct (v405, v403) v406 
                    let v408 : string = "$0.as_ref()"
                    let v409 : Ref<Slice<uint8>> = Fable.Core.RustInterop.emitRustExpr v407 v408 
                    let v410 : string = "std::str::from_utf8($0)"
                    let v411 : Result<Ref<Str>, std_str_Utf8Error> = Fable.Core.RustInterop.emitRustExpr v409 v410 
                    let v412 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v413 : string = "$0.unwrap()"
                    let v414 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v411 v413 
                    let _v412 = v414 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v415 : string = "$0.unwrap()"
                    let v416 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v411 v415 
                    let _v412 = v416 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v417 : string = "$0.unwrap()"
                    let v418 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v411 v417 
                    let _v412 = v418 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v419 : Ref<Str> = match v411 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
                    let _v412 = v419 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v420 : Ref<Str> = match v411 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
                    let _v412 = v420 
                    #endif
#else
                    let v421 : Ref<Str> = match v411 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
                    let _v412 = v421 
                    #endif
                    let v422 : Ref<Str> = _v412 
                    let v425 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v426 : string = "String::from($0)"
                    let v427 : std_string_String = Fable.Core.RustInterop.emitRustExpr v422 v426 
                    let _v425 = v427 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v428 : string = "String::from($0)"
                    let v429 : std_string_String = Fable.Core.RustInterop.emitRustExpr v422 v428 
                    let _v425 = v429 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v430 : string = "String::from($0)"
                    let v431 : std_string_String = Fable.Core.RustInterop.emitRustExpr v422 v430 
                    let _v425 = v431 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v432 : std_string_String = v422 |> unbox<std_string_String>
                    let _v425 = v432 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v435 : std_string_String = v422 |> unbox<std_string_String>
                    let _v425 = v435 
                    #endif
#else
                    let v438 : std_string_String = v422 |> unbox<std_string_String>
                    let _v425 = v438 
                    #endif
                    let v441 : std_string_String = _v425 
                    let v446 : string = "fable_library_rust::String_::fromString($0)"
                    let v447 : string = Fable.Core.RustInterop.emitRustExpr v441 v446 
                    let v448 : string = $"> {v447}"
                    if v5 then
                        let v449 : unit = ()
                        let v450 : (unit -> unit) = closure48(v448)
                        let v451 : unit = (fun () -> v450 (); v449) ()
                        ()
                    else
                        let v494 : unit = ()
                        let v495 : (unit -> unit) = closure11(v448)
                        let v496 : unit = (fun () -> v495 (); v494) ()
                        ()
                    v441
            let v590 : string = "$0"
            let v591 : std_sync_Arc<std_sync_Mutex<std_sync_mpsc_Sender<std_string_String>>> = Fable.Core.RustInterop.emitRustExpr v382 v590 
            let v592 : string = "v591.lock()"
            let v593 : Result<std_sync_MutexGuard<std_sync_mpsc_Sender<std_string_String>>, std_sync_PoisonError<std_sync_MutexGuard<std_sync_mpsc_Sender<std_string_String>>>> = Fable.Core.RustInterop.emitRustExpr () v592 
            let v594 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v595 : string = "$0.unwrap()"
            let v596 : std_sync_MutexGuard<std_sync_mpsc_Sender<std_string_String>> = Fable.Core.RustInterop.emitRustExpr v593 v595 
            let _v594 = v596 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v597 : string = "$0.unwrap()"
            let v598 : std_sync_MutexGuard<std_sync_mpsc_Sender<std_string_String>> = Fable.Core.RustInterop.emitRustExpr v593 v597 
            let _v594 = v598 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v599 : string = "$0.unwrap()"
            let v600 : std_sync_MutexGuard<std_sync_mpsc_Sender<std_string_String>> = Fable.Core.RustInterop.emitRustExpr v593 v599 
            let _v594 = v600 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v601 : std_sync_MutexGuard<std_sync_mpsc_Sender<std_string_String>> = match v593 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v594 = v601 
            #endif
#if FABLE_COMPILER_PYTHON
            let v602 : std_sync_MutexGuard<std_sync_mpsc_Sender<std_string_String>> = match v593 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v594 = v602 
            #endif
#else
            let v603 : std_sync_MutexGuard<std_sync_mpsc_Sender<std_string_String>> = match v593 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v594 = v603 
            #endif
            let v604 : std_sync_MutexGuard<std_sync_mpsc_Sender<std_string_String>> = _v594 
            let v607 : string = "&$0"
            let v608 : Ref<std_sync_mpsc_Sender<std_string_String>> = Fable.Core.RustInterop.emitRustExpr v604 v607 
            let v609 : string = "$0.send($1)"
            let v610 : Result<unit, std_sync_mpsc_SendError<std_string_String>> = Fable.Core.RustInterop.emitRustExpr struct (v608, v589) v609 
            let v611 : (std_sync_mpsc_SendError<std_string_String> -> std_string_String) = method109()
            let v612 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v613 : string = "$0.map_err(|x| $1(x))"
            let v614 : Result<unit, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v610, v611) v613 
            let _v612 = v614 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v615 : string = "$0.map_err(|x| $1(x))"
            let v616 : Result<unit, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v610, v611) v615 
            let _v612 = v616 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v617 : string = "$0.map_err(|x| $1(x))"
            let v618 : Result<unit, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v610, v611) v617 
            let _v612 = v618 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v619 : Result<unit, std_string_String> = match v610 with Ok x -> Ok x | Error x -> Error (v611 x)
            let _v612 = v619 
            #endif
#if FABLE_COMPILER_PYTHON
            let v620 : Result<unit, std_string_String> = match v610 with Ok x -> Ok x | Error x -> Error (v611 x)
            let _v612 = v620 
            #endif
#else
            let v621 : Result<unit, std_string_String> = match v610 with Ok x -> Ok x | Error x -> Error (v611 x)
            let _v612 = v621 
            #endif
            let v622 : Result<unit, std_string_String> = _v612 
            let v625 : string = "$0"
            let v626 : core_ops_Try<unit> = Fable.Core.RustInterop.emitRustExpr v622 v625 
            let v627 : string = "true; $0 }); //"
            let v628 : bool = Fable.Core.RustInterop.emitRustExpr v626 v627 
            let v629 : string = "_iter_try_for_each.map_err(|x| x.into())"
            let v630 : Result<unit, string> = Fable.Core.RustInterop.emitRustExpr () v629 
            let v631 : Result<unit, string> = method110(v630)
            let v632 : string = ""
            let v633 : string = "}"
            let v634 : string = v632 + v633 
            let v635 : _ = v631 
            let v636 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v637 : string = $"true; let v635 = $0"
            let v638 : bool = Fable.Core.RustInterop.emitRustExpr v635 v637 
            let _v636 = v638 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v639 : string = $"true; let v635 = $0"
            let v640 : bool = Fable.Core.RustInterop.emitRustExpr v635 v639 
            let _v636 = v640 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v641 : string = $"true; let v635 = $0"
            let v642 : bool = Fable.Core.RustInterop.emitRustExpr v635 v641 
            let _v636 = v642 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v643 : bool = true
            let _v636 = v643 
            #endif
#if FABLE_COMPILER_PYTHON
            let v644 : bool = true
            let _v636 = v644 
            #endif
#else
            let v645 : bool = true
            let _v636 = v645 
            #endif
            let v646 : bool = _v636 
            let v649 : string = $"true; v635 " + v634 + "); " + v632 + " // rust.fix_closure'"
            let v650 : bool = Fable.Core.RustInterop.emitRustExpr () v649 
            let v651 : string = "__spawn"
            let v652 : std_thread_JoinHandle<Result<unit, string>> = Fable.Core.RustInterop.emitRustExpr () v651 
            let v653 : string = "true; let __spawn = std::thread::spawn(move || { //"
            let v654 : bool = Fable.Core.RustInterop.emitRustExpr () v653 
            let v655 : string = "encoding_rs_io::DecodeReaderBytesBuilder::new().utf8_passthru(true).build($0)"
            let v656 : encoding_rs_io_DecodeReaderBytes<std_process_ChildStderr, Vec<uint8>> = Fable.Core.RustInterop.emitRustExpr v300 v655 
            let v657 : string = "std::io::BufReader::new($0)"
            let v658 : std_io_BufReader<encoding_rs_io_DecodeReaderBytes<std_process_ChildStderr, Vec<uint8>>> = Fable.Core.RustInterop.emitRustExpr v656 v657 
            let v659 : string = "std::io::BufRead::lines(v658)"
            let v660 : std_io_Lines<std_io_BufReader<encoding_rs_io_DecodeReaderBytes<std_process_ChildStderr, Vec<uint8>>>> = Fable.Core.RustInterop.emitRustExpr () v659 
            let v661 : string = "true; let mut v660 = v660; let _iter_try_for_each = v660.try_for_each(|x| { //"
            let v662 : bool = Fable.Core.RustInterop.emitRustExpr () v661 
            let v663 : string = "x"
            let v664 : Result<std_string_String, std_io_Error> = Fable.Core.RustInterop.emitRustExpr () v663 
            let v665 : string = "$0.clone()"
            let v666 : std_sync_Arc<std_sync_Mutex<std_sync_mpsc_Sender<std_string_String>>> = Fable.Core.RustInterop.emitRustExpr v362 v665 
            let v667 : (std_io_Error -> std_string_String) = method54()
            let v668 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v669 : string = "$0.map_err(|x| $1(x))"
            let v670 : Result<std_string_String, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v664, v667) v669 
            let _v668 = v670 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v671 : string = "$0.map_err(|x| $1(x))"
            let v672 : Result<std_string_String, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v664, v667) v671 
            let _v668 = v672 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v673 : string = "$0.map_err(|x| $1(x))"
            let v674 : Result<std_string_String, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v664, v667) v673 
            let _v668 = v674 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v675 : Result<std_string_String, std_string_String> = match v664 with Ok x -> Ok x | Error x -> Error (v667 x)
            let _v668 = v675 
            #endif
#if FABLE_COMPILER_PYTHON
            let v676 : Result<std_string_String, std_string_String> = match v664 with Ok x -> Ok x | Error x -> Error (v667 x)
            let _v668 = v676 
            #endif
#else
            let v677 : Result<std_string_String, std_string_String> = match v664 with Ok x -> Ok x | Error x -> Error (v667 x)
            let _v668 = v677 
            #endif
            let v678 : Result<std_string_String, std_string_String> = _v668 
            let v681 : (std_string_String -> US25) = method102()
            let v682 : (std_string_String -> US25) = method103()
            let v683 : string = "match $2 { Ok(x) => $0(x), Err(e) => $1(e) }"
            let v684 : US25 = Fable.Core.RustInterop.emitRustExpr struct (v681, v682, v678) v683 
            let v914 : std_string_String =
                match v684 with
                | US25_1(v824) -> (* Error *)
                    let v825 : unit = ()
                    let v826 : (unit -> unit) = closure47(v824)
                    let v827 : unit = (fun () -> v826 (); v825) ()
                    let v870 : string = $"\u001b[4;7m{v824}\u001b[0m"
                    let v871 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v872 : string = "&*$0"
                    let v873 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v870 v872 
                    let _v871 = v873 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v874 : string = "&*$0"
                    let v875 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v870 v874 
                    let _v871 = v875 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v876 : string = "&*$0"
                    let v877 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v870 v876 
                    let _v871 = v877 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v878 : Ref<Str> = v870 |> unbox<Ref<Str>>
                    let _v871 = v878 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v881 : Ref<Str> = v870 |> unbox<Ref<Str>>
                    let _v871 = v881 
                    #endif
#else
                    let v884 : Ref<Str> = v870 |> unbox<Ref<Str>>
                    let _v871 = v884 
                    #endif
                    let v887 : Ref<Str> = _v871 
                    let v892 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v893 : string = "String::from($0)"
                    let v894 : std_string_String = Fable.Core.RustInterop.emitRustExpr v887 v893 
                    let _v892 = v894 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v895 : string = "String::from($0)"
                    let v896 : std_string_String = Fable.Core.RustInterop.emitRustExpr v887 v895 
                    let _v892 = v896 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v897 : string = "String::from($0)"
                    let v898 : std_string_String = Fable.Core.RustInterop.emitRustExpr v887 v897 
                    let _v892 = v898 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v899 : std_string_String = v887 |> unbox<std_string_String>
                    let _v892 = v899 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v902 : std_string_String = v887 |> unbox<std_string_String>
                    let _v892 = v902 
                    #endif
#else
                    let v905 : std_string_String = v887 |> unbox<std_string_String>
                    let _v892 = v905 
                    #endif
                    let v908 : std_string_String = _v892 
                    v908
                | US25_0(v685) -> (* Ok *)
                    let v686 : string = "fable_library_rust::String_::fromString($0)"
                    let v687 : string = Fable.Core.RustInterop.emitRustExpr v685 v686 
                    let v688 : string = "encoding_rs::UTF_8"
                    let v689 : Ref<encoding_rs_Encoding> = Fable.Core.RustInterop.emitRustExpr () v688 
                    let v690 : string = "$0.encode(&*$1).0"
                    let v691 : std_borrow_Cow<Slice<uint8>> = Fable.Core.RustInterop.emitRustExpr struct (v689, v687) v690 
                    let v692 : string = "$0.as_ref()"
                    let v693 : Ref<Slice<uint8>> = Fable.Core.RustInterop.emitRustExpr v691 v692 
                    let v694 : string = "std::str::from_utf8($0)"
                    let v695 : Result<Ref<Str>, std_str_Utf8Error> = Fable.Core.RustInterop.emitRustExpr v693 v694 
                    let v696 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v697 : string = "$0.unwrap()"
                    let v698 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v695 v697 
                    let _v696 = v698 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v699 : string = "$0.unwrap()"
                    let v700 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v695 v699 
                    let _v696 = v700 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v701 : string = "$0.unwrap()"
                    let v702 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v695 v701 
                    let _v696 = v702 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v703 : Ref<Str> = match v695 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
                    let _v696 = v703 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v704 : Ref<Str> = match v695 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
                    let _v696 = v704 
                    #endif
#else
                    let v705 : Ref<Str> = match v695 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
                    let _v696 = v705 
                    #endif
                    let v706 : Ref<Str> = _v696 
                    let v709 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v710 : string = "String::from($0)"
                    let v711 : std_string_String = Fable.Core.RustInterop.emitRustExpr v706 v710 
                    let _v709 = v711 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v712 : string = "String::from($0)"
                    let v713 : std_string_String = Fable.Core.RustInterop.emitRustExpr v706 v712 
                    let _v709 = v713 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v714 : string = "String::from($0)"
                    let v715 : std_string_String = Fable.Core.RustInterop.emitRustExpr v706 v714 
                    let _v709 = v715 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v716 : std_string_String = v706 |> unbox<std_string_String>
                    let _v709 = v716 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v719 : std_string_String = v706 |> unbox<std_string_String>
                    let _v709 = v719 
                    #endif
#else
                    let v722 : std_string_String = v706 |> unbox<std_string_String>
                    let _v709 = v722 
                    #endif
                    let v725 : std_string_String = _v709 
                    let v730 : string = "fable_library_rust::String_::fromString($0)"
                    let v731 : string = Fable.Core.RustInterop.emitRustExpr v725 v730 
                    let v732 : string = $"! {v731}"
                    if v5 then
                        let v733 : unit = ()
                        let v734 : (unit -> unit) = closure48(v732)
                        let v735 : unit = (fun () -> v734 (); v733) ()
                        ()
                    else
                        let v777 : unit = ()
                        let v778 : (unit -> unit) = closure11(v732)
                        let v779 : unit = (fun () -> v778 (); v777) ()
                        ()
                    let v781 : string = $"\u001b[4;7m{v725}\u001b[0m"
                    let v782 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v783 : string = "&*$0"
                    let v784 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v781 v783 
                    let _v782 = v784 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v785 : string = "&*$0"
                    let v786 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v781 v785 
                    let _v782 = v786 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v787 : string = "&*$0"
                    let v788 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v781 v787 
                    let _v782 = v788 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v789 : Ref<Str> = v781 |> unbox<Ref<Str>>
                    let _v782 = v789 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v792 : Ref<Str> = v781 |> unbox<Ref<Str>>
                    let _v782 = v792 
                    #endif
#else
                    let v795 : Ref<Str> = v781 |> unbox<Ref<Str>>
                    let _v782 = v795 
                    #endif
                    let v798 : Ref<Str> = _v782 
                    let v803 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v804 : string = "String::from($0)"
                    let v805 : std_string_String = Fable.Core.RustInterop.emitRustExpr v798 v804 
                    let _v803 = v805 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v806 : string = "String::from($0)"
                    let v807 : std_string_String = Fable.Core.RustInterop.emitRustExpr v798 v806 
                    let _v803 = v807 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v808 : string = "String::from($0)"
                    let v809 : std_string_String = Fable.Core.RustInterop.emitRustExpr v798 v808 
                    let _v803 = v809 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v810 : std_string_String = v798 |> unbox<std_string_String>
                    let _v803 = v810 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v813 : std_string_String = v798 |> unbox<std_string_String>
                    let _v803 = v813 
                    #endif
#else
                    let v816 : std_string_String = v798 |> unbox<std_string_String>
                    let _v803 = v816 
                    #endif
                    let v819 : std_string_String = _v803 
                    v819
            let v915 : string = "$0"
            let v916 : std_sync_Arc<std_sync_Mutex<std_sync_mpsc_Sender<std_string_String>>> = Fable.Core.RustInterop.emitRustExpr v666 v915 
            let v917 : string = "v916.lock()"
            let v918 : Result<std_sync_MutexGuard<std_sync_mpsc_Sender<std_string_String>>, std_sync_PoisonError<std_sync_MutexGuard<std_sync_mpsc_Sender<std_string_String>>>> = Fable.Core.RustInterop.emitRustExpr () v917 
            let v919 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v920 : string = "$0.unwrap()"
            let v921 : std_sync_MutexGuard<std_sync_mpsc_Sender<std_string_String>> = Fable.Core.RustInterop.emitRustExpr v918 v920 
            let _v919 = v921 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v922 : string = "$0.unwrap()"
            let v923 : std_sync_MutexGuard<std_sync_mpsc_Sender<std_string_String>> = Fable.Core.RustInterop.emitRustExpr v918 v922 
            let _v919 = v923 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v924 : string = "$0.unwrap()"
            let v925 : std_sync_MutexGuard<std_sync_mpsc_Sender<std_string_String>> = Fable.Core.RustInterop.emitRustExpr v918 v924 
            let _v919 = v925 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v926 : std_sync_MutexGuard<std_sync_mpsc_Sender<std_string_String>> = match v918 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v919 = v926 
            #endif
#if FABLE_COMPILER_PYTHON
            let v927 : std_sync_MutexGuard<std_sync_mpsc_Sender<std_string_String>> = match v918 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v919 = v927 
            #endif
#else
            let v928 : std_sync_MutexGuard<std_sync_mpsc_Sender<std_string_String>> = match v918 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v919 = v928 
            #endif
            let v929 : std_sync_MutexGuard<std_sync_mpsc_Sender<std_string_String>> = _v919 
            let v932 : string = "&$0"
            let v933 : Ref<std_sync_mpsc_Sender<std_string_String>> = Fable.Core.RustInterop.emitRustExpr v929 v932 
            let v934 : string = "$0.send($1)"
            let v935 : Result<unit, std_sync_mpsc_SendError<std_string_String>> = Fable.Core.RustInterop.emitRustExpr struct (v933, v914) v934 
            let v936 : (std_sync_mpsc_SendError<std_string_String> -> std_string_String) = method109()
            let v937 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v938 : string = "$0.map_err(|x| $1(x))"
            let v939 : Result<unit, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v935, v936) v938 
            let _v937 = v939 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v940 : string = "$0.map_err(|x| $1(x))"
            let v941 : Result<unit, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v935, v936) v940 
            let _v937 = v941 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v942 : string = "$0.map_err(|x| $1(x))"
            let v943 : Result<unit, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v935, v936) v942 
            let _v937 = v943 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v944 : Result<unit, std_string_String> = match v935 with Ok x -> Ok x | Error x -> Error (v936 x)
            let _v937 = v944 
            #endif
#if FABLE_COMPILER_PYTHON
            let v945 : Result<unit, std_string_String> = match v935 with Ok x -> Ok x | Error x -> Error (v936 x)
            let _v937 = v945 
            #endif
#else
            let v946 : Result<unit, std_string_String> = match v935 with Ok x -> Ok x | Error x -> Error (v936 x)
            let _v937 = v946 
            #endif
            let v947 : Result<unit, std_string_String> = _v937 
            let v950 : string = "$0"
            let v951 : core_ops_Try<unit> = Fable.Core.RustInterop.emitRustExpr v947 v950 
            let v952 : string = "true; $0 }); //"
            let v953 : bool = Fable.Core.RustInterop.emitRustExpr v951 v952 
            let v954 : string = "_iter_try_for_each.map_err(|x| x.into())"
            let v955 : Result<unit, string> = Fable.Core.RustInterop.emitRustExpr () v954 
            let v956 : Result<unit, string> = method110(v955)
            let v957 : string = v632 + v633 
            let v958 : _ = v956 
            let v959 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v960 : string = $"true; let v958 = $0"
            let v961 : bool = Fable.Core.RustInterop.emitRustExpr v958 v960 
            let _v959 = v961 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v962 : string = $"true; let v958 = $0"
            let v963 : bool = Fable.Core.RustInterop.emitRustExpr v958 v962 
            let _v959 = v963 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v964 : string = $"true; let v958 = $0"
            let v965 : bool = Fable.Core.RustInterop.emitRustExpr v958 v964 
            let _v959 = v965 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v966 : bool = true
            let _v959 = v966 
            #endif
#if FABLE_COMPILER_PYTHON
            let v967 : bool = true
            let _v959 = v967 
            #endif
#else
            let v968 : bool = true
            let _v959 = v968 
            #endif
            let v969 : bool = _v959 
            let v972 : string = $"true; v958 " + v957 + "); " + v632 + " // rust.fix_closure'"
            let v973 : bool = Fable.Core.RustInterop.emitRustExpr () v972 
            let v974 : string = "__spawn"
            let v975 : std_thread_JoinHandle<Result<unit, string>> = Fable.Core.RustInterop.emitRustExpr () v974 
            let v976 : ((std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit) -> US26) = method111()
            let v977 : US26 option = v4 |> Option.map v976 
            let v988 : US26 = US26_1
            let v989 : US26 = v977 |> Option.defaultValue v988 
            match v989 with
            | US26_1 -> (* None *)
                ()
            | US26_0(v993) -> (* Some *)
                let v994 : string = "$0"
                let v995 : std_sync_Arc<std_sync_Mutex<std_process_ChildStdin option>> = Fable.Core.RustInterop.emitRustExpr v347 v994 
                let v996 : string = "v995.lock()"
                let v997 : Result<std_sync_MutexGuard<std_process_ChildStdin option>, std_sync_PoisonError<std_sync_MutexGuard<std_process_ChildStdin option>>> = Fable.Core.RustInterop.emitRustExpr () v996 
                let v998 : unit = ()
                
#if FABLE_COMPILER || WASM || CONTRACT
                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                let v999 : string = "$0.unwrap()"
                let v1000 : std_sync_MutexGuard<std_process_ChildStdin option> = Fable.Core.RustInterop.emitRustExpr v997 v999 
                let _v998 = v1000 
                #endif
#if FABLE_COMPILER_RUST && WASM
                let v1001 : string = "$0.unwrap()"
                let v1002 : std_sync_MutexGuard<std_process_ChildStdin option> = Fable.Core.RustInterop.emitRustExpr v997 v1001 
                let _v998 = v1002 
                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                let v1003 : string = "$0.unwrap()"
                let v1004 : std_sync_MutexGuard<std_process_ChildStdin option> = Fable.Core.RustInterop.emitRustExpr v997 v1003 
                let _v998 = v1004 
                #endif
#if FABLE_COMPILER_TYPESCRIPT
                let v1005 : std_sync_MutexGuard<std_process_ChildStdin option> = match v997 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
                let _v998 = v1005 
                #endif
#if FABLE_COMPILER_PYTHON
                let v1006 : std_sync_MutexGuard<std_process_ChildStdin option> = match v997 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
                let _v998 = v1006 
                #endif
#else
                let v1007 : std_sync_MutexGuard<std_process_ChildStdin option> = match v997 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
                let _v998 = v1007 
                #endif
                let v1008 : std_sync_MutexGuard<std_process_ChildStdin option> = _v998 
                let v1011 : std_sync_MutexGuard<std_process_ChildStdin option> = method112(v1008)
                let v1012 : string = "true; let mut v1011 = v1011"
                let v1013 : bool = Fable.Core.RustInterop.emitRustExpr () v1012 
                let v1014 : string = "&mut $0"
                let v1015 : Ref<Mut<std_process_ChildStdin option>> = Fable.Core.RustInterop.emitRustExpr v1011 v1014 
                let v1016 : string = "Option::take($0)"
                let v1017 : std_process_ChildStdin option = Fable.Core.RustInterop.emitRustExpr v1015 v1016 
                let v1018 : string = "true; let _optionm_map_ = $0.map(|x| { //"
                let v1019 : bool = Fable.Core.RustInterop.emitRustExpr v1017 v1018 
                let v1020 : string = "x"
                let v1021 : std_process_ChildStdin = Fable.Core.RustInterop.emitRustExpr () v1020 
                let v1022 : string = "std::sync::Mutex::new(v1021)"
                let v1023 : std_sync_Mutex<std_process_ChildStdin> = Fable.Core.RustInterop.emitRustExpr () v1022 
                let v1024 : string = "std::sync::Arc::new(v1023)"
                let v1025 : std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> = Fable.Core.RustInterop.emitRustExpr () v1024 
                let v1026 : string = "true; $0 })"
                let v1027 : bool = Fable.Core.RustInterop.emitRustExpr v1025 v1026 
                let v1028 : string = "_optionm_map_"
                let v1029 : std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> option = Fable.Core.RustInterop.emitRustExpr () v1028 
                let v1030 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> US27) = method113()
                let v1031 : US27 option = v1029 |> Option.map v1030 
                let v1042 : US27 = US27_1
                let v1043 : US27 = v1031 |> Option.defaultValue v1042 
                match v1043 with
                | US27_1 -> (* None *)
                    ()
                | US27_0(v1047) -> (* Some *)
                    v993 v1047
                    let v1048 : string = "$0"
                    let v1049 : std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> = Fable.Core.RustInterop.emitRustExpr v1047 v1048 
                    let v1050 : string = "v1049.lock()"
                    let v1051 : Result<std_sync_MutexGuard<std_process_ChildStdin>, std_sync_PoisonError<std_sync_MutexGuard<std_process_ChildStdin>>> = Fable.Core.RustInterop.emitRustExpr () v1050 
                    let v1052 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v1053 : string = "$0.unwrap()"
                    let v1054 : std_sync_MutexGuard<std_process_ChildStdin> = Fable.Core.RustInterop.emitRustExpr v1051 v1053 
                    let _v1052 = v1054 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v1055 : string = "$0.unwrap()"
                    let v1056 : std_sync_MutexGuard<std_process_ChildStdin> = Fable.Core.RustInterop.emitRustExpr v1051 v1055 
                    let _v1052 = v1056 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v1057 : string = "$0.unwrap()"
                    let v1058 : std_sync_MutexGuard<std_process_ChildStdin> = Fable.Core.RustInterop.emitRustExpr v1051 v1057 
                    let _v1052 = v1058 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v1059 : std_sync_MutexGuard<std_process_ChildStdin> = match v1051 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
                    let _v1052 = v1059 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v1060 : std_sync_MutexGuard<std_process_ChildStdin> = match v1051 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
                    let _v1052 = v1060 
                    #endif
#else
                    let v1061 : std_sync_MutexGuard<std_process_ChildStdin> = match v1051 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
                    let _v1052 = v1061 
                    #endif
                    let v1062 : std_sync_MutexGuard<std_process_ChildStdin> = _v1052 
                    let v1065 : std_sync_MutexGuard<std_process_ChildStdin> = method114(v1062)
                    let v1066 : string = "true; let mut v1065 = v1065"
                    let v1067 : bool = Fable.Core.RustInterop.emitRustExpr () v1066 
                    let v1068 : string = "true; std::io::Write::flush(&mut *$0).unwrap()"
                    let v1069 : bool = Fable.Core.RustInterop.emitRustExpr v1065 v1068 
                    ()
            let v1070 : string = "$0"
            let v1071 : std_sync_Arc<std_sync_Mutex<std_process_Child option>> = Fable.Core.RustInterop.emitRustExpr v224 v1070 
            let v1072 : string = "v1071.lock()"
            let v1073 : Result<std_sync_MutexGuard<std_process_Child option>, std_sync_PoisonError<std_sync_MutexGuard<std_process_Child option>>> = Fable.Core.RustInterop.emitRustExpr () v1072 
            let v1074 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v1075 : string = "$0.unwrap()"
            let v1076 : std_sync_MutexGuard<std_process_Child option> = Fable.Core.RustInterop.emitRustExpr v1073 v1075 
            let _v1074 = v1076 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v1077 : string = "$0.unwrap()"
            let v1078 : std_sync_MutexGuard<std_process_Child option> = Fable.Core.RustInterop.emitRustExpr v1073 v1077 
            let _v1074 = v1078 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v1079 : string = "$0.unwrap()"
            let v1080 : std_sync_MutexGuard<std_process_Child option> = Fable.Core.RustInterop.emitRustExpr v1073 v1079 
            let _v1074 = v1080 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v1081 : std_sync_MutexGuard<std_process_Child option> = match v1073 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v1074 = v1081 
            #endif
#if FABLE_COMPILER_PYTHON
            let v1082 : std_sync_MutexGuard<std_process_Child option> = match v1073 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v1074 = v1082 
            #endif
#else
            let v1083 : std_sync_MutexGuard<std_process_Child option> = match v1073 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v1074 = v1083 
            #endif
            let v1084 : std_sync_MutexGuard<std_process_Child option> = _v1074 
            let v1087 : std_sync_MutexGuard<std_process_Child option> = method97(v1084)
            let v1088 : string = "true; let mut v1087 = v1087"
            let v1089 : bool = Fable.Core.RustInterop.emitRustExpr () v1088 
            let v1090 : string = "&mut $0"
            let v1091 : Ref<Mut<std_process_Child option>> = Fable.Core.RustInterop.emitRustExpr v1087 v1090 
            let v1092 : string = "Option::take($0)"
            let v1093 : std_process_Child option = Fable.Core.RustInterop.emitRustExpr v1091 v1092 
            let v1094 : string = "$0.unwrap()"
            let v1095 : std_process_Child = Fable.Core.RustInterop.emitRustExpr v1093 v1094 
            let v1096 : string = "$0.wait_with_output()"
            let v1097 : Result<std_process_Output, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1095 v1096 
            let v1098 : (std_io_Error -> std_string_String) = method54()
            let v1099 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v1100 : string = "$0.map_err(|x| $1(x))"
            let v1101 : Result<std_process_Output, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v1097, v1098) v1100 
            let _v1099 = v1101 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v1102 : string = "$0.map_err(|x| $1(x))"
            let v1103 : Result<std_process_Output, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v1097, v1098) v1102 
            let _v1099 = v1103 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v1104 : string = "$0.map_err(|x| $1(x))"
            let v1105 : Result<std_process_Output, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v1097, v1098) v1104 
            let _v1099 = v1105 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v1106 : Result<std_process_Output, std_string_String> = match v1097 with Ok x -> Ok x | Error x -> Error (v1098 x)
            let _v1099 = v1106 
            #endif
#if FABLE_COMPILER_PYTHON
            let v1107 : Result<std_process_Output, std_string_String> = match v1097 with Ok x -> Ok x | Error x -> Error (v1098 x)
            let _v1099 = v1107 
            #endif
#else
            let v1108 : Result<std_process_Output, std_string_String> = match v1097 with Ok x -> Ok x | Error x -> Error (v1098 x)
            let _v1099 = v1108 
            #endif
            let v1109 : Result<std_process_Output, std_string_String> = _v1099 
            let v1112 : std_thread_JoinHandle<Result<unit, string>> = method115(v975)
            let v1113 : string = "v1112"
            let v1114 : string = v1113 + v632 
            let v1115 : string = v1114 + v632 
            let v1116 : std_thread_JoinHandle<Result<unit, string>> = method115(v652)
            let v1117 : string = "v1116"
            let v1118 : string = ", "
            let v1119 : string = v1117 + v1118 
            let v1120 : string = v1119 + v1115 
            let v1121 : string = "vec![" + v1120 + "]"
            let v1122 : Vec<std_thread_JoinHandle<Result<unit, string>>> = Fable.Core.RustInterop.emitRustExpr () v1121 
            let v1123 : string = "true; $0.into_iter().for_each(|x| { //"
            let v1124 : bool = Fable.Core.RustInterop.emitRustExpr v1122 v1123 
            let v1125 : string = "x"
            let v1126 : std_thread_JoinHandle<Result<unit, string>> = Fable.Core.RustInterop.emitRustExpr () v1125 
            let v1127 : string = "std::thread::JoinHandle::join($0)"
            let v1128 : Result<Result<unit, string>, Box<LifetimeRef<Dyn<LifetimeJoin<core_any_Any, LifetimeRef<LifetimeJoin<StaticLifetime, Send<StaticLifetime>>>>>>>> = Fable.Core.RustInterop.emitRustExpr v1126 v1127 
            let v1129 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v1130 : string = "$0.unwrap()"
            let v1131 : Result<unit, string> = Fable.Core.RustInterop.emitRustExpr v1128 v1130 
            let _v1129 = v1131 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v1132 : string = "$0.unwrap()"
            let v1133 : Result<unit, string> = Fable.Core.RustInterop.emitRustExpr v1128 v1132 
            let _v1129 = v1133 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v1134 : string = "$0.unwrap()"
            let v1135 : Result<unit, string> = Fable.Core.RustInterop.emitRustExpr v1128 v1134 
            let _v1129 = v1135 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v1136 : Result<unit, string> = match v1128 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v1129 = v1136 
            #endif
#if FABLE_COMPILER_PYTHON
            let v1137 : Result<unit, string> = match v1128 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v1129 = v1137 
            #endif
#else
            let v1138 : Result<unit, string> = match v1128 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v1129 = v1138 
            #endif
            let v1139 : Result<unit, string> = _v1129 
            let v1142 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v1143 : string = "$0.unwrap()"
            Fable.Core.RustInterop.emitRustExpr v1139 v1143 
            let _v1142 = () 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v1144 : string = "$0.unwrap()"
            Fable.Core.RustInterop.emitRustExpr v1139 v1144 
            let _v1142 = () 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v1145 : string = "$0.unwrap()"
            Fable.Core.RustInterop.emitRustExpr v1139 v1145 
            let _v1142 = () 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            match v1139 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v1142 = () 
            #endif
#if FABLE_COMPILER_PYTHON
            match v1139 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v1142 = () 
            #endif
#else
            match v1139 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v1142 = () 
            #endif
            _v1142 
            let v1146 : string = $"true"
            let v1147 : bool = Fable.Core.RustInterop.emitRustExpr () v1146 
            let v1148 : string = "true; }}); { //"
            let v1149 : bool = Fable.Core.RustInterop.emitRustExpr () v1148 
            let v1150 : (std_process_Output -> US28) = closure52()
            let v1151 : (std_string_String -> US28) = closure53()
            let v1152 : US28 = match v1109 with Ok x -> v1150 x | Error x -> v1151 x
            match v1152 with
            | US28_1(v1229) -> (* Error *)
                let v1230 : unit = ()
                let v1231 : (unit -> unit) = closure54(v1229)
                let v1232 : unit = (fun () -> v1231 (); v1230) ()
                let v1272 : US4 = US4_0(v1229)
                let v1273 : US24 = US24_1
                struct (-2, v1272, v1273)
            | US28_0(v1153) -> (* Ok *)
                let v1154 : string = "$0.status"
                let v1155 : std_process_ExitStatus = Fable.Core.RustInterop.emitRustExpr v1153 v1154 
                let v1156 : string = "$0.code()"
                let v1157 : int32 option = Fable.Core.RustInterop.emitRustExpr v1155 v1156 
                let v1158 : (int32 -> US29) = method117()
                let v1159 : US29 option = v1157 |> Option.map v1158 
                let v1170 : US29 = US29_1
                let v1171 : US29 = v1159 |> Option.defaultValue v1170 
                match v1171 with
                | US29_1 -> (* None *)
                    let v1178 : string = "runtime.execute_with_options / exit_code=None"
                    let v1179 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v1180 : string = "&*$0"
                    let v1181 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1178 v1180 
                    let _v1179 = v1181 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v1182 : string = "&*$0"
                    let v1183 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1178 v1182 
                    let _v1179 = v1183 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v1184 : string = "&*$0"
                    let v1185 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1178 v1184 
                    let _v1179 = v1185 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v1186 : Ref<Str> = v1178 |> unbox<Ref<Str>>
                    let _v1179 = v1186 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v1189 : Ref<Str> = v1178 |> unbox<Ref<Str>>
                    let _v1179 = v1189 
                    #endif
#else
                    let v1192 : Ref<Str> = v1178 |> unbox<Ref<Str>>
                    let _v1179 = v1192 
                    #endif
                    let v1195 : Ref<Str> = _v1179 
                    let v1200 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v1201 : string = "String::from($0)"
                    let v1202 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1195 v1201 
                    let _v1200 = v1202 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v1203 : string = "String::from($0)"
                    let v1204 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1195 v1203 
                    let _v1200 = v1204 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v1205 : string = "String::from($0)"
                    let v1206 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1195 v1205 
                    let _v1200 = v1206 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v1207 : std_string_String = v1195 |> unbox<std_string_String>
                    let _v1200 = v1207 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v1210 : std_string_String = v1195 |> unbox<std_string_String>
                    let _v1200 = v1210 
                    #endif
#else
                    let v1213 : std_string_String = v1195 |> unbox<std_string_String>
                    let _v1200 = v1213 
                    #endif
                    let v1216 : std_string_String = _v1200 
                    let v1221 : US4 = US4_0(v1216)
                    let v1222 : US24 = US24_0(v368)
                    struct (-1, v1221, v1222)
                | US29_0(v1175) -> (* Some *)
                    let v1176 : US4 = US4_1
                    let v1177 : US24 = US24_0(v368)
                    struct (v1175, v1176, v1177)
    let v1337 : std_sync_Arc<std_sync_Mutex<std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>>> option =
        match v1330 with
        | US24_1 -> (* None *)
            let v1335 : std_sync_Arc<std_sync_Mutex<std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>>> option = None
            v1335
        | US24_0(v1331) -> (* Some *)
            let v1332 : std_sync_Arc<std_sync_Mutex<std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>>> option = Some v1331 
            v1332
    let v1338 : string = "true; let _optionm_map_ = $0.map(|x| { //"
    let v1339 : bool = Fable.Core.RustInterop.emitRustExpr v1337 v1338 
    let v1340 : string = "x"
    let v1341 : std_sync_Arc<std_sync_Mutex<std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>>> = Fable.Core.RustInterop.emitRustExpr () v1340 
    let v1342 : string = "$0"
    let v1343 : std_sync_Arc<std_sync_Mutex<std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>>> = Fable.Core.RustInterop.emitRustExpr v1341 v1342 
    let v1344 : string = "v1343.lock()"
    let v1345 : Result<std_sync_MutexGuard<std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>>, std_sync_PoisonError<std_sync_MutexGuard<std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>>>> = Fable.Core.RustInterop.emitRustExpr () v1344 
    let v1346 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v1347 : string = "$0.unwrap()"
    let v1348 : std_sync_MutexGuard<std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>> = Fable.Core.RustInterop.emitRustExpr v1345 v1347 
    let _v1346 = v1348 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v1349 : string = "$0.unwrap()"
    let v1350 : std_sync_MutexGuard<std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>> = Fable.Core.RustInterop.emitRustExpr v1345 v1349 
    let _v1346 = v1350 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v1351 : string = "$0.unwrap()"
    let v1352 : std_sync_MutexGuard<std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>> = Fable.Core.RustInterop.emitRustExpr v1345 v1351 
    let _v1346 = v1352 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v1353 : std_sync_MutexGuard<std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>> = match v1345 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
    let _v1346 = v1353 
    #endif
#if FABLE_COMPILER_PYTHON
    let v1354 : std_sync_MutexGuard<std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>> = match v1345 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
    let _v1346 = v1354 
    #endif
#else
    let v1355 : std_sync_MutexGuard<std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>> = match v1345 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
    let _v1346 = v1355 
    #endif
    let v1356 : std_sync_MutexGuard<std_sync_Arc<std_sync_mpsc_Receiver<std_string_String>>> = _v1346 
    let v1359 : string = "$0.iter()"
    let v1360 : _ = Fable.Core.RustInterop.emitRustExpr v1356 v1359 
    let v1361 : string = "$0.collect::<Vec<_>>()"
    let v1362 : Vec<std_string_String> = Fable.Core.RustInterop.emitRustExpr v1360 v1361 
    let v1363 : string = "true; let _vec_map : Vec<_> = $0.into_iter().map(|x| { //"
    let v1364 : bool = Fable.Core.RustInterop.emitRustExpr v1362 v1363 
    let v1365 : string = "x"
    let v1366 : std_string_String = Fable.Core.RustInterop.emitRustExpr () v1365 
    let v1367 : string = "fable_library_rust::String_::fromString($0)"
    let v1368 : string = Fable.Core.RustInterop.emitRustExpr v1366 v1367 
    let v1369 : string = "true; $0 }).collect::<Vec<_>>()"
    let v1370 : bool = Fable.Core.RustInterop.emitRustExpr v1368 v1369 
    let v1371 : string = "_vec_map"
    let v1372 : Vec<string> = Fable.Core.RustInterop.emitRustExpr () v1371 
    let v1373 : string = "fable_library_rust::NativeArray_::array_from($0)"
    let v1374 : (string []) = Fable.Core.RustInterop.emitRustExpr v1372 v1373 
    let v1375 : string seq = v1374 |> Seq.ofArray
    let v1378 : (string -> (string seq -> string)) = String.concat
    let v1379 : string = "\n"
    let v1380 : (string seq -> string) = v1378 v1379
    let v1381 : string = v1380 v1375
    let v1384 : string = "true; $0 })"
    let v1385 : bool = Fable.Core.RustInterop.emitRustExpr v1381 v1384 
    let v1386 : string = "_optionm_map_"
    let v1387 : string option = Fable.Core.RustInterop.emitRustExpr () v1386 
    let v1394 : US1 =
        match v1329 with
        | US4_1 -> (* None *)
            US1_1
        | US4_0(v1388) -> (* Some *)
            let v1389 : string = "fable_library_rust::String_::fromString($0)"
            let v1390 : string = Fable.Core.RustInterop.emitRustExpr v1388 v1389 
            US1_0(v1390)
    let v1398 : string =
        match v1394 with
        | US1_1 -> (* None *)
            let v1396 : string = ""
            v1396
        | US1_0(v1395) -> (* Some *)
            v1395
    let v1399 : string = v1387 |> Option.defaultValue v1398 
    let v1402 : unit = ()
    let v1403 : (unit -> unit) = closure56(v1328, v1399)
    let v1404 : unit = (fun () -> v1403 (); v1402) ()
    let v1445 : (int32 * string) = v1328, v1399 
    v1445 
    )
    |> fun x -> x ()
    ) () )
    |> fun x -> _v128 <- Some x
    let v1446 : (int32 * string) = match _v128 with Some x -> x | None -> failwith "base.capture / _v128=None"
    let (a, b) = v1446 
    let v1447 : int32 = a
    let v1448 : string = b
    let _v7 = struct (v1447, v1448) 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let struct (v1453 : int32, v1454 : string) = null |> unbox<struct (int32 * string)>
    let _v7 = struct (v1453, v1454) 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let struct (v1459 : int32, v1460 : string) = null |> unbox<struct (int32 * string)>
    let _v7 = struct (v1459, v1460) 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let struct (v1465 : int32, v1466 : string) = null |> unbox<struct (int32 * string)>
    let _v7 = struct (v1465, v1466) 
    #endif
#if FABLE_COMPILER_PYTHON
    let struct (v1471 : int32, v1472 : string) = null |> unbox<struct (int32 * string)>
    let _v7 = struct (v1471, v1472) 
    #endif
#else
    let v1477 : Async<struct (int32 * string)> = method120(v0, v1, v2, v3, v4, v5, v6)
    let v1478 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let struct (v1479 : int32, v1480 : string) = null |> unbox<struct (int32 * string)>
    let _v1478 = struct (v1479, v1480) 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let struct (v1485 : int32, v1486 : string) = null |> unbox<struct (int32 * string)>
    let _v1478 = struct (v1485, v1486) 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let struct (v1491 : int32, v1492 : string) = null |> unbox<struct (int32 * string)>
    let _v1478 = struct (v1491, v1492) 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let struct (v1497 : int32, v1498 : string) = null |> unbox<struct (int32 * string)>
    let _v1478 = struct (v1497, v1498) 
    #endif
#if FABLE_COMPILER_PYTHON
    let struct (v1503 : int32, v1504 : string) = null |> unbox<struct (int32 * string)>
    let _v1478 = struct (v1503, v1504) 
    #endif
#else
    let v1509 : (Async<struct (int32 * string)> -> struct (int32 * string)) = Async.RunSynchronously
    let struct (v1510 : int32, v1511 : string) = v1509 v1477
    let _v1478 = struct (v1510, v1511) 
    #endif
    let struct (v1512 : int32, v1513 : string) = _v1478 
    let _v7 = struct (v1512, v1513) 
    #endif
    let struct (v1522 : int32, v1523 : string) = _v7 
    struct (v1522, v1523)
and method129 (v0 : string, v1 : string, v2 : string) : struct (string * string) =
    let v3 : string = method43(v1)
    let v4 : string = method26(v2, v3)
    let v5 : string = "."
    let v6 : int32 = v1.LastIndexOf v5 
    let v7 : int32 = v6 - 1
    let v8 : string = v1.[int 0..int v7]
    let v9 : int32 = v4.LastIndexOf v5 
    let v10 : int32 = v9 - 1
    let v11 : string = v4.[int 0..int v10]
    let v12 : string = ".md"
    let v13 : bool = v0.EndsWith v12 
    let v14 : bool = v13 = false
    let v17 : string =
        if v14 then
            let v15 : string = $"{v1}.{v0}"
            v15
        else
            let v16 : string = $"{v8}.{v0}"
            v16
    let v20 : string =
        if v14 then
            let v18 : string = $"{v4}.{v0}"
            v18
        else
            let v19 : string = $"{v11}.{v0}"
            v19
    struct (v17, v20)
and method130 () : string =
    let v0 : string = ""
    v0
and closure66 () (v0 : string) : US33 =
    US33_0(v0)
and method131 () : (string -> US33) =
    closure66()
and closure67 () (v0 : std_string_String) : US33 =
    US33_1(v0)
and method132 () : (std_string_String -> US33) =
    closure67()
and method133 (v0 : string) : bool =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v3 : string = "&*$0"
    let v4 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v0 v3 
    let _v2 = v4 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v5 : string = "&*$0"
    let v6 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v0 v5 
    let _v2 = v6 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v7 : string = "&*$0"
    let v8 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v0 v7 
    let _v2 = v8 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v9 : Ref<Str> = v0 |> unbox<Ref<Str>>
    let _v2 = v9 
    #endif
#if FABLE_COMPILER_PYTHON
    let v12 : Ref<Str> = v0 |> unbox<Ref<Str>>
    let _v2 = v12 
    #endif
#else
    let v15 : Ref<Str> = v0 |> unbox<Ref<Str>>
    let _v2 = v15 
    #endif
    let v18 : Ref<Str> = _v2 
    let v23 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v24 : string = "String::from($0)"
    let v25 : std_string_String = Fable.Core.RustInterop.emitRustExpr v18 v24 
    let _v23 = v25 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v26 : string = "String::from($0)"
    let v27 : std_string_String = Fable.Core.RustInterop.emitRustExpr v18 v26 
    let _v23 = v27 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v28 : string = "String::from($0)"
    let v29 : std_string_String = Fable.Core.RustInterop.emitRustExpr v18 v28 
    let _v23 = v29 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v30 : std_string_String = v18 |> unbox<std_string_String>
    let _v23 = v30 
    #endif
#if FABLE_COMPILER_PYTHON
    let v33 : std_string_String = v18 |> unbox<std_string_String>
    let _v23 = v33 
    #endif
#else
    let v36 : std_string_String = v18 |> unbox<std_string_String>
    let _v23 = v36 
    #endif
    let v39 : std_string_String = _v23 
    let v44 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v45 : string = "std::path::PathBuf::from($0)"
    let v46 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v39 v45 
    let _v44 = v46 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v47 : string = "std::path::PathBuf::from($0)"
    let v48 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v39 v47 
    let _v44 = v48 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v49 : string = "std::path::PathBuf::from($0)"
    let v50 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v39 v49 
    let _v44 = v50 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v51 : std_path_PathBuf = v39 |> std_path_PathBuf 
    let _v44 = v51 
    #endif
#if FABLE_COMPILER_PYTHON
    let v54 : std_path_PathBuf = v39 |> std_path_PathBuf 
    let _v44 = v54 
    #endif
#else
    let v57 : std_path_PathBuf = v39 |> std_path_PathBuf 
    let _v44 = v57 
    #endif
    let v60 : std_path_PathBuf = _v44 
    let v65 : string = "$0.exists()"
    let v66 : bool = Fable.Core.RustInterop.emitRustExpr v60 v65 
    let v69 : bool =
        if v66 then
            let v67 : string = "$0.is_file()"
            let v68 : bool = Fable.Core.RustInterop.emitRustExpr v60 v67 
            v68
        else
            false
    let _v1 = v69 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v70 : bool = null |> unbox<bool>
    let _v1 = v70 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v73 : bool = null |> unbox<bool>
    let _v1 = v73 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v76 : string = "fs"
    let v77 : IFsExistsSync = Fable.Core.JsInterop.importAll v76 
    let v78 : string = "$0.existsSync($1)"
    let v79 : bool = Fable.Core.JsInterop.emitJsExpr struct (v77, v0) v78 
    let _v1 = v79 
    #endif
#if FABLE_COMPILER_PYTHON
    let v80 : bool = null |> unbox<bool>
    let _v1 = v80 
    #endif
#else
    let v83 : (string -> bool) = System.IO.File.Exists
    let v84 : bool = v83 v0
    let _v1 = v84 
    #endif
    let v85 : bool = _v1 
    v85
and method135 (v0 : string, v1 : string, v2 : string, v3 : int32, v4 : string, v5 : int32, v6 : string, v7 : string, v8 : US1, v9 : string, v10 : string) : string =
    let v11 : string = method14()
    let v12 : Mut3 = {l0 = v11} : Mut3
    let v13 : string = "{ "
    let v14 : string = $"{v13}"
    let v17 : unit = ()
    let v18 : (unit -> unit) = closure8(v12, v14)
    let v19 : unit = (fun () -> v18 (); v17) ()
    let v22 : string = "file"
    let v23 : string = $"{v22}"
    let v26 : unit = ()
    let v27 : (unit -> unit) = closure8(v12, v23)
    let v28 : unit = (fun () -> v27 (); v26) ()
    let v31 : string = " = "
    let v32 : string = $"{v31}"
    let v35 : unit = ()
    let v36 : (unit -> unit) = closure8(v12, v32)
    let v37 : unit = (fun () -> v36 (); v35) ()
    let v40 : string = $"{v0}"
    let v43 : unit = ()
    let v44 : (unit -> unit) = closure8(v12, v40)
    let v45 : unit = (fun () -> v44 (); v43) ()
    let v48 : string = "; "
    let v49 : string = $"{v48}"
    let v52 : unit = ()
    let v53 : (unit -> unit) = closure8(v12, v49)
    let v54 : unit = (fun () -> v53 (); v52) ()
    let v57 : string = "real_path"
    let v58 : string = $"{v57}"
    let v61 : unit = ()
    let v62 : (unit -> unit) = closure8(v12, v58)
    let v63 : unit = (fun () -> v62 (); v61) ()
    let v66 : string = $"{v31}"
    let v69 : unit = ()
    let v70 : (unit -> unit) = closure8(v12, v66)
    let v71 : unit = (fun () -> v70 (); v69) ()
    let v74 : string = $"{v1}"
    let v77 : unit = ()
    let v78 : (unit -> unit) = closure8(v12, v74)
    let v79 : unit = (fun () -> v78 (); v77) ()
    let v82 : string = $"{v48}"
    let v85 : unit = ()
    let v86 : (unit -> unit) = closure8(v12, v82)
    let v87 : unit = (fun () -> v86 (); v85) ()
    let v90 : string = "relative_path"
    let v91 : string = $"{v90}"
    let v94 : unit = ()
    let v95 : (unit -> unit) = closure8(v12, v91)
    let v96 : unit = (fun () -> v95 (); v94) ()
    let v99 : string = $"{v31}"
    let v102 : unit = ()
    let v103 : (unit -> unit) = closure8(v12, v99)
    let v104 : unit = (fun () -> v103 (); v102) ()
    let v107 : string = $"{v2}"
    let v110 : unit = ()
    let v111 : (unit -> unit) = closure8(v12, v107)
    let v112 : unit = (fun () -> v111 (); v110) ()
    let v115 : string = $"{v48}"
    let v118 : unit = ()
    let v119 : (unit -> unit) = closure8(v12, v115)
    let v120 : unit = (fun () -> v119 (); v118) ()
    let v123 : string = "origin_hash_exit_code"
    let v124 : string = $"{v123}"
    let v127 : unit = ()
    let v128 : (unit -> unit) = closure8(v12, v124)
    let v129 : unit = (fun () -> v128 (); v127) ()
    let v132 : string = $"{v31}"
    let v135 : unit = ()
    let v136 : (unit -> unit) = closure8(v12, v132)
    let v137 : unit = (fun () -> v136 (); v135) ()
    let v140 : string = $"{v3}"
    let v143 : unit = ()
    let v144 : (unit -> unit) = closure8(v12, v140)
    let v145 : unit = (fun () -> v144 (); v143) ()
    let v148 : string = $"{v48}"
    let v151 : unit = ()
    let v152 : (unit -> unit) = closure8(v12, v148)
    let v153 : unit = (fun () -> v152 (); v151) ()
    let v156 : string = "origin_hash"
    let v157 : string = $"{v156}"
    let v160 : unit = ()
    let v161 : (unit -> unit) = closure8(v12, v157)
    let v162 : unit = (fun () -> v161 (); v160) ()
    let v165 : string = $"{v31}"
    let v168 : unit = ()
    let v169 : (unit -> unit) = closure8(v12, v165)
    let v170 : unit = (fun () -> v169 (); v168) ()
    let v173 : string = $"{v4}"
    let v176 : unit = ()
    let v177 : (unit -> unit) = closure8(v12, v173)
    let v178 : unit = (fun () -> v177 (); v176) ()
    let v181 : string = $"{v48}"
    let v184 : unit = ()
    let v185 : (unit -> unit) = closure8(v12, v181)
    let v186 : unit = (fun () -> v185 (); v184) ()
    let v189 : string = "local_git_hash_exit_code"
    let v190 : string = $"{v189}"
    let v193 : unit = ()
    let v194 : (unit -> unit) = closure8(v12, v190)
    let v195 : unit = (fun () -> v194 (); v193) ()
    let v198 : string = $"{v31}"
    let v201 : unit = ()
    let v202 : (unit -> unit) = closure8(v12, v198)
    let v203 : unit = (fun () -> v202 (); v201) ()
    let v206 : string = $"{v5}"
    let v209 : unit = ()
    let v210 : (unit -> unit) = closure8(v12, v206)
    let v211 : unit = (fun () -> v210 (); v209) ()
    let v214 : string = $"{v48}"
    let v217 : unit = ()
    let v218 : (unit -> unit) = closure8(v12, v214)
    let v219 : unit = (fun () -> v218 (); v217) ()
    let v222 : string = "local_git_hash"
    let v223 : string = $"{v222}"
    let v226 : unit = ()
    let v227 : (unit -> unit) = closure8(v12, v223)
    let v228 : unit = (fun () -> v227 (); v226) ()
    let v231 : string = $"{v31}"
    let v234 : unit = ()
    let v235 : (unit -> unit) = closure8(v12, v231)
    let v236 : unit = (fun () -> v235 (); v234) ()
    let v239 : string = $"{v6}"
    let v242 : unit = ()
    let v243 : (unit -> unit) = closure8(v12, v239)
    let v244 : unit = (fun () -> v243 (); v242) ()
    let v247 : string = $"{v48}"
    let v250 : unit = ()
    let v251 : (unit -> unit) = closure8(v12, v247)
    let v252 : unit = (fun () -> v251 (); v250) ()
    let v255 : string = "hash1"
    let v256 : string = $"{v255}"
    let v259 : unit = ()
    let v260 : (unit -> unit) = closure8(v12, v256)
    let v261 : unit = (fun () -> v260 (); v259) ()
    let v264 : string = $"{v31}"
    let v267 : unit = ()
    let v268 : (unit -> unit) = closure8(v12, v264)
    let v269 : unit = (fun () -> v268 (); v267) ()
    let v272 : string = $"{v7}"
    let v275 : unit = ()
    let v276 : (unit -> unit) = closure8(v12, v272)
    let v277 : unit = (fun () -> v276 (); v275) ()
    let v280 : string = $"{v48}"
    let v283 : unit = ()
    let v284 : (unit -> unit) = closure8(v12, v280)
    let v285 : unit = (fun () -> v284 (); v283) ()
    let v288 : string = "hash2"
    let v289 : string = $"{v288}"
    let v292 : unit = ()
    let v293 : (unit -> unit) = closure8(v12, v289)
    let v294 : unit = (fun () -> v293 (); v292) ()
    let v297 : string = $"{v31}"
    let v300 : unit = ()
    let v301 : (unit -> unit) = closure8(v12, v297)
    let v302 : unit = (fun () -> v301 (); v300) ()
    let v305 : string = $"%A{v8}"
    let v308 : string = $"{v305}"
    let v311 : unit = ()
    let v312 : (unit -> unit) = closure8(v12, v308)
    let v313 : unit = (fun () -> v312 (); v311) ()
    let v316 : string = $"{v48}"
    let v319 : unit = ()
    let v320 : (unit -> unit) = closure8(v12, v316)
    let v321 : unit = (fun () -> v320 (); v319) ()
    let v324 : string = "dist_path"
    let v325 : string = $"{v324}"
    let v328 : unit = ()
    let v329 : (unit -> unit) = closure8(v12, v325)
    let v330 : unit = (fun () -> v329 (); v328) ()
    let v333 : string = $"{v31}"
    let v336 : unit = ()
    let v337 : (unit -> unit) = closure8(v12, v333)
    let v338 : unit = (fun () -> v337 (); v336) ()
    let v341 : string = $"{v9}"
    let v344 : unit = ()
    let v345 : (unit -> unit) = closure8(v12, v341)
    let v346 : unit = (fun () -> v345 (); v344) ()
    let v349 : string = $"{v48}"
    let v352 : unit = ()
    let v353 : (unit -> unit) = closure8(v12, v349)
    let v354 : unit = (fun () -> v353 (); v352) ()
    let v357 : string = "cache_path"
    let v358 : string = $"{v357}"
    let v361 : unit = ()
    let v362 : (unit -> unit) = closure8(v12, v358)
    let v363 : unit = (fun () -> v362 (); v361) ()
    let v366 : string = $"{v31}"
    let v369 : unit = ()
    let v370 : (unit -> unit) = closure8(v12, v366)
    let v371 : unit = (fun () -> v370 (); v369) ()
    let v374 : string = $"{v10}"
    let v377 : unit = ()
    let v378 : (unit -> unit) = closure8(v12, v374)
    let v379 : unit = (fun () -> v378 (); v377) ()
    let v382 : string = " }"
    let v383 : string = $"{v382}"
    let v386 : unit = ()
    let v387 : (unit -> unit) = closure8(v12, v383)
    let v388 : unit = (fun () -> v387 (); v386) ()
    let v391 : string = v12.l0
    v391
and method134 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : string, v9 : string, v10 : string, v11 : string, v12 : int32, v13 : string, v14 : int32, v15 : string, v16 : string, v17 : US1, v18 : string, v19 : string) : string =
    let v20 : string = method135(v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
    let v21 : int64 = v0.l0
    let v22 : string = $"{v6} {v7} #{v21} %s{v8} / {v20}"
    method18(v22)
and closure68 (v0 : string, v1 : string, v2 : string, v3 : string, v4 : int32, v5 : string, v6 : string, v7 : int32, v8 : string, v9 : string, v10 : US1) () : unit =
    let v11 : US0 = US0_2
    let v12 : bool = method7(v11)
    if v12 then
        let v13 : unit = ()
        let v14 : (unit -> unit) = closure6()
        let v15 : unit = (fun () -> v14 (); v13) ()
        let struct (v29 : Mut0, v30 : Mut1, v31 : Mut2, v32 : Mut3, v33 : Mut4, v34 : int64 option) = TraceState.trace_state.Value
        let v47 : string = method8(v29, v30, v31, v32, v33, v34)
        let v48 : string = method12()
        let v49 : string = "documents.run / par_map"
        let v50 : string = " / origin_hash |> sm'.contains local_git_hash |> not"
        let v51 : string = v49 + v50 
        let v52 : string = " / Some hash2 when hash1 = hash2"
        let v53 : string = v51 + v52 
        let v54 : bool = v53 = ""
        let v57 : string =
            if v54 then
                let v55 : string = ""
                v55
            else
                method134(v29, v30, v31, v32, v33, v34, v47, v48, v53, v1, v2, v0, v4, v3, v7, v6, v9, v10, v5, v8)
        method19(v57)
and method137 (v0 : string) : string =
    v0
and closure69 () (v0 : uint64) : US34 =
    US34_0(v0)
and closure70 () (v0 : std_string_String) : US34 =
    US34_1(v0)
and method139 (v0 : string, v1 : string, v2 : std_string_String) : string =
    let v3 : string = method14()
    let v4 : Mut3 = {l0 = v3} : Mut3
    let v5 : string = "{ "
    let v6 : string = $"{v5}"
    let v9 : unit = ()
    let v10 : (unit -> unit) = closure8(v4, v6)
    let v11 : unit = (fun () -> v10 (); v9) ()
    let v14 : string = "old_path"
    let v15 : string = $"{v14}"
    let v18 : unit = ()
    let v19 : (unit -> unit) = closure8(v4, v15)
    let v20 : unit = (fun () -> v19 (); v18) ()
    let v23 : string = " = "
    let v24 : string = $"{v23}"
    let v27 : unit = ()
    let v28 : (unit -> unit) = closure8(v4, v24)
    let v29 : unit = (fun () -> v28 (); v27) ()
    let v32 : string = $"{v0}"
    let v35 : unit = ()
    let v36 : (unit -> unit) = closure8(v4, v32)
    let v37 : unit = (fun () -> v36 (); v35) ()
    let v40 : string = "; "
    let v41 : string = $"{v40}"
    let v44 : unit = ()
    let v45 : (unit -> unit) = closure8(v4, v41)
    let v46 : unit = (fun () -> v45 (); v44) ()
    let v49 : string = "new_path"
    let v50 : string = $"{v49}"
    let v53 : unit = ()
    let v54 : (unit -> unit) = closure8(v4, v50)
    let v55 : unit = (fun () -> v54 (); v53) ()
    let v58 : string = $"{v23}"
    let v61 : unit = ()
    let v62 : (unit -> unit) = closure8(v4, v58)
    let v63 : unit = (fun () -> v62 (); v61) ()
    let v66 : string = $"{v1}"
    let v69 : unit = ()
    let v70 : (unit -> unit) = closure8(v4, v66)
    let v71 : unit = (fun () -> v70 (); v69) ()
    let v74 : string = $"{v40}"
    let v77 : unit = ()
    let v78 : (unit -> unit) = closure8(v4, v74)
    let v79 : unit = (fun () -> v78 (); v77) ()
    let v82 : string = "error"
    let v83 : string = $"{v82}"
    let v86 : unit = ()
    let v87 : (unit -> unit) = closure8(v4, v83)
    let v88 : unit = (fun () -> v87 (); v86) ()
    let v91 : string = $"{v23}"
    let v94 : unit = ()
    let v95 : (unit -> unit) = closure8(v4, v91)
    let v96 : unit = (fun () -> v95 (); v94) ()
    let v99 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v100 : string = "format!(\"{:#?}\", $0)"
    let v101 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2 v100 
    let v102 : string = "fable_library_rust::String_::fromString($0)"
    let v103 : string = Fable.Core.RustInterop.emitRustExpr v101 v102 
    let _v99 = v103 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v104 : string = "format!(\"{:#?}\", $0)"
    let v105 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2 v104 
    let v106 : string = "fable_library_rust::String_::fromString($0)"
    let v107 : string = Fable.Core.RustInterop.emitRustExpr v105 v106 
    let _v99 = v107 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v108 : string = "format!(\"{:#?}\", $0)"
    let v109 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2 v108 
    let v110 : string = "fable_library_rust::String_::fromString($0)"
    let v111 : string = Fable.Core.RustInterop.emitRustExpr v109 v110 
    let _v99 = v111 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v112 : string = $"%A{v2}"
    let _v99 = v112 
    #endif
#if FABLE_COMPILER_PYTHON
    let v115 : string = $"%A{v2}"
    let _v99 = v115 
    #endif
#else
    let v118 : string = $"%A{v2}"
    let _v99 = v118 
    #endif
    let v121 : string = _v99 
    let v126 : string = $"{v121}"
    let v129 : unit = ()
    let v130 : (unit -> unit) = closure8(v4, v126)
    let v131 : unit = (fun () -> v130 (); v129) ()
    let v134 : string = " }"
    let v135 : string = $"{v134}"
    let v138 : unit = ()
    let v139 : (unit -> unit) = closure8(v4, v135)
    let v140 : unit = (fun () -> v139 (); v138) ()
    let v143 : string = v4.l0
    v143
and method138 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : string, v9 : string, v10 : std_string_String) : string =
    let v11 : string = method139(v8, v9, v10)
    let v12 : int64 = v0.l0
    let v13 : string = "file_system.file_copy"
    let v14 : string = $"{v6} {v7} #{v12} %s{v13} / {v11}"
    method18(v14)
and closure71 (v0 : string, v1 : string, v2 : std_string_String) () : unit =
    let v3 : US0 = US0_3
    let v4 : bool = method7(v3)
    if v4 then
        let v5 : unit = ()
        let v6 : (unit -> unit) = closure6()
        let v7 : unit = (fun () -> v6 (); v5) ()
        let struct (v21 : Mut0, v22 : Mut1, v23 : Mut2, v24 : Mut3, v25 : Mut4, v26 : int64 option) = TraceState.trace_state.Value
        let v39 : string = method8(v21, v22, v23, v24, v25, v26)
        let v40 : string = method35()
        let v41 : string = method138(v21, v22, v23, v24, v25, v26, v39, v40, v0, v1, v2)
        method19(v41)
and method141 (v0 : string, v1 : string, v2 : uint64) : string =
    let v3 : string = method14()
    let v4 : Mut3 = {l0 = v3} : Mut3
    let v5 : string = "{ "
    let v6 : string = $"{v5}"
    let v9 : unit = ()
    let v10 : (unit -> unit) = closure8(v4, v6)
    let v11 : unit = (fun () -> v10 (); v9) ()
    let v14 : string = "old_path"
    let v15 : string = $"{v14}"
    let v18 : unit = ()
    let v19 : (unit -> unit) = closure8(v4, v15)
    let v20 : unit = (fun () -> v19 (); v18) ()
    let v23 : string = " = "
    let v24 : string = $"{v23}"
    let v27 : unit = ()
    let v28 : (unit -> unit) = closure8(v4, v24)
    let v29 : unit = (fun () -> v28 (); v27) ()
    let v32 : string = $"{v0}"
    let v35 : unit = ()
    let v36 : (unit -> unit) = closure8(v4, v32)
    let v37 : unit = (fun () -> v36 (); v35) ()
    let v40 : string = "; "
    let v41 : string = $"{v40}"
    let v44 : unit = ()
    let v45 : (unit -> unit) = closure8(v4, v41)
    let v46 : unit = (fun () -> v45 (); v44) ()
    let v49 : string = "new_path"
    let v50 : string = $"{v49}"
    let v53 : unit = ()
    let v54 : (unit -> unit) = closure8(v4, v50)
    let v55 : unit = (fun () -> v54 (); v53) ()
    let v58 : string = $"{v23}"
    let v61 : unit = ()
    let v62 : (unit -> unit) = closure8(v4, v58)
    let v63 : unit = (fun () -> v62 (); v61) ()
    let v66 : string = $"{v1}"
    let v69 : unit = ()
    let v70 : (unit -> unit) = closure8(v4, v66)
    let v71 : unit = (fun () -> v70 (); v69) ()
    let v74 : string = $"{v40}"
    let v77 : unit = ()
    let v78 : (unit -> unit) = closure8(v4, v74)
    let v79 : unit = (fun () -> v78 (); v77) ()
    let v82 : string = "result"
    let v83 : string = $"{v82}"
    let v86 : unit = ()
    let v87 : (unit -> unit) = closure8(v4, v83)
    let v88 : unit = (fun () -> v87 (); v86) ()
    let v91 : string = $"{v23}"
    let v94 : unit = ()
    let v95 : (unit -> unit) = closure8(v4, v91)
    let v96 : unit = (fun () -> v95 (); v94) ()
    let v99 : string = $"{v2}"
    let v102 : unit = ()
    let v103 : (unit -> unit) = closure8(v4, v99)
    let v104 : unit = (fun () -> v103 (); v102) ()
    let v107 : string = " }"
    let v108 : string = $"{v107}"
    let v111 : unit = ()
    let v112 : (unit -> unit) = closure8(v4, v108)
    let v113 : unit = (fun () -> v112 (); v111) ()
    let v116 : string = v4.l0
    v116
and method140 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : string, v9 : string, v10 : uint64) : string =
    let v11 : string = method141(v8, v9, v10)
    let v12 : int64 = v0.l0
    let v13 : string = "file_system.file_copy"
    let v14 : string = $"{v6} {v7} #{v12} %s{v13} / {v11}"
    method18(v14)
and closure72 (v0 : string, v1 : string, v2 : uint64) () : unit =
    let v3 : US0 = US0_1
    let v4 : bool = method7(v3)
    if v4 then
        let v5 : unit = ()
        let v6 : (unit -> unit) = closure6()
        let v7 : unit = (fun () -> v6 (); v5) ()
        let struct (v21 : Mut0, v22 : Mut1, v23 : Mut2, v24 : Mut3, v25 : Mut4, v26 : int64 option) = TraceState.trace_state.Value
        let v39 : string = method8(v21, v22, v23, v24, v25, v26)
        let v40 : string = method50()
        let v41 : string = method140(v21, v22, v23, v24, v25, v26, v39, v40, v0, v1, v2)
        method19(v41)
and method136 (v0 : string, v1 : string) : unit =
    let v2 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v3 : string = method137(v0)
    let v4 : string = "std::fs::copy(&*$0, &*v3)"
    let v5 : Result<uint64, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1 v4 
    let v6 : (std_io_Error -> std_string_String) = method54()
    let v7 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v8 : string = "$0.map_err(|x| $1(x))"
    let v9 : Result<uint64, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v5, v6) v8 
    let _v7 = v9 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v10 : string = "$0.map_err(|x| $1(x))"
    let v11 : Result<uint64, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v5, v6) v10 
    let _v7 = v11 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v12 : string = "$0.map_err(|x| $1(x))"
    let v13 : Result<uint64, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v5, v6) v12 
    let _v7 = v13 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v14 : Result<uint64, std_string_String> = match v5 with Ok x -> Ok x | Error x -> Error (v6 x)
    let _v7 = v14 
    #endif
#if FABLE_COMPILER_PYTHON
    let v15 : Result<uint64, std_string_String> = match v5 with Ok x -> Ok x | Error x -> Error (v6 x)
    let _v7 = v15 
    #endif
#else
    let v16 : Result<uint64, std_string_String> = match v5 with Ok x -> Ok x | Error x -> Error (v6 x)
    let _v7 = v16 
    #endif
    let v17 : Result<uint64, std_string_String> = _v7 
    let v20 : (uint64 -> US34) = closure69()
    let v21 : (std_string_String -> US34) = closure70()
    let v22 : US34 = match v17 with Ok x -> v20 x | Error x -> v21 x
    match v22 with
    | US34_1(v66) -> (* Error *)
        let v67 : unit = ()
        let v68 : (unit -> unit) = closure71(v1, v3, v66)
        let v69 : unit = (fun () -> v68 (); v67) ()
        ()
    | US34_0(v23) -> (* Ok *)
        let v24 : unit = ()
        let v25 : (unit -> unit) = closure72(v1, v3, v23)
        let v26 : unit = (fun () -> v25 (); v24) ()
        ()
    let _v2 = () 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let _v2 = () 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let _v2 = () 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let _v2 = () 
    #endif
#if FABLE_COMPILER_PYTHON
    let _v2 = () 
    #endif
#else
    System.IO.File.Copy (v1, v0, true)
    let _v2 = () 
    #endif
    _v2 
    ()
and method143 (v0 : Vec<uint8>) : Vec<uint8> =
    v0
and method144 (v0 : int32, v1 : Mut7) : bool =
    let v2 : int32 = v1.l0
    let v3 : bool = v2 < v0
    v3
and method145 (v0 : string) : string =
    v0
and method146 (v0 : std_sync_MutexGuard<std_process_ChildStdin>) : std_sync_MutexGuard<std_process_ChildStdin> =
    v0
and closure75 (v0 : string) (v1 : std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>>) : unit =
    let v2 : string = "$0"
    let v3 : std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> = Fable.Core.RustInterop.emitRustExpr v1 v2 
    let v4 : string = "v3.lock()"
    let v5 : Result<std_sync_MutexGuard<std_process_ChildStdin>, std_sync_PoisonError<std_sync_MutexGuard<std_process_ChildStdin>>> = Fable.Core.RustInterop.emitRustExpr () v4 
    let v6 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v7 : string = "$0.unwrap()"
    let v8 : std_sync_MutexGuard<std_process_ChildStdin> = Fable.Core.RustInterop.emitRustExpr v5 v7 
    let _v6 = v8 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v9 : string = "$0.unwrap()"
    let v10 : std_sync_MutexGuard<std_process_ChildStdin> = Fable.Core.RustInterop.emitRustExpr v5 v9 
    let _v6 = v10 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v11 : string = "$0.unwrap()"
    let v12 : std_sync_MutexGuard<std_process_ChildStdin> = Fable.Core.RustInterop.emitRustExpr v5 v11 
    let _v6 = v12 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v13 : std_sync_MutexGuard<std_process_ChildStdin> = match v5 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
    let _v6 = v13 
    #endif
#if FABLE_COMPILER_PYTHON
    let v14 : std_sync_MutexGuard<std_process_ChildStdin> = match v5 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
    let _v6 = v14 
    #endif
#else
    let v15 : std_sync_MutexGuard<std_process_ChildStdin> = match v5 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
    let _v6 = v15 
    #endif
    let v16 : std_sync_MutexGuard<std_process_ChildStdin> = _v6 
    let v19 : string = method145(v0)
    let v20 : string = "v19.as_bytes()"
    let v21 : Ref<Slice<uint8>> = Fable.Core.RustInterop.emitRustExpr () v20 
    let v22 : std_sync_MutexGuard<std_process_ChildStdin> = method146(v16)
    let v23 : string = "true; let mut v22 = v22"
    let v24 : bool = Fable.Core.RustInterop.emitRustExpr () v23 
    let v25 : string = "true; std::io::Write::write_all(&mut *$0, v21).unwrap()"
    let v26 : bool = Fable.Core.RustInterop.emitRustExpr v22 v25 
    ()
and method147 (v0 : int32, v1 : Mut8) : bool =
    let v2 : int32 = v1.l0
    let v3 : bool = v2 < v0
    v3
and method148 (v0 : string) : string =
    v0
and method150 (v0 : int32, v1 : int32, v2 : string) : string =
    let v3 : string = method14()
    let v4 : Mut3 = {l0 = v3} : Mut3
    let v5 : string = "{ "
    let v6 : string = $"{v5}"
    let v9 : unit = ()
    let v10 : (unit -> unit) = closure8(v4, v6)
    let v11 : unit = (fun () -> v10 (); v9) ()
    let v14 : string = "exit_code"
    let v15 : string = $"{v14}"
    let v18 : unit = ()
    let v19 : (unit -> unit) = closure8(v4, v15)
    let v20 : unit = (fun () -> v19 (); v18) ()
    let v23 : string = " = "
    let v24 : string = $"{v23}"
    let v27 : unit = ()
    let v28 : (unit -> unit) = closure8(v4, v24)
    let v29 : unit = (fun () -> v28 (); v27) ()
    let v32 : string = $"{v0}"
    let v35 : unit = ()
    let v36 : (unit -> unit) = closure8(v4, v32)
    let v37 : unit = (fun () -> v36 (); v35) ()
    let v40 : string = "; "
    let v41 : string = $"{v40}"
    let v44 : unit = ()
    let v45 : (unit -> unit) = closure8(v4, v41)
    let v46 : unit = (fun () -> v45 (); v44) ()
    let v49 : string = "result_len"
    let v50 : string = $"{v49}"
    let v53 : unit = ()
    let v54 : (unit -> unit) = closure8(v4, v50)
    let v55 : unit = (fun () -> v54 (); v53) ()
    let v58 : string = $"{v23}"
    let v61 : unit = ()
    let v62 : (unit -> unit) = closure8(v4, v58)
    let v63 : unit = (fun () -> v62 (); v61) ()
    let v66 : string = $"{v1}"
    let v69 : unit = ()
    let v70 : (unit -> unit) = closure8(v4, v66)
    let v71 : unit = (fun () -> v70 (); v69) ()
    let v74 : string = $"{v40}"
    let v77 : unit = ()
    let v78 : (unit -> unit) = closure8(v4, v74)
    let v79 : unit = (fun () -> v78 (); v77) ()
    let v82 : string = "output_path"
    let v83 : string = $"{v82}"
    let v86 : unit = ()
    let v87 : (unit -> unit) = closure8(v4, v83)
    let v88 : unit = (fun () -> v87 (); v86) ()
    let v91 : string = $"{v23}"
    let v94 : unit = ()
    let v95 : (unit -> unit) = closure8(v4, v91)
    let v96 : unit = (fun () -> v95 (); v94) ()
    let v99 : string = $"{v2}"
    let v102 : unit = ()
    let v103 : (unit -> unit) = closure8(v4, v99)
    let v104 : unit = (fun () -> v103 (); v102) ()
    let v107 : string = " }"
    let v108 : string = $"{v107}"
    let v111 : unit = ()
    let v112 : (unit -> unit) = closure8(v4, v108)
    let v113 : unit = (fun () -> v112 (); v111) ()
    let v116 : string = v4.l0
    v116
and method149 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : int32, v9 : int32, v10 : string) : string =
    let v11 : string = method150(v8, v9, v10)
    let v12 : int64 = v0.l0
    let v13 : string = "documents.hangul"
    let v14 : string = $"{v6} {v7} #{v12} %s{v13} / {v11}"
    method18(v14)
and closure76 (v0 : string, v1 : int32, v2 : string) () : unit =
    let v3 : US0 = US0_2
    let v4 : bool = method7(v3)
    if v4 then
        let v5 : unit = ()
        let v6 : (unit -> unit) = closure6()
        let v7 : unit = (fun () -> v6 (); v5) ()
        let struct (v21 : Mut0, v22 : Mut1, v23 : Mut2, v24 : Mut3, v25 : Mut4, v26 : int64 option) = TraceState.trace_state.Value
        let v39 : string = method8(v21, v22, v23, v24, v25, v26)
        let v40 : string = method12()
        let v41 : int32 = v2.Length
        let v42 : string = method149(v21, v22, v23, v24, v25, v26, v39, v40, v1, v41, v0)
        method19(v42)
and method142 (v0 : string, v1 : string, v2 : string, v3 : string) : US35 =
    let v4 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v5 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v6 : string = "std::fs::read(&*$0)"
    let v7 : Result<Vec<uint8>, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3 v6 
    let v8 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v9 : string = "$0.unwrap()"
    let v10 : Vec<uint8> = Fable.Core.RustInterop.emitRustExpr v7 v9 
    let _v8 = v10 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v11 : string = "$0.unwrap()"
    let v12 : Vec<uint8> = Fable.Core.RustInterop.emitRustExpr v7 v11 
    let _v8 = v12 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v13 : string = "$0.unwrap()"
    let v14 : Vec<uint8> = Fable.Core.RustInterop.emitRustExpr v7 v13 
    let _v8 = v14 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v15 : Vec<uint8> = match v7 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
    let _v8 = v15 
    #endif
#if FABLE_COMPILER_PYTHON
    let v16 : Vec<uint8> = match v7 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
    let _v8 = v16 
    #endif
#else
    let v17 : Vec<uint8> = match v7 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
    let _v8 = v17 
    #endif
    let v18 : Vec<uint8> = _v8 
    let _v5 = v18 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v21 : Vec<uint8> = null |> unbox<Vec<uint8>>
    let _v5 = v21 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v24 : Vec<uint8> = null |> unbox<Vec<uint8>>
    let _v5 = v24 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v27 : Vec<uint8> = null |> unbox<Vec<uint8>>
    let _v5 = v27 
    #endif
#if FABLE_COMPILER_PYTHON
    let v30 : Vec<uint8> = null |> unbox<Vec<uint8>>
    let _v5 = v30 
    #endif
#else
    let v33 : (uint8 []) = v3 |> System.IO.File.ReadAllBytes
    let v34 : string = "$0.to_vec()"
    let v35 : Vec<uint8> = Fable.Core.RustInterop.emitRustExpr v33 v34 
    let _v5 = v35 
    #endif
    let v36 : Vec<uint8> = _v5 
    let v41 : Vec<uint8> = method143(v36)
    let v42 : string = "std::string::String::from_utf8($0)"
    let v43 : Result<std_string_String, std_string_FromUtf8Error> = Fable.Core.RustInterop.emitRustExpr v41 v42 
    let v44 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v45 : string = "$0.unwrap()"
    let v46 : std_string_String = Fable.Core.RustInterop.emitRustExpr v43 v45 
    let _v44 = v46 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v47 : string = "$0.unwrap()"
    let v48 : std_string_String = Fable.Core.RustInterop.emitRustExpr v43 v47 
    let _v44 = v48 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v49 : string = "$0.unwrap()"
    let v50 : std_string_String = Fable.Core.RustInterop.emitRustExpr v43 v49 
    let _v44 = v50 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v51 : std_string_String = match v43 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
    let _v44 = v51 
    #endif
#if FABLE_COMPILER_PYTHON
    let v52 : std_string_String = match v43 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
    let _v44 = v52 
    #endif
#else
    let v53 : std_string_String = match v43 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
    let _v44 = v53 
    #endif
    let v54 : std_string_String = _v44 
    let v57 : string = "fable_library_rust::String_::fromString($0)"
    let v58 : string = Fable.Core.RustInterop.emitRustExpr v54 v57 
    let _v4 = v58 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v59 : string = null |> unbox<string>
    let _v4 = v59 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v62 : string = null |> unbox<string>
    let _v4 = v62 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v65 : string = null |> unbox<string>
    let _v4 = v65 
    #endif
#if FABLE_COMPILER_PYTHON
    let v68 : string = null |> unbox<string>
    let _v4 = v68 
    #endif
#else
    let v71 : string = v3 |> System.IO.File.ReadAllText
    let _v4 = v71 
    #endif
    let v72 : string = _v4 
    let v77 : string = "\n"
    let v78 : (string []) = v72.Split v77 
    let v81 : int32 = v78.Length
    let v82 : (string []) = Array.zeroCreate<string> (v81)
    let v83 : Mut6 = {l0 = 0} : Mut6
    while method48(v81, v83) do
        let v85 : int32 = v83.l0
        let v86 : string = v78.[int v85]
        let v87 : (unit -> string) = v86.Trim
        let v88 : string = v87 ()
        v82.[int v85] <- v88
        let v89 : int32 = v85 + 1
        v83.l0 <- v89
        ()
    let v90 : int32 = v82.Length
    let v91 : (string []) = Array.zeroCreate<string> (v90)
    let v92 : Mut7 = {l0 = 0; l1 = 0} : Mut7
    while method144(v90, v92) do
        let v94 : int32 = v92.l0
        let v95 : int32 = v92.l1
        let v96 : string = v82.[int v94]
        let v97 : string = ""
        let v98 : bool = v97 <> v96 
        let v102 : int32 =
            if v98 then
                v91.[int v95] <- v96
                let v101 : int32 = v95 + 1
                v101
            else
                v95
        let v103 : int32 = v94 + 1
        v92.l0 <- v103
        v92.l1 <- v102
        ()
    let v104 : int32 = v92.l1
    let v105 : (string []) = Array.zeroCreate<string> (v104)
    let v106 : Mut6 = {l0 = 0} : Mut6
    while method48(v104, v106) do
        let v108 : int32 = v106.l0
        let v109 : string = v91.[int v108]
        v105.[int v108] <- v109
        let v110 : int32 = v108 + 1
        v106.l0 <- v110
        ()
    let v111 : string seq = seq { for i = 0 to v105.Length - 1 do yield v105.[i] }
    let v114 : (string -> (string seq -> string)) = String.concat
    let v115 : (string seq -> string) = v114 v77
    let v116 : string = v115 v111
    let v119 : string = $"{v116}

"
    let v120 : System.Threading.CancellationToken option = None
    let v121 : (struct (string * string) []) = [||]
    let v122 : (struct (int32 * string * bool) -> Async<unit>) option = None
    let v123 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit) option = None
    let v124 : string option = None
    let v125 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v126 : string = "cfg!(windows)"
    let v127 : bool = Fable.Core.RustInterop.emitRustExpr () v126 
    let _v125 = v127 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v128 : string = "cfg!(windows)"
    let v129 : bool = Fable.Core.RustInterop.emitRustExpr () v128 
    let _v125 = v129 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v130 : string = "cfg!(windows)"
    let v131 : bool = Fable.Core.RustInterop.emitRustExpr () v130 
    let _v125 = v131 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v132 : US5 = US5_0
    let v133 : US6 = US6_3(v132)
    let v134 : string = $"platform.is_windows / target: {v133}"
    let v135 : bool = failwith<bool> v134
    let _v125 = v135 
    #endif
#if FABLE_COMPILER_PYTHON
    let v136 : US5 = US5_0
    let v137 : US6 = US6_4(v136)
    let v138 : string = $"platform.is_windows / target: {v137}"
    let v139 : bool = failwith<bool> v138
    let _v125 = v139 
    #endif
#else
    let v140 : System.Runtime.InteropServices.OSPlatform = System.Runtime.InteropServices.OSPlatform.Windows
    let v141 : (System.Runtime.InteropServices.OSPlatform -> bool) = System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform
    let v142 : bool = v141 v140
    let _v125 = v142 
    #endif
    let v143 : bool = _v125 
    let v151 : string =
        if v143 then
            let v149 : string = ".exe"
            v149
        else
            let v150 : string = ""
            v150
    let v152 : string = $"../vault/deps/hangulize/cmd/hangulize/hangulize{v151}"
    let v153 : string = method26(v0, v152)
    let v154 : string = $"{v153} {v1}"
    let v155 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit) = closure75(v119)
    let v156 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit) option = Some v155 
    let v159 : bool = true
    let struct (v160 : int32, v161 : string) = method67(v154, v120, v121, v122, v156, v159, v124)
    let v162 : (string []) = v161.Split v77 
    let v165 : int32 = v162.Length
    let v166 : string = ""
    let v167 : Mut8 = {l0 = 0; l1 = v166; l2 = 0; l3 = 0} : Mut8
    while method147(v90, v167) do
        let v169 : int32 = v167.l0
        let struct (v170 : string, v171 : int32, v172 : int32) = v167.l1, v167.l2, v167.l3
        let v173 : string = v82.[int v169]
        let v174 : bool = v173 = ""
        let struct (v190 : string, v191 : int32, v192 : int32) =
            if v174 then
                let v175 : string = $"{v170}
"
                let v176 : int32 = v171 + 1
                let v177 : int32 = v172 + 1
                struct (v175, v176, v177)
            else
                let v178 : int32 = v171 - v172
                let v179 : bool = v178 >= v165
                let v188 : string =
                    if v179 then
                        v170
                    else
                        let v180 : string = v162.[int v178]
                        let v183 : int32 = v165 - 1
                        let v184 : bool = v178 = v183
                        if v184 then
                            let v185 : string = $"{v170}{v180}"
                            v185
                        else
                            let v186 : string = $"{v170}{v180}
"
                            v186
                let v189 : int32 = v171 + 1
                struct (v188, v189, v172)
        let v193 : int32 = v169 + 1
        v167.l0 <- v193
        v167.l1 <- v190
        v167.l2 <- v191
        v167.l3 <- v192
        ()
    let struct (v194 : string, v195 : int32, v196 : int32) = v167.l1, v167.l2, v167.l3
    let v197 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v198 : string = "std::fs::write(&*$0, &*$1).unwrap()"
    Fable.Core.RustInterop.emitRustExpr struct (v2, v194) v198 
    let _v197 = () 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let _v197 = () 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let _v197 = () 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let _v197 = () 
    #endif
#if FABLE_COMPILER_PYTHON
    let _v197 = () 
    #endif
#else
    let v199 : string = method148(v194)
    System.IO.File.WriteAllText (v2, v199)
    let _v197 = () 
    #endif
    _v197 
    let v200 : unit = ()
    let v201 : (unit -> unit) = closure76(v2, v160, v194)
    let v202 : unit = (fun () -> v201 (); v200) ()
    US35_0(v160, v194)
and method152 (v0 : int32, v1 : string) : string =
    let v2 : string = method14()
    let v3 : Mut3 = {l0 = v2} : Mut3
    let v4 : string = "{ "
    let v5 : string = $"{v4}"
    let v8 : unit = ()
    let v9 : (unit -> unit) = closure8(v3, v5)
    let v10 : unit = (fun () -> v9 (); v8) ()
    let v13 : string = "exit_code"
    let v14 : string = $"{v13}"
    let v17 : unit = ()
    let v18 : (unit -> unit) = closure8(v3, v14)
    let v19 : unit = (fun () -> v18 (); v17) ()
    let v22 : string = " = "
    let v23 : string = $"{v22}"
    let v26 : unit = ()
    let v27 : (unit -> unit) = closure8(v3, v23)
    let v28 : unit = (fun () -> v27 (); v26) ()
    let v31 : string = $"{v0}"
    let v34 : unit = ()
    let v35 : (unit -> unit) = closure8(v3, v31)
    let v36 : unit = (fun () -> v35 (); v34) ()
    let v39 : string = "; "
    let v40 : string = $"{v39}"
    let v43 : unit = ()
    let v44 : (unit -> unit) = closure8(v3, v40)
    let v45 : unit = (fun () -> v44 (); v43) ()
    let v48 : string = "result"
    let v49 : string = $"{v48}"
    let v52 : unit = ()
    let v53 : (unit -> unit) = closure8(v3, v49)
    let v54 : unit = (fun () -> v53 (); v52) ()
    let v57 : string = $"{v22}"
    let v60 : unit = ()
    let v61 : (unit -> unit) = closure8(v3, v57)
    let v62 : unit = (fun () -> v61 (); v60) ()
    let v65 : string = $"{v1}"
    let v68 : unit = ()
    let v69 : (unit -> unit) = closure8(v3, v65)
    let v70 : unit = (fun () -> v69 (); v68) ()
    let v73 : string = " }"
    let v74 : string = $"{v73}"
    let v77 : unit = ()
    let v78 : (unit -> unit) = closure8(v3, v74)
    let v79 : unit = (fun () -> v78 (); v77) ()
    let v82 : string = v3.l0
    v82
and method151 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : int32, v9 : string) : string =
    let v10 : string = method152(v8, v9)
    let v11 : int64 = v0.l0
    let v12 : string = "documents.files_fn / error"
    let v13 : string = $"{v6} {v7} #{v11} %s{v12} / {v10}"
    method18(v13)
and closure77 (v0 : string, v1 : int32) () : unit =
    let v2 : US0 = US0_2
    let v3 : bool = method7(v2)
    if v3 then
        let v4 : unit = ()
        let v5 : (unit -> unit) = closure6()
        let v6 : unit = (fun () -> v5 (); v4) ()
        let struct (v20 : Mut0, v21 : Mut1, v22 : Mut2, v23 : Mut3, v24 : Mut4, v25 : int64 option) = TraceState.trace_state.Value
        let v38 : string = method8(v20, v21, v22, v23, v24, v25)
        let v39 : string = method12()
        let v40 : string = method151(v20, v21, v22, v23, v24, v25, v38, v39, v1, v0)
        method19(v40)
and closure74 (v0 : string, v1 : string, v2 : string, v3 : string, v4 : string) (v5 : string) : US32 =
    let struct (v6 : string, v7 : string) = method129(v5, v4, v0)
    let v8 : bool = method133(v6)
    let v9 : bool = v8 = false
    let v12 : bool =
        if v9 then
            true
        else
            let v10 : bool = method133(v7)
            let v11 : bool = v10 = false
            v11
    let v290 : bool =
        if v12 then
            false
        else
            let v13 : string = method40(v6)
            let v14 : string = "std::fs::File::open(&*v13)"
            let v15 : Result<std_fs_File, std_io_Error> = Fable.Core.RustInterop.emitRustExpr () v14 
            let v16 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v17 : string = "$0.unwrap()"
            let v18 : std_fs_File = Fable.Core.RustInterop.emitRustExpr v15 v17 
            let _v16 = v18 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v19 : string = "$0.unwrap()"
            let v20 : std_fs_File = Fable.Core.RustInterop.emitRustExpr v15 v19 
            let _v16 = v20 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v21 : string = "$0.unwrap()"
            let v22 : std_fs_File = Fable.Core.RustInterop.emitRustExpr v15 v21 
            let _v16 = v22 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v23 : std_fs_File = match v15 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v16 = v23 
            #endif
#if FABLE_COMPILER_PYTHON
            let v24 : std_fs_File = match v15 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v16 = v24 
            #endif
#else
            let v25 : std_fs_File = match v15 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v16 = v25 
            #endif
            let v26 : std_fs_File = _v16 
            let v29 : string = "std::io::BufReader::new($0)"
            let v30 : std_io_BufReader<std_fs_File> = Fable.Core.RustInterop.emitRustExpr v26 v29 
            let v31 : string = "std::io::BufReader::new($0)"
            let v32 : std_io_BufReader<std_io_BufReader<std_fs_File>> = Fable.Core.RustInterop.emitRustExpr v30 v31 
            let v33 : string = "true; let mut v32 = v32"
            let v34 : bool = Fable.Core.RustInterop.emitRustExpr () v33 
            let v35 : string = "let result : sha2::Sha256 = sha2::Digest::new()"
            Fable.Core.RustInterop.emitRustExpr () v35 
            let v36 : string = "result"
            let v37 : sha2_Sha256 = Fable.Core.RustInterop.emitRustExpr () v36 
            let v38 : string = "true; let mut v37 = v37"
            let v39 : bool = Fable.Core.RustInterop.emitRustExpr () v38 
            let v40 : unativeint = 0 |> unativeint 
            let v43 : string = "[$0; 1024]"
            let v44 : Slice'<uint8> = Fable.Core.RustInterop.emitRustExpr 0uy v43 
            let v45 : string = "true; loop { // rust.loop"
            let v46 : bool = Fable.Core.RustInterop.emitRustExpr () v45 
            let v47 : string = "true; let mut v44 = v44"
            let v48 : bool = Fable.Core.RustInterop.emitRustExpr () v47 
            let v49 : string = "std::io::Read::read(&mut v32, &mut v44)"
            let v50 : Result<unativeint, std_io_Error> = Fable.Core.RustInterop.emitRustExpr () v49 
            let v51 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v52 : string = "$0.unwrap()"
            let v53 : unativeint = Fable.Core.RustInterop.emitRustExpr v50 v52 
            let _v51 = v53 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v54 : string = "$0.unwrap()"
            let v55 : unativeint = Fable.Core.RustInterop.emitRustExpr v50 v54 
            let _v51 = v55 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v56 : string = "$0.unwrap()"
            let v57 : unativeint = Fable.Core.RustInterop.emitRustExpr v50 v56 
            let _v51 = v57 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v58 : unativeint = match v50 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v51 = v58 
            #endif
#if FABLE_COMPILER_PYTHON
            let v59 : unativeint = match v50 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v51 = v59 
            #endif
#else
            let v60 : unativeint = match v50 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v51 = v60 
            #endif
            let v61 : unativeint = _v51 
            let v64 : bool = v61 = v40 
            if v64 then
                let v67 : string = "true; break"
                let v68 : bool = Fable.Core.RustInterop.emitRustExpr () v67 
                ()
            let v69 : string = "v44.len()"
            let v70 : unativeint = Fable.Core.RustInterop.emitRustExpr () v69 
            let v71 : uint8 = v70 |> uint8 
            let v74 : unativeint = v61 |> unativeint 
            let v77 : unativeint = v74 |> unbox<unativeint>
            let v80 : bool = v77 = v70 
            let v87 : Ref<Slice'<uint8>> =
                if v80 then
                    let v83 : string = "&v44[v40..]"
                    let v84 : Ref<Slice'<uint8>> = Fable.Core.RustInterop.emitRustExpr () v83 
                    v84
                else
                    let v85 : string = "&v44[$0..$1]"
                    let v86 : Ref<Slice'<uint8>> = Fable.Core.RustInterop.emitRustExpr struct (v40, v74) v85 
                    v86
            let v88 : string = "sha2::Digest::update(&mut v37, v87)"
            Fable.Core.RustInterop.emitRustExpr () v88 
            let v89 : string = "true; } // rust.loop"
            let v90 : bool = Fable.Core.RustInterop.emitRustExpr () v89 
            let v91 : string = "true; } // rust.loop"
            let v92 : bool = Fable.Core.RustInterop.emitRustExpr () v91 
            let v93 : string = "true; } // rust.loop"
            let v94 : bool = Fable.Core.RustInterop.emitRustExpr () v93 
            let v95 : string = "true; { // rust.loop"
            let v96 : bool = Fable.Core.RustInterop.emitRustExpr () v95 
            let v97 : string = "true; { // rust.loop"
            let v98 : bool = Fable.Core.RustInterop.emitRustExpr () v97 
            let v99 : string = "&sha2::Digest::finalize(v37)"
            let v100 : Ref<Slice<uint8>> = Fable.Core.RustInterop.emitRustExpr () v99 
            let v101 : string = "$0.iter().map(|x| *x).collect::<Vec<_>>()"
            let v102 : Vec<uint8> = Fable.Core.RustInterop.emitRustExpr v100 v101 
            let v103 : string = "true; let _vec_map : Vec<_> = $0.into_iter().map(|x| { //"
            let v104 : bool = Fable.Core.RustInterop.emitRustExpr v102 v103 
            let v105 : string = "x"
            let v106 : uint8 = Fable.Core.RustInterop.emitRustExpr () v105 
            let v107 : string = "format!(\"{:02x}\", $0)"
            let v108 : std_string_String = Fable.Core.RustInterop.emitRustExpr v106 v107 
            let v109 : string = "fable_library_rust::String_::fromString($0)"
            let v110 : string = Fable.Core.RustInterop.emitRustExpr v108 v109 
            let v111 : string = "true; $0 }).collect::<Vec<_>>()"
            let v112 : bool = Fable.Core.RustInterop.emitRustExpr v110 v111 
            let v113 : string = "_vec_map"
            let v114 : Vec<string> = Fable.Core.RustInterop.emitRustExpr () v113 
            let v115 : string = "fable_library_rust::NativeArray_::array_from($0)"
            let v116 : (string []) = Fable.Core.RustInterop.emitRustExpr v114 v115 
            let v117 : string seq = seq { for i = 0 to v116.Length - 1 do yield v116.[i] }
            let v120 : string = method130()
            let v121 : (string -> (string seq -> string)) = String.concat
            let v122 : (string seq -> string) = v121 v120
            let v123 : string = v122 v117
            let v126 : Result<string, std_io_Error> = Ok v123 
            let v127 : (std_io_Error -> std_string_String) = method54()
            let v128 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v129 : string = "$0.map_err(|x| $1(x))"
            let v130 : Result<string, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v126, v127) v129 
            let _v128 = v130 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v131 : string = "$0.map_err(|x| $1(x))"
            let v132 : Result<string, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v126, v127) v131 
            let _v128 = v132 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v133 : string = "$0.map_err(|x| $1(x))"
            let v134 : Result<string, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v126, v127) v133 
            let _v128 = v134 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v135 : Result<string, std_string_String> = match v126 with Ok x -> Ok x | Error x -> Error (v127 x)
            let _v128 = v135 
            #endif
#if FABLE_COMPILER_PYTHON
            let v136 : Result<string, std_string_String> = match v126 with Ok x -> Ok x | Error x -> Error (v127 x)
            let _v128 = v136 
            #endif
#else
            let v137 : Result<string, std_string_String> = match v126 with Ok x -> Ok x | Error x -> Error (v127 x)
            let _v128 = v137 
            #endif
            let v138 : Result<string, std_string_String> = _v128 
            let v141 : (string -> US33) = method131()
            let v142 : (std_string_String -> US33) = method132()
            let v143 : string = "match $2 { Ok(x) => $0(x), Err(e) => $1(e) }"
            let v144 : US33 = Fable.Core.RustInterop.emitRustExpr struct (v141, v142, v138) v143 
            let v150 : string =
                match v144 with
                | US33_1(v146) -> (* Error *)
                    let v147 : string = $"resultm.get / Result value was Error: {v146}"
                    failwith<string> v147
                | US33_0(v145) -> (* Ok *)
                    v145
            let v151 : string = method40(v7)
            let v152 : string = "std::fs::File::open(&*v151)"
            let v153 : Result<std_fs_File, std_io_Error> = Fable.Core.RustInterop.emitRustExpr () v152 
            let v154 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v155 : string = "$0.unwrap()"
            let v156 : std_fs_File = Fable.Core.RustInterop.emitRustExpr v153 v155 
            let _v154 = v156 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v157 : string = "$0.unwrap()"
            let v158 : std_fs_File = Fable.Core.RustInterop.emitRustExpr v153 v157 
            let _v154 = v158 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v159 : string = "$0.unwrap()"
            let v160 : std_fs_File = Fable.Core.RustInterop.emitRustExpr v153 v159 
            let _v154 = v160 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v161 : std_fs_File = match v153 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v154 = v161 
            #endif
#if FABLE_COMPILER_PYTHON
            let v162 : std_fs_File = match v153 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v154 = v162 
            #endif
#else
            let v163 : std_fs_File = match v153 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v154 = v163 
            #endif
            let v164 : std_fs_File = _v154 
            let v167 : string = "std::io::BufReader::new($0)"
            let v168 : std_io_BufReader<std_fs_File> = Fable.Core.RustInterop.emitRustExpr v164 v167 
            let v169 : string = "std::io::BufReader::new($0)"
            let v170 : std_io_BufReader<std_io_BufReader<std_fs_File>> = Fable.Core.RustInterop.emitRustExpr v168 v169 
            let v171 : string = "true; let mut v170 = v170"
            let v172 : bool = Fable.Core.RustInterop.emitRustExpr () v171 
            let v173 : string = "let result : sha2::Sha256 = sha2::Digest::new()"
            Fable.Core.RustInterop.emitRustExpr () v173 
            let v174 : string = "result"
            let v175 : sha2_Sha256 = Fable.Core.RustInterop.emitRustExpr () v174 
            let v176 : string = "true; let mut v175 = v175"
            let v177 : bool = Fable.Core.RustInterop.emitRustExpr () v176 
            let v178 : unativeint = 0 |> unativeint 
            let v181 : string = "[$0; 1024]"
            let v182 : Slice'<uint8> = Fable.Core.RustInterop.emitRustExpr 0uy v181 
            let v183 : string = "true; loop { // rust.loop"
            let v184 : bool = Fable.Core.RustInterop.emitRustExpr () v183 
            let v185 : string = "true; let mut v182 = v182"
            let v186 : bool = Fable.Core.RustInterop.emitRustExpr () v185 
            let v187 : string = "std::io::Read::read(&mut v170, &mut v182)"
            let v188 : Result<unativeint, std_io_Error> = Fable.Core.RustInterop.emitRustExpr () v187 
            let v189 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v190 : string = "$0.unwrap()"
            let v191 : unativeint = Fable.Core.RustInterop.emitRustExpr v188 v190 
            let _v189 = v191 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v192 : string = "$0.unwrap()"
            let v193 : unativeint = Fable.Core.RustInterop.emitRustExpr v188 v192 
            let _v189 = v193 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v194 : string = "$0.unwrap()"
            let v195 : unativeint = Fable.Core.RustInterop.emitRustExpr v188 v194 
            let _v189 = v195 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v196 : unativeint = match v188 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v189 = v196 
            #endif
#if FABLE_COMPILER_PYTHON
            let v197 : unativeint = match v188 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v189 = v197 
            #endif
#else
            let v198 : unativeint = match v188 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v189 = v198 
            #endif
            let v199 : unativeint = _v189 
            let v202 : bool = v199 = v178 
            if v202 then
                let v205 : string = "true; break"
                let v206 : bool = Fable.Core.RustInterop.emitRustExpr () v205 
                ()
            let v207 : string = "v182.len()"
            let v208 : unativeint = Fable.Core.RustInterop.emitRustExpr () v207 
            let v209 : uint8 = v208 |> uint8 
            let v212 : unativeint = v199 |> unativeint 
            let v215 : unativeint = v212 |> unbox<unativeint>
            let v218 : bool = v215 = v208 
            let v225 : Ref<Slice'<uint8>> =
                if v218 then
                    let v221 : string = "&v182[v178..]"
                    let v222 : Ref<Slice'<uint8>> = Fable.Core.RustInterop.emitRustExpr () v221 
                    v222
                else
                    let v223 : string = "&v182[$0..$1]"
                    let v224 : Ref<Slice'<uint8>> = Fable.Core.RustInterop.emitRustExpr struct (v178, v212) v223 
                    v224
            let v226 : string = "sha2::Digest::update(&mut v175, v225)"
            Fable.Core.RustInterop.emitRustExpr () v226 
            let v227 : string = "true; } // rust.loop"
            let v228 : bool = Fable.Core.RustInterop.emitRustExpr () v227 
            let v229 : string = "true; } // rust.loop"
            let v230 : bool = Fable.Core.RustInterop.emitRustExpr () v229 
            let v231 : string = "true; } // rust.loop"
            let v232 : bool = Fable.Core.RustInterop.emitRustExpr () v231 
            let v233 : string = "true; { // rust.loop"
            let v234 : bool = Fable.Core.RustInterop.emitRustExpr () v233 
            let v235 : string = "true; { // rust.loop"
            let v236 : bool = Fable.Core.RustInterop.emitRustExpr () v235 
            let v237 : string = "&sha2::Digest::finalize(v175)"
            let v238 : Ref<Slice<uint8>> = Fable.Core.RustInterop.emitRustExpr () v237 
            let v239 : string = "$0.iter().map(|x| *x).collect::<Vec<_>>()"
            let v240 : Vec<uint8> = Fable.Core.RustInterop.emitRustExpr v238 v239 
            let v241 : string = "true; let _vec_map : Vec<_> = $0.into_iter().map(|x| { //"
            let v242 : bool = Fable.Core.RustInterop.emitRustExpr v240 v241 
            let v243 : string = "x"
            let v244 : uint8 = Fable.Core.RustInterop.emitRustExpr () v243 
            let v245 : string = "format!(\"{:02x}\", $0)"
            let v246 : std_string_String = Fable.Core.RustInterop.emitRustExpr v244 v245 
            let v247 : string = "fable_library_rust::String_::fromString($0)"
            let v248 : string = Fable.Core.RustInterop.emitRustExpr v246 v247 
            let v249 : string = "true; $0 }).collect::<Vec<_>>()"
            let v250 : bool = Fable.Core.RustInterop.emitRustExpr v248 v249 
            let v251 : string = "_vec_map"
            let v252 : Vec<string> = Fable.Core.RustInterop.emitRustExpr () v251 
            let v253 : string = "fable_library_rust::NativeArray_::array_from($0)"
            let v254 : (string []) = Fable.Core.RustInterop.emitRustExpr v252 v253 
            let v255 : string seq = seq { for i = 0 to v254.Length - 1 do yield v254.[i] }
            let v258 : string = method130()
            let v259 : (string -> (string seq -> string)) = String.concat
            let v260 : (string seq -> string) = v259 v258
            let v261 : string = v260 v255
            let v264 : Result<string, std_io_Error> = Ok v261 
            let v265 : (std_io_Error -> std_string_String) = method54()
            let v266 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v267 : string = "$0.map_err(|x| $1(x))"
            let v268 : Result<string, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v264, v265) v267 
            let _v266 = v268 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v269 : string = "$0.map_err(|x| $1(x))"
            let v270 : Result<string, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v264, v265) v269 
            let _v266 = v270 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v271 : string = "$0.map_err(|x| $1(x))"
            let v272 : Result<string, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v264, v265) v271 
            let _v266 = v272 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v273 : Result<string, std_string_String> = match v264 with Ok x -> Ok x | Error x -> Error (v265 x)
            let _v266 = v273 
            #endif
#if FABLE_COMPILER_PYTHON
            let v274 : Result<string, std_string_String> = match v264 with Ok x -> Ok x | Error x -> Error (v265 x)
            let _v266 = v274 
            #endif
#else
            let v275 : Result<string, std_string_String> = match v264 with Ok x -> Ok x | Error x -> Error (v265 x)
            let _v266 = v275 
            #endif
            let v276 : Result<string, std_string_String> = _v266 
            let v279 : (string -> US33) = method131()
            let v280 : (std_string_String -> US33) = method132()
            let v281 : string = "match $2 { Ok(x) => $0(x), Err(e) => $1(e) }"
            let v282 : US33 = Fable.Core.RustInterop.emitRustExpr struct (v279, v280, v276) v281 
            let v288 : string =
                match v282 with
                | US33_1(v284) -> (* Error *)
                    let v285 : string = $"resultm.get / Result value was Error: {v284}"
                    failwith<string> v285
                | US33_0(v283) -> (* Ok *)
                    v283
            let v289 : bool = v150 = v288
            v289
    if v290 then
        US32_1
    else
        let v292 : US35 = method142(v2, v3, v6, v4)
        match v292 with
        | US35_1(v348, v349) -> (* Error *)
            let v350 : (string * string) = v6, v349 
            let v351 : Result<string, (string * string)> = Error v350 
            US32_0(v351)
        | US35_0(v293, v294) -> (* Ok *)
            let v295 : bool = v293 <> 0 
            if v295 then
                let v298 : unit = ()
                let v299 : (unit -> unit) = closure77(v294, v293)
                let v300 : unit = (fun () -> v299 (); v298) ()
                let v340 : (string * string) = v6, v294 
                let v341 : Result<string, (string * string)> = Error v340 
                US32_0(v341)
            else
                let v343 : bool = method133(v6)
                if v343 then
                    method136(v7, v6)
                else
                    let v344 : string = $"documents.files_fn / {v6} should exist"
                    failwith<unit> v344
                let v345 : Result<string, (string * string)> = Ok v6 
                US32_0(v345)
and closure73 (v0 : string, v1 : string, v2 : string, v3 : string) (v4 : string) : (string -> US32) =
    closure74(v0, v1, v2, v3, v4)
and method155 (v0 : int32, v1 : string, v2 : string) : string =
    let v3 : string = method14()
    let v4 : Mut3 = {l0 = v3} : Mut3
    let v5 : string = "{ "
    let v6 : string = $"{v5}"
    let v9 : unit = ()
    let v10 : (unit -> unit) = closure8(v4, v6)
    let v11 : unit = (fun () -> v10 (); v9) ()
    let v14 : string = "exit_code"
    let v15 : string = $"{v14}"
    let v18 : unit = ()
    let v19 : (unit -> unit) = closure8(v4, v15)
    let v20 : unit = (fun () -> v19 (); v18) ()
    let v23 : string = " = "
    let v24 : string = $"{v23}"
    let v27 : unit = ()
    let v28 : (unit -> unit) = closure8(v4, v24)
    let v29 : unit = (fun () -> v28 (); v27) ()
    let v32 : string = $"{v0}"
    let v35 : unit = ()
    let v36 : (unit -> unit) = closure8(v4, v32)
    let v37 : unit = (fun () -> v36 (); v35) ()
    let v40 : string = "; "
    let v41 : string = $"{v40}"
    let v44 : unit = ()
    let v45 : (unit -> unit) = closure8(v4, v41)
    let v46 : unit = (fun () -> v45 (); v44) ()
    let v49 : string = "output_path"
    let v50 : string = $"{v49}"
    let v53 : unit = ()
    let v54 : (unit -> unit) = closure8(v4, v50)
    let v55 : unit = (fun () -> v54 (); v53) ()
    let v58 : string = $"{v23}"
    let v61 : unit = ()
    let v62 : (unit -> unit) = closure8(v4, v58)
    let v63 : unit = (fun () -> v62 (); v61) ()
    let v66 : string = $"{v1}"
    let v69 : unit = ()
    let v70 : (unit -> unit) = closure8(v4, v66)
    let v71 : unit = (fun () -> v70 (); v69) ()
    let v74 : string = $"{v40}"
    let v77 : unit = ()
    let v78 : (unit -> unit) = closure8(v4, v74)
    let v79 : unit = (fun () -> v78 (); v77) ()
    let v82 : string = "result"
    let v83 : string = $"{v82}"
    let v86 : unit = ()
    let v87 : (unit -> unit) = closure8(v4, v83)
    let v88 : unit = (fun () -> v87 (); v86) ()
    let v91 : string = $"{v23}"
    let v94 : unit = ()
    let v95 : (unit -> unit) = closure8(v4, v91)
    let v96 : unit = (fun () -> v95 (); v94) ()
    let v99 : string = $"{v2}"
    let v102 : unit = ()
    let v103 : (unit -> unit) = closure8(v4, v99)
    let v104 : unit = (fun () -> v103 (); v102) ()
    let v107 : string = " }"
    let v108 : string = $"{v107}"
    let v111 : unit = ()
    let v112 : (unit -> unit) = closure8(v4, v108)
    let v113 : unit = (fun () -> v112 (); v111) ()
    let v116 : string = v4.l0
    v116
and method154 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : int32, v9 : string, v10 : string) : string =
    let v11 : string = method155(v8, v9, v10)
    let v12 : int64 = v0.l0
    let v13 : string = "documents.crowbook / result contains ERROR"
    let v14 : string = $"{v6} {v7} #{v12} %s{v13} / {v11}"
    method18(v14)
and closure80 (v0 : string, v1 : string, v2 : int32) () : unit =
    let v3 : US0 = US0_3
    let v4 : bool = method7(v3)
    if v4 then
        let v5 : unit = ()
        let v6 : (unit -> unit) = closure6()
        let v7 : unit = (fun () -> v6 (); v5) ()
        let struct (v21 : Mut0, v22 : Mut1, v23 : Mut2, v24 : Mut3, v25 : Mut4, v26 : int64 option) = TraceState.trace_state.Value
        let v39 : string = method8(v21, v22, v23, v24, v25, v26)
        let v40 : string = method35()
        let v41 : string = method154(v21, v22, v23, v24, v25, v26, v39, v40, v2, v0, v1)
        method19(v41)
and method153 (v0 : bool, v1 : string, v2 : string, v3 : string, v4 : string) : US35 =
    let v5 : bool = "html" = v4
    let v61 : string =
        if v5 then
            let v6 : string = $"--set"
            let v7 : string = $" html.css.add \\\"'"
            let v8 : string = v6 + v7 
            let v9 : string = $" body {{ color: #e8e6e3; background-color: #202324; }}"
            let v10 : string = v8 + v9 
            let v11 : string = $" a {{ color: #989693; }}"
            let v12 : string = v10 + v11 
            let v13 : string = $" pre {{ background-color: #1b1b1b; padding: 10px; }}"
            let v14 : string = v12 + v13 
            let v15 : string = $" '\\\""
            let v16 : string = v14 + v15 
            let v17 : string = $" rendering.num_depth 6"
            let v18 : string = $" rendering.highlight.theme \\\"Solarized (dark)\\\""
            let v19 : string = v17 + v18 
            let v20 : string = v16 + v19 
            v20
        else
            let v21 : bool = "pdf" = v4
            if v21 then
                let v22 : string = $"--set"
                let v23 : string = $" tex.paper.size a4paper"
                let v24 : string = v22 + v23 
                let v25 : string = $" tex.template.add \"\\pagenumbering{{gobble}}\""
                let v26 : string = v24 + v25 
                let v27 : bool = v0 = false
                let v36 : string =
                    if v27 then
                        let v28 : string = ""
                        v28
                    else
                        let v29 : string = $" tex.template.add \"\\usepackage{{polyglossia}}\""
                        let v30 : string = $" tex.template.add \"\\setmainlanguage{{korean}}\""
                        let v31 : string = v29 + v30 
                        let v32 : string = $" tex.template.add \"\\setmainfont{{NanumGothicCoding}}\""
                        let v33 : string = v31 + v32 
                        let v34 : string = $" tex.font.size 13"
                        let v35 : string = v33 + v34 
                        v35
                let v37 : string = v26 + v36 
                let v38 : string = $" rendering.num_depth 6"
                let v39 : string = $" rendering.highlight.theme \\\"Solarized (dark)\\\""
                let v40 : string = v38 + v39 
                let v41 : string = v37 + v40 
                v41
            else
                let v42 : bool = "epub" = v4
                if v42 then
                    let v43 : string = $"--set"
                    let v44 : string = $" epub.version 3"
                    let v45 : string = v43 + v44 
                    let v46 : string = $" html.css.add \\\"' "
                    let v47 : string = v45 + v46 
                    let v48 : string = $" body {{ color: #e8e6e3; background-color: #202324; }} "
                    let v49 : string = v47 + v48 
                    let v50 : string = $" a {{ color: #989693; }} "
                    let v51 : string = v49 + v50 
                    let v52 : string = $" '\\\""
                    let v53 : string = v51 + v52 
                    let v54 : string = $" rendering.num_depth 6"
                    let v55 : string = $" rendering.highlight.theme \\\"Solarized (dark)\\\""
                    let v56 : string = v54 + v55 
                    let v57 : string = v53 + v56 
                    v57
                else
                    let v58 : string = ""
                    v58
    let v62 : System.Threading.CancellationToken option = None
    let v63 : (struct (string * string) []) = [||]
    let v64 : (struct (int32 * string * bool) -> Async<unit>) option = None
    let v65 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit) option = None
    let v66 : string option = None
    let v67 : string = $"crowbook --verbose --to {v4}"
    let v68 : string = $" --single \"{v2}\" --output \"{v1}\" {v61}"
    let v69 : string = v67 + v68 
    let v70 : string option = Some v3 
    let v73 : bool = true
    let struct (v74 : int32, v75 : string) = method67(v69, v62, v63, v64, v65, v73, v70)
    let v76 : string = "ERROR"
    let v77 : bool = v75.Contains v76 
    let v80 : bool = v77 = false
    if v80 then
        US35_0(v74, v75)
    else
        let v82 : unit = ()
        let v83 : (unit -> unit) = closure80(v1, v75, v74)
        let v84 : unit = (fun () -> v83 (); v82) ()
        US35_1(v74, v75)
and closure79 (v0 : string, v1 : string, v2 : bool, v3 : string) (v4 : string) : US32 =
    let struct (v5 : string, v6 : string) = method129(v4, v3, v0)
    let v7 : bool = method133(v5)
    let v8 : bool = v7 = false
    let v11 : bool =
        if v8 then
            true
        else
            let v9 : bool = method133(v6)
            let v10 : bool = v9 = false
            v10
    let v289 : bool =
        if v11 then
            false
        else
            let v12 : string = method40(v5)
            let v13 : string = "std::fs::File::open(&*v12)"
            let v14 : Result<std_fs_File, std_io_Error> = Fable.Core.RustInterop.emitRustExpr () v13 
            let v15 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v16 : string = "$0.unwrap()"
            let v17 : std_fs_File = Fable.Core.RustInterop.emitRustExpr v14 v16 
            let _v15 = v17 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v18 : string = "$0.unwrap()"
            let v19 : std_fs_File = Fable.Core.RustInterop.emitRustExpr v14 v18 
            let _v15 = v19 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v20 : string = "$0.unwrap()"
            let v21 : std_fs_File = Fable.Core.RustInterop.emitRustExpr v14 v20 
            let _v15 = v21 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v22 : std_fs_File = match v14 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v15 = v22 
            #endif
#if FABLE_COMPILER_PYTHON
            let v23 : std_fs_File = match v14 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v15 = v23 
            #endif
#else
            let v24 : std_fs_File = match v14 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v15 = v24 
            #endif
            let v25 : std_fs_File = _v15 
            let v28 : string = "std::io::BufReader::new($0)"
            let v29 : std_io_BufReader<std_fs_File> = Fable.Core.RustInterop.emitRustExpr v25 v28 
            let v30 : string = "std::io::BufReader::new($0)"
            let v31 : std_io_BufReader<std_io_BufReader<std_fs_File>> = Fable.Core.RustInterop.emitRustExpr v29 v30 
            let v32 : string = "true; let mut v31 = v31"
            let v33 : bool = Fable.Core.RustInterop.emitRustExpr () v32 
            let v34 : string = "let result : sha2::Sha256 = sha2::Digest::new()"
            Fable.Core.RustInterop.emitRustExpr () v34 
            let v35 : string = "result"
            let v36 : sha2_Sha256 = Fable.Core.RustInterop.emitRustExpr () v35 
            let v37 : string = "true; let mut v36 = v36"
            let v38 : bool = Fable.Core.RustInterop.emitRustExpr () v37 
            let v39 : unativeint = 0 |> unativeint 
            let v42 : string = "[$0; 1024]"
            let v43 : Slice'<uint8> = Fable.Core.RustInterop.emitRustExpr 0uy v42 
            let v44 : string = "true; loop { // rust.loop"
            let v45 : bool = Fable.Core.RustInterop.emitRustExpr () v44 
            let v46 : string = "true; let mut v43 = v43"
            let v47 : bool = Fable.Core.RustInterop.emitRustExpr () v46 
            let v48 : string = "std::io::Read::read(&mut v31, &mut v43)"
            let v49 : Result<unativeint, std_io_Error> = Fable.Core.RustInterop.emitRustExpr () v48 
            let v50 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v51 : string = "$0.unwrap()"
            let v52 : unativeint = Fable.Core.RustInterop.emitRustExpr v49 v51 
            let _v50 = v52 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v53 : string = "$0.unwrap()"
            let v54 : unativeint = Fable.Core.RustInterop.emitRustExpr v49 v53 
            let _v50 = v54 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v55 : string = "$0.unwrap()"
            let v56 : unativeint = Fable.Core.RustInterop.emitRustExpr v49 v55 
            let _v50 = v56 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v57 : unativeint = match v49 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v50 = v57 
            #endif
#if FABLE_COMPILER_PYTHON
            let v58 : unativeint = match v49 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v50 = v58 
            #endif
#else
            let v59 : unativeint = match v49 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v50 = v59 
            #endif
            let v60 : unativeint = _v50 
            let v63 : bool = v60 = v39 
            if v63 then
                let v66 : string = "true; break"
                let v67 : bool = Fable.Core.RustInterop.emitRustExpr () v66 
                ()
            let v68 : string = "v43.len()"
            let v69 : unativeint = Fable.Core.RustInterop.emitRustExpr () v68 
            let v70 : uint8 = v69 |> uint8 
            let v73 : unativeint = v60 |> unativeint 
            let v76 : unativeint = v73 |> unbox<unativeint>
            let v79 : bool = v76 = v69 
            let v86 : Ref<Slice'<uint8>> =
                if v79 then
                    let v82 : string = "&v43[v39..]"
                    let v83 : Ref<Slice'<uint8>> = Fable.Core.RustInterop.emitRustExpr () v82 
                    v83
                else
                    let v84 : string = "&v43[$0..$1]"
                    let v85 : Ref<Slice'<uint8>> = Fable.Core.RustInterop.emitRustExpr struct (v39, v73) v84 
                    v85
            let v87 : string = "sha2::Digest::update(&mut v36, v86)"
            Fable.Core.RustInterop.emitRustExpr () v87 
            let v88 : string = "true; } // rust.loop"
            let v89 : bool = Fable.Core.RustInterop.emitRustExpr () v88 
            let v90 : string = "true; } // rust.loop"
            let v91 : bool = Fable.Core.RustInterop.emitRustExpr () v90 
            let v92 : string = "true; } // rust.loop"
            let v93 : bool = Fable.Core.RustInterop.emitRustExpr () v92 
            let v94 : string = "true; { // rust.loop"
            let v95 : bool = Fable.Core.RustInterop.emitRustExpr () v94 
            let v96 : string = "true; { // rust.loop"
            let v97 : bool = Fable.Core.RustInterop.emitRustExpr () v96 
            let v98 : string = "&sha2::Digest::finalize(v36)"
            let v99 : Ref<Slice<uint8>> = Fable.Core.RustInterop.emitRustExpr () v98 
            let v100 : string = "$0.iter().map(|x| *x).collect::<Vec<_>>()"
            let v101 : Vec<uint8> = Fable.Core.RustInterop.emitRustExpr v99 v100 
            let v102 : string = "true; let _vec_map : Vec<_> = $0.into_iter().map(|x| { //"
            let v103 : bool = Fable.Core.RustInterop.emitRustExpr v101 v102 
            let v104 : string = "x"
            let v105 : uint8 = Fable.Core.RustInterop.emitRustExpr () v104 
            let v106 : string = "format!(\"{:02x}\", $0)"
            let v107 : std_string_String = Fable.Core.RustInterop.emitRustExpr v105 v106 
            let v108 : string = "fable_library_rust::String_::fromString($0)"
            let v109 : string = Fable.Core.RustInterop.emitRustExpr v107 v108 
            let v110 : string = "true; $0 }).collect::<Vec<_>>()"
            let v111 : bool = Fable.Core.RustInterop.emitRustExpr v109 v110 
            let v112 : string = "_vec_map"
            let v113 : Vec<string> = Fable.Core.RustInterop.emitRustExpr () v112 
            let v114 : string = "fable_library_rust::NativeArray_::array_from($0)"
            let v115 : (string []) = Fable.Core.RustInterop.emitRustExpr v113 v114 
            let v116 : string seq = seq { for i = 0 to v115.Length - 1 do yield v115.[i] }
            let v119 : string = method130()
            let v120 : (string -> (string seq -> string)) = String.concat
            let v121 : (string seq -> string) = v120 v119
            let v122 : string = v121 v116
            let v125 : Result<string, std_io_Error> = Ok v122 
            let v126 : (std_io_Error -> std_string_String) = method54()
            let v127 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v128 : string = "$0.map_err(|x| $1(x))"
            let v129 : Result<string, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v125, v126) v128 
            let _v127 = v129 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v130 : string = "$0.map_err(|x| $1(x))"
            let v131 : Result<string, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v125, v126) v130 
            let _v127 = v131 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v132 : string = "$0.map_err(|x| $1(x))"
            let v133 : Result<string, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v125, v126) v132 
            let _v127 = v133 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v134 : Result<string, std_string_String> = match v125 with Ok x -> Ok x | Error x -> Error (v126 x)
            let _v127 = v134 
            #endif
#if FABLE_COMPILER_PYTHON
            let v135 : Result<string, std_string_String> = match v125 with Ok x -> Ok x | Error x -> Error (v126 x)
            let _v127 = v135 
            #endif
#else
            let v136 : Result<string, std_string_String> = match v125 with Ok x -> Ok x | Error x -> Error (v126 x)
            let _v127 = v136 
            #endif
            let v137 : Result<string, std_string_String> = _v127 
            let v140 : (string -> US33) = method131()
            let v141 : (std_string_String -> US33) = method132()
            let v142 : string = "match $2 { Ok(x) => $0(x), Err(e) => $1(e) }"
            let v143 : US33 = Fable.Core.RustInterop.emitRustExpr struct (v140, v141, v137) v142 
            let v149 : string =
                match v143 with
                | US33_1(v145) -> (* Error *)
                    let v146 : string = $"resultm.get / Result value was Error: {v145}"
                    failwith<string> v146
                | US33_0(v144) -> (* Ok *)
                    v144
            let v150 : string = method40(v6)
            let v151 : string = "std::fs::File::open(&*v150)"
            let v152 : Result<std_fs_File, std_io_Error> = Fable.Core.RustInterop.emitRustExpr () v151 
            let v153 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v154 : string = "$0.unwrap()"
            let v155 : std_fs_File = Fable.Core.RustInterop.emitRustExpr v152 v154 
            let _v153 = v155 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v156 : string = "$0.unwrap()"
            let v157 : std_fs_File = Fable.Core.RustInterop.emitRustExpr v152 v156 
            let _v153 = v157 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v158 : string = "$0.unwrap()"
            let v159 : std_fs_File = Fable.Core.RustInterop.emitRustExpr v152 v158 
            let _v153 = v159 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v160 : std_fs_File = match v152 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v153 = v160 
            #endif
#if FABLE_COMPILER_PYTHON
            let v161 : std_fs_File = match v152 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v153 = v161 
            #endif
#else
            let v162 : std_fs_File = match v152 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v153 = v162 
            #endif
            let v163 : std_fs_File = _v153 
            let v166 : string = "std::io::BufReader::new($0)"
            let v167 : std_io_BufReader<std_fs_File> = Fable.Core.RustInterop.emitRustExpr v163 v166 
            let v168 : string = "std::io::BufReader::new($0)"
            let v169 : std_io_BufReader<std_io_BufReader<std_fs_File>> = Fable.Core.RustInterop.emitRustExpr v167 v168 
            let v170 : string = "true; let mut v169 = v169"
            let v171 : bool = Fable.Core.RustInterop.emitRustExpr () v170 
            let v172 : string = "let result : sha2::Sha256 = sha2::Digest::new()"
            Fable.Core.RustInterop.emitRustExpr () v172 
            let v173 : string = "result"
            let v174 : sha2_Sha256 = Fable.Core.RustInterop.emitRustExpr () v173 
            let v175 : string = "true; let mut v174 = v174"
            let v176 : bool = Fable.Core.RustInterop.emitRustExpr () v175 
            let v177 : unativeint = 0 |> unativeint 
            let v180 : string = "[$0; 1024]"
            let v181 : Slice'<uint8> = Fable.Core.RustInterop.emitRustExpr 0uy v180 
            let v182 : string = "true; loop { // rust.loop"
            let v183 : bool = Fable.Core.RustInterop.emitRustExpr () v182 
            let v184 : string = "true; let mut v181 = v181"
            let v185 : bool = Fable.Core.RustInterop.emitRustExpr () v184 
            let v186 : string = "std::io::Read::read(&mut v169, &mut v181)"
            let v187 : Result<unativeint, std_io_Error> = Fable.Core.RustInterop.emitRustExpr () v186 
            let v188 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v189 : string = "$0.unwrap()"
            let v190 : unativeint = Fable.Core.RustInterop.emitRustExpr v187 v189 
            let _v188 = v190 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v191 : string = "$0.unwrap()"
            let v192 : unativeint = Fable.Core.RustInterop.emitRustExpr v187 v191 
            let _v188 = v192 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v193 : string = "$0.unwrap()"
            let v194 : unativeint = Fable.Core.RustInterop.emitRustExpr v187 v193 
            let _v188 = v194 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v195 : unativeint = match v187 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v188 = v195 
            #endif
#if FABLE_COMPILER_PYTHON
            let v196 : unativeint = match v187 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v188 = v196 
            #endif
#else
            let v197 : unativeint = match v187 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v188 = v197 
            #endif
            let v198 : unativeint = _v188 
            let v201 : bool = v198 = v177 
            if v201 then
                let v204 : string = "true; break"
                let v205 : bool = Fable.Core.RustInterop.emitRustExpr () v204 
                ()
            let v206 : string = "v181.len()"
            let v207 : unativeint = Fable.Core.RustInterop.emitRustExpr () v206 
            let v208 : uint8 = v207 |> uint8 
            let v211 : unativeint = v198 |> unativeint 
            let v214 : unativeint = v211 |> unbox<unativeint>
            let v217 : bool = v214 = v207 
            let v224 : Ref<Slice'<uint8>> =
                if v217 then
                    let v220 : string = "&v181[v177..]"
                    let v221 : Ref<Slice'<uint8>> = Fable.Core.RustInterop.emitRustExpr () v220 
                    v221
                else
                    let v222 : string = "&v181[$0..$1]"
                    let v223 : Ref<Slice'<uint8>> = Fable.Core.RustInterop.emitRustExpr struct (v177, v211) v222 
                    v223
            let v225 : string = "sha2::Digest::update(&mut v174, v224)"
            Fable.Core.RustInterop.emitRustExpr () v225 
            let v226 : string = "true; } // rust.loop"
            let v227 : bool = Fable.Core.RustInterop.emitRustExpr () v226 
            let v228 : string = "true; } // rust.loop"
            let v229 : bool = Fable.Core.RustInterop.emitRustExpr () v228 
            let v230 : string = "true; } // rust.loop"
            let v231 : bool = Fable.Core.RustInterop.emitRustExpr () v230 
            let v232 : string = "true; { // rust.loop"
            let v233 : bool = Fable.Core.RustInterop.emitRustExpr () v232 
            let v234 : string = "true; { // rust.loop"
            let v235 : bool = Fable.Core.RustInterop.emitRustExpr () v234 
            let v236 : string = "&sha2::Digest::finalize(v174)"
            let v237 : Ref<Slice<uint8>> = Fable.Core.RustInterop.emitRustExpr () v236 
            let v238 : string = "$0.iter().map(|x| *x).collect::<Vec<_>>()"
            let v239 : Vec<uint8> = Fable.Core.RustInterop.emitRustExpr v237 v238 
            let v240 : string = "true; let _vec_map : Vec<_> = $0.into_iter().map(|x| { //"
            let v241 : bool = Fable.Core.RustInterop.emitRustExpr v239 v240 
            let v242 : string = "x"
            let v243 : uint8 = Fable.Core.RustInterop.emitRustExpr () v242 
            let v244 : string = "format!(\"{:02x}\", $0)"
            let v245 : std_string_String = Fable.Core.RustInterop.emitRustExpr v243 v244 
            let v246 : string = "fable_library_rust::String_::fromString($0)"
            let v247 : string = Fable.Core.RustInterop.emitRustExpr v245 v246 
            let v248 : string = "true; $0 }).collect::<Vec<_>>()"
            let v249 : bool = Fable.Core.RustInterop.emitRustExpr v247 v248 
            let v250 : string = "_vec_map"
            let v251 : Vec<string> = Fable.Core.RustInterop.emitRustExpr () v250 
            let v252 : string = "fable_library_rust::NativeArray_::array_from($0)"
            let v253 : (string []) = Fable.Core.RustInterop.emitRustExpr v251 v252 
            let v254 : string seq = seq { for i = 0 to v253.Length - 1 do yield v253.[i] }
            let v257 : string = method130()
            let v258 : (string -> (string seq -> string)) = String.concat
            let v259 : (string seq -> string) = v258 v257
            let v260 : string = v259 v254
            let v263 : Result<string, std_io_Error> = Ok v260 
            let v264 : (std_io_Error -> std_string_String) = method54()
            let v265 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v266 : string = "$0.map_err(|x| $1(x))"
            let v267 : Result<string, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v263, v264) v266 
            let _v265 = v267 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v268 : string = "$0.map_err(|x| $1(x))"
            let v269 : Result<string, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v263, v264) v268 
            let _v265 = v269 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v270 : string = "$0.map_err(|x| $1(x))"
            let v271 : Result<string, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v263, v264) v270 
            let _v265 = v271 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v272 : Result<string, std_string_String> = match v263 with Ok x -> Ok x | Error x -> Error (v264 x)
            let _v265 = v272 
            #endif
#if FABLE_COMPILER_PYTHON
            let v273 : Result<string, std_string_String> = match v263 with Ok x -> Ok x | Error x -> Error (v264 x)
            let _v265 = v273 
            #endif
#else
            let v274 : Result<string, std_string_String> = match v263 with Ok x -> Ok x | Error x -> Error (v264 x)
            let _v265 = v274 
            #endif
            let v275 : Result<string, std_string_String> = _v265 
            let v278 : (string -> US33) = method131()
            let v279 : (std_string_String -> US33) = method132()
            let v280 : string = "match $2 { Ok(x) => $0(x), Err(e) => $1(e) }"
            let v281 : US33 = Fable.Core.RustInterop.emitRustExpr struct (v278, v279, v275) v280 
            let v287 : string =
                match v281 with
                | US33_1(v283) -> (* Error *)
                    let v284 : string = $"resultm.get / Result value was Error: {v283}"
                    failwith<string> v284
                | US33_0(v282) -> (* Ok *)
                    v282
            let v288 : bool = v149 = v287
            v288
    if v289 then
        US32_1
    else
        let v291 : US35 = method153(v2, v5, v3, v1, v4)
        match v291 with
        | US35_1(v347, v348) -> (* Error *)
            let v349 : (string * string) = v5, v348 
            let v350 : Result<string, (string * string)> = Error v349 
            US32_0(v350)
        | US35_0(v292, v293) -> (* Ok *)
            let v294 : bool = v292 <> 0 
            if v294 then
                let v297 : unit = ()
                let v298 : (unit -> unit) = closure77(v293, v292)
                let v299 : unit = (fun () -> v298 (); v297) ()
                let v339 : (string * string) = v5, v293 
                let v340 : Result<string, (string * string)> = Error v339 
                US32_0(v340)
            else
                let v342 : bool = method133(v5)
                if v342 then
                    method136(v6, v5)
                else
                    let v343 : string = $"documents.files_fn / {v5} should exist"
                    failwith<unit> v343
                let v344 : Result<string, (string * string)> = Ok v5 
                US32_0(v344)
and closure78 (v0 : string, v1 : string, v2 : bool) (v3 : string) : (string -> US32) =
    closure79(v0, v1, v2, v3)
and method157 (v0 : string, v1 : string) : string =
    let v2 : string = method14()
    let v3 : Mut3 = {l0 = v2} : Mut3
    let v4 : string = "{ "
    let v5 : string = $"{v4}"
    let v8 : unit = ()
    let v9 : (unit -> unit) = closure8(v3, v5)
    let v10 : unit = (fun () -> v9 (); v8) ()
    let v13 : string = "output_path"
    let v14 : string = $"{v13}"
    let v17 : unit = ()
    let v18 : (unit -> unit) = closure8(v3, v14)
    let v19 : unit = (fun () -> v18 (); v17) ()
    let v22 : string = " = "
    let v23 : string = $"{v22}"
    let v26 : unit = ()
    let v27 : (unit -> unit) = closure8(v3, v23)
    let v28 : unit = (fun () -> v27 (); v26) ()
    let v31 : string = $"{v0}"
    let v34 : unit = ()
    let v35 : (unit -> unit) = closure8(v3, v31)
    let v36 : unit = (fun () -> v35 (); v34) ()
    let v39 : string = "; "
    let v40 : string = $"{v39}"
    let v43 : unit = ()
    let v44 : (unit -> unit) = closure8(v3, v40)
    let v45 : unit = (fun () -> v44 (); v43) ()
    let v48 : string = "output_cache_path"
    let v49 : string = $"{v48}"
    let v52 : unit = ()
    let v53 : (unit -> unit) = closure8(v3, v49)
    let v54 : unit = (fun () -> v53 (); v52) ()
    let v57 : string = $"{v22}"
    let v60 : unit = ()
    let v61 : (unit -> unit) = closure8(v3, v57)
    let v62 : unit = (fun () -> v61 (); v60) ()
    let v65 : string = $"{v1}"
    let v68 : unit = ()
    let v69 : (unit -> unit) = closure8(v3, v65)
    let v70 : unit = (fun () -> v69 (); v68) ()
    let v73 : string = " }"
    let v74 : string = $"{v73}"
    let v77 : unit = ()
    let v78 : (unit -> unit) = closure8(v3, v74)
    let v79 : unit = (fun () -> v78 (); v77) ()
    let v82 : string = v3.l0
    v82
and method156 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : string, v9 : string) : string =
    let v10 : string = method157(v8, v9)
    let v11 : int64 = v0.l0
    let v12 : string = "documents.run / par_map / files' = [] / listm.iter"
    let v13 : string = $"{v6} {v7} #{v11} %s{v12} / {v10}"
    method18(v13)
and closure81 (v0 : string, v1 : string) () : unit =
    let v2 : US0 = US0_2
    let v3 : bool = method7(v2)
    if v3 then
        let v4 : unit = ()
        let v5 : (unit -> unit) = closure6()
        let v6 : unit = (fun () -> v5 (); v4) ()
        let struct (v20 : Mut0, v21 : Mut1, v22 : Mut2, v23 : Mut3, v24 : Mut4, v25 : int64 option) = TraceState.trace_state.Value
        let v38 : string = method8(v20, v21, v22, v23, v24, v25)
        let v39 : string = method12()
        let v40 : string = method156(v20, v21, v22, v23, v24, v25, v38, v39, v1, v0)
        method19(v40)
and method158 (v0 : UH4, v1 : UH5 list) : UH5 list =
    match v0 with
    | UH4_1(v2, v3) -> (* Cons *)
        let v4 : UH5 list = method158(v3, v1)
        let v5 : UH5 list = v2 :: v4 
        v5
    | UH4_0 -> (* Nil *)
        v1
and method159 (v0 : int32, v1 : Mut9) : bool =
    let v2 : int32 = v1.l0
    let v3 : bool = v2 < v0
    v3
and method160 (v0 : UH5, v1 : struct (string * string * (string -> (string -> US32))) list) : struct (string * string * (string -> (string -> US32))) list =
    match v0 with
    | UH5_1(v2, v3, v4, v5) -> (* Cons *)
        let v6 : struct (string * string * (string -> (string -> US32))) list = method160(v5, v1)
        let v7 : struct (string * string * (string -> (string -> US32))) list = struct (v2, v3, v4) :: v6 
        v7
    | UH5_0 -> (* Nil *)
        v1
and closure82 () struct (v0 : string, v1 : string, v2 : (string -> (string -> US32))) : Result<string, (string * string)> option =
    let v3 : (string -> US32) = v2 v1
    let v4 : US32 = v3 v0
    match v4 with
    | US32_1 -> (* None *)
        let v9 : Result<string, (string * string)> option = None
        v9
    | US32_0(v5) -> (* Some *)
        let v6 : Result<string, (string * string)> option = Some v5 
        v6
and method161 (v0 : Vec<Result<string, (string * string)> option>) : Vec<Result<string, (string * string)> option> =
    v0
and method162 (v0 : Vec<Result<string, (string * string)> option>) : Vec<Result<string, (string * string)> option> =
    v0
and closure30 (v0 : string, v1 : string, v2 : string, v3 : string, v4 : string) (v5 : string) : Result<(string * Vec<Result<string, (string * string)> option>), std_string_String> =
    let v6 : string = method39(v5)
    let v7 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v8 : string = "&*$0"
    let v9 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v8 
    let _v7 = v9 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v10 : string = "&*$0"
    let v11 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v10 
    let _v7 = v11 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v12 : string = "&*$0"
    let v13 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6 v12 
    let _v7 = v13 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v14 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v7 = v14 
    #endif
#if FABLE_COMPILER_PYTHON
    let v17 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v7 = v17 
    #endif
#else
    let v20 : Ref<Str> = v6 |> unbox<Ref<Str>>
    let _v7 = v20 
    #endif
    let v23 : Ref<Str> = _v7 
    let v28 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v29 : string = "String::from($0)"
    let v30 : std_string_String = Fable.Core.RustInterop.emitRustExpr v23 v29 
    let _v28 = v30 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v31 : string = "String::from($0)"
    let v32 : std_string_String = Fable.Core.RustInterop.emitRustExpr v23 v31 
    let _v28 = v32 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v33 : string = "String::from($0)"
    let v34 : std_string_String = Fable.Core.RustInterop.emitRustExpr v23 v33 
    let _v28 = v34 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v35 : std_string_String = v23 |> unbox<std_string_String>
    let _v28 = v35 
    #endif
#if FABLE_COMPILER_PYTHON
    let v38 : std_string_String = v23 |> unbox<std_string_String>
    let _v28 = v38 
    #endif
#else
    let v41 : std_string_String = v23 |> unbox<std_string_String>
    let _v28 = v41 
    #endif
    let v44 : std_string_String = _v28 
    let v49 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v50 : string = "std::path::PathBuf::from($0)"
    let v51 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v44 v50 
    let _v49 = v51 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v52 : string = "std::path::PathBuf::from($0)"
    let v53 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v44 v52 
    let _v49 = v53 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v54 : string = "std::path::PathBuf::from($0)"
    let v55 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v44 v54 
    let _v49 = v55 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v56 : std_path_PathBuf = v44 |> std_path_PathBuf 
    let _v49 = v56 
    #endif
#if FABLE_COMPILER_PYTHON
    let v59 : std_path_PathBuf = v44 |> std_path_PathBuf 
    let _v49 = v59 
    #endif
#else
    let v62 : std_path_PathBuf = v44 |> std_path_PathBuf 
    let _v49 = v62 
    #endif
    let v65 : std_path_PathBuf = _v49 
    let v70 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v71 : string = "$0.display()"
    let v72 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v65 v71 
    let _v70 = v72 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v73 : string = "$0.display()"
    let v74 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v65 v73 
    let _v70 = v74 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v75 : string = "$0.display()"
    let v76 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v65 v75 
    let _v70 = v76 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v77 : std_path_Display = v65 |> unbox<std_path_Display>
    let _v70 = v77 
    #endif
#if FABLE_COMPILER_PYTHON
    let v80 : std_path_Display = v65 |> unbox<std_path_Display>
    let _v70 = v80 
    #endif
#else
    let v83 : std_path_Display = v65 |> unbox<std_path_Display>
    let _v70 = v83 
    #endif
    let v86 : std_path_Display = _v70 
    let v91 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v92 : string = "format!(\"{}\", $0)"
    let v93 : std_string_String = Fable.Core.RustInterop.emitRustExpr v86 v92 
    let _v91 = v93 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v94 : string = "format!(\"{}\", $0)"
    let v95 : std_string_String = Fable.Core.RustInterop.emitRustExpr v86 v94 
    let _v91 = v95 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v96 : string = "format!(\"{}\", $0)"
    let v97 : std_string_String = Fable.Core.RustInterop.emitRustExpr v86 v96 
    let _v91 = v97 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v98 : std_string_String = null |> unbox<std_string_String>
    let _v91 = v98 
    #endif
#if FABLE_COMPILER_PYTHON
    let v101 : std_string_String = null |> unbox<std_string_String>
    let _v91 = v101 
    #endif
#else
    let v104 : std_string_String = null |> unbox<std_string_String>
    let _v91 = v104 
    #endif
    let v107 : std_string_String = _v91 
    let v112 : string = "fable_library_rust::String_::fromString($0)"
    let v113 : string = Fable.Core.RustInterop.emitRustExpr v107 v112 
    let v114 : string = method65()
    let v115 : string = v113.Replace (v3, v114)
    let v116 : string = "\\"
    let v117 : string = "/"
    let v118 : string = v115.Replace (v116, v117)
    let v119 : string = $".{v118}"
    let v120 : string = method40(v6)
    let v121 : string = method26(v2, v119)
    let v122 : string = method66(v121)
    let v123 : System.Threading.CancellationToken option = None
    let v124 : (struct (string * string) []) = [||]
    let v125 : (struct (int32 * string * bool) -> Async<unit>) option = None
    let v126 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit) option = None
    let v127 : string option = None
    let v128 : string = $"git ls-tree --format='%%(objectname)' origin/gh-pages \"{v122}\""
    let v129 : string option = Some v2 
    let v132 : bool = true
    let struct (v133 : int32, v134 : string) = method67(v128, v123, v124, v125, v126, v132, v129)
    let v135 : string = method26(v3, v119)
    let v136 : string = method66(v135)
    let v137 : System.Threading.CancellationToken option = None
    let v138 : (struct (string * string) []) = [||]
    let v139 : (struct (int32 * string * bool) -> Async<unit>) option = None
    let v140 : (std_sync_Arc<std_sync_Mutex<std_process_ChildStdin>> -> unit) option = None
    let v141 : string option = None
    let v142 : string = $"git hash-object \"{v136}\""
    let v143 : string option = Some v3 
    let v146 : bool = true
    let struct (v147 : int32, v148 : string) = method67(v142, v137, v138, v139, v140, v146, v143)
    let v149 : string = method26(v4, v119)
    let v150 : string = method66(v149)
    let v151 : string = "hangul.md"
    let struct (v152 : string, v153 : string) = method129(v151, v136, v4)
    let v154 : bool = false
    let v155 : bool = false
    let v156 : bool = false
    let v157 : bool = true
    let v158 : bool = true
    let v159 : bool = true
    let v160 : bool = v134.Contains v148 
    let v593 : UH4 =
        if v160 then
            UH4_0
        else
            let v164 : string = method40(v136)
            let v165 : string = "std::fs::File::open(&*v164)"
            let v166 : Result<std_fs_File, std_io_Error> = Fable.Core.RustInterop.emitRustExpr () v165 
            let v167 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v168 : string = "$0.unwrap()"
            let v169 : std_fs_File = Fable.Core.RustInterop.emitRustExpr v166 v168 
            let _v167 = v169 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v170 : string = "$0.unwrap()"
            let v171 : std_fs_File = Fable.Core.RustInterop.emitRustExpr v166 v170 
            let _v167 = v171 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v172 : string = "$0.unwrap()"
            let v173 : std_fs_File = Fable.Core.RustInterop.emitRustExpr v166 v172 
            let _v167 = v173 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v174 : std_fs_File = match v166 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v167 = v174 
            #endif
#if FABLE_COMPILER_PYTHON
            let v175 : std_fs_File = match v166 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v167 = v175 
            #endif
#else
            let v176 : std_fs_File = match v166 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v167 = v176 
            #endif
            let v177 : std_fs_File = _v167 
            let v180 : string = "std::io::BufReader::new($0)"
            let v181 : std_io_BufReader<std_fs_File> = Fable.Core.RustInterop.emitRustExpr v177 v180 
            let v182 : string = "std::io::BufReader::new($0)"
            let v183 : std_io_BufReader<std_io_BufReader<std_fs_File>> = Fable.Core.RustInterop.emitRustExpr v181 v182 
            let v184 : string = "true; let mut v183 = v183"
            let v185 : bool = Fable.Core.RustInterop.emitRustExpr () v184 
            let v186 : string = "let result : sha2::Sha256 = sha2::Digest::new()"
            Fable.Core.RustInterop.emitRustExpr () v186 
            let v187 : string = "result"
            let v188 : sha2_Sha256 = Fable.Core.RustInterop.emitRustExpr () v187 
            let v189 : string = "true; let mut v188 = v188"
            let v190 : bool = Fable.Core.RustInterop.emitRustExpr () v189 
            let v191 : unativeint = 0 |> unativeint 
            let v194 : string = "[$0; 1024]"
            let v195 : Slice'<uint8> = Fable.Core.RustInterop.emitRustExpr 0uy v194 
            let v196 : string = "true; loop { // rust.loop"
            let v197 : bool = Fable.Core.RustInterop.emitRustExpr () v196 
            let v198 : string = "true; let mut v195 = v195"
            let v199 : bool = Fable.Core.RustInterop.emitRustExpr () v198 
            let v200 : string = "std::io::Read::read(&mut v183, &mut v195)"
            let v201 : Result<unativeint, std_io_Error> = Fable.Core.RustInterop.emitRustExpr () v200 
            let v202 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v203 : string = "$0.unwrap()"
            let v204 : unativeint = Fable.Core.RustInterop.emitRustExpr v201 v203 
            let _v202 = v204 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v205 : string = "$0.unwrap()"
            let v206 : unativeint = Fable.Core.RustInterop.emitRustExpr v201 v205 
            let _v202 = v206 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v207 : string = "$0.unwrap()"
            let v208 : unativeint = Fable.Core.RustInterop.emitRustExpr v201 v207 
            let _v202 = v208 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v209 : unativeint = match v201 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v202 = v209 
            #endif
#if FABLE_COMPILER_PYTHON
            let v210 : unativeint = match v201 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v202 = v210 
            #endif
#else
            let v211 : unativeint = match v201 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v202 = v211 
            #endif
            let v212 : unativeint = _v202 
            let v215 : bool = v212 = v191 
            if v215 then
                let v218 : string = "true; break"
                let v219 : bool = Fable.Core.RustInterop.emitRustExpr () v218 
                ()
            let v220 : string = "v195.len()"
            let v221 : unativeint = Fable.Core.RustInterop.emitRustExpr () v220 
            let v222 : uint8 = v221 |> uint8 
            let v225 : unativeint = v212 |> unativeint 
            let v228 : unativeint = v225 |> unbox<unativeint>
            let v231 : bool = v228 = v221 
            let v238 : Ref<Slice'<uint8>> =
                if v231 then
                    let v234 : string = "&v195[v191..]"
                    let v235 : Ref<Slice'<uint8>> = Fable.Core.RustInterop.emitRustExpr () v234 
                    v235
                else
                    let v236 : string = "&v195[$0..$1]"
                    let v237 : Ref<Slice'<uint8>> = Fable.Core.RustInterop.emitRustExpr struct (v191, v225) v236 
                    v237
            let v239 : string = "sha2::Digest::update(&mut v188, v238)"
            Fable.Core.RustInterop.emitRustExpr () v239 
            let v240 : string = "true; } // rust.loop"
            let v241 : bool = Fable.Core.RustInterop.emitRustExpr () v240 
            let v242 : string = "true; } // rust.loop"
            let v243 : bool = Fable.Core.RustInterop.emitRustExpr () v242 
            let v244 : string = "true; } // rust.loop"
            let v245 : bool = Fable.Core.RustInterop.emitRustExpr () v244 
            let v246 : string = "true; { // rust.loop"
            let v247 : bool = Fable.Core.RustInterop.emitRustExpr () v246 
            let v248 : string = "true; { // rust.loop"
            let v249 : bool = Fable.Core.RustInterop.emitRustExpr () v248 
            let v250 : string = "&sha2::Digest::finalize(v188)"
            let v251 : Ref<Slice<uint8>> = Fable.Core.RustInterop.emitRustExpr () v250 
            let v252 : string = "$0.iter().map(|x| *x).collect::<Vec<_>>()"
            let v253 : Vec<uint8> = Fable.Core.RustInterop.emitRustExpr v251 v252 
            let v254 : string = "true; let _vec_map : Vec<_> = $0.into_iter().map(|x| { //"
            let v255 : bool = Fable.Core.RustInterop.emitRustExpr v253 v254 
            let v256 : string = "x"
            let v257 : uint8 = Fable.Core.RustInterop.emitRustExpr () v256 
            let v258 : string = "format!(\"{:02x}\", $0)"
            let v259 : std_string_String = Fable.Core.RustInterop.emitRustExpr v257 v258 
            let v260 : string = "fable_library_rust::String_::fromString($0)"
            let v261 : string = Fable.Core.RustInterop.emitRustExpr v259 v260 
            let v262 : string = "true; $0 }).collect::<Vec<_>>()"
            let v263 : bool = Fable.Core.RustInterop.emitRustExpr v261 v262 
            let v264 : string = "_vec_map"
            let v265 : Vec<string> = Fable.Core.RustInterop.emitRustExpr () v264 
            let v266 : string = "fable_library_rust::NativeArray_::array_from($0)"
            let v267 : (string []) = Fable.Core.RustInterop.emitRustExpr v265 v266 
            let v268 : string seq = seq { for i = 0 to v267.Length - 1 do yield v267.[i] }
            let v271 : string = method130()
            let v272 : (string -> (string seq -> string)) = String.concat
            let v273 : (string seq -> string) = v272 v271
            let v274 : string = v273 v268
            let v277 : Result<string, std_io_Error> = Ok v274 
            let v278 : (std_io_Error -> std_string_String) = method54()
            let v279 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v280 : string = "$0.map_err(|x| $1(x))"
            let v281 : Result<string, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v277, v278) v280 
            let _v279 = v281 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v282 : string = "$0.map_err(|x| $1(x))"
            let v283 : Result<string, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v277, v278) v282 
            let _v279 = v283 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v284 : string = "$0.map_err(|x| $1(x))"
            let v285 : Result<string, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v277, v278) v284 
            let _v279 = v285 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v286 : Result<string, std_string_String> = match v277 with Ok x -> Ok x | Error x -> Error (v278 x)
            let _v279 = v286 
            #endif
#if FABLE_COMPILER_PYTHON
            let v287 : Result<string, std_string_String> = match v277 with Ok x -> Ok x | Error x -> Error (v278 x)
            let _v279 = v287 
            #endif
#else
            let v288 : Result<string, std_string_String> = match v277 with Ok x -> Ok x | Error x -> Error (v278 x)
            let _v279 = v288 
            #endif
            let v289 : Result<string, std_string_String> = _v279 
            let v292 : (string -> US33) = method131()
            let v293 : (std_string_String -> US33) = method132()
            let v294 : string = "match $2 { Ok(x) => $0(x), Err(e) => $1(e) }"
            let v295 : US33 = Fable.Core.RustInterop.emitRustExpr struct (v292, v293, v289) v294 
            let v301 : string =
                match v295 with
                | US33_1(v297) -> (* Error *)
                    let v298 : string = $"resultm.get / Result value was Error: {v297}"
                    failwith<string> v298
                | US33_0(v296) -> (* Ok *)
                    v296
            let v302 : bool = method133(v150)
            let v303 : bool = v302 = false
            let v443 : US1 =
                if v303 then
                    US1_1
                else
                    let v305 : string = method40(v150)
                    let v306 : string = "std::fs::File::open(&*v305)"
                    let v307 : Result<std_fs_File, std_io_Error> = Fable.Core.RustInterop.emitRustExpr () v306 
                    let v308 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v309 : string = "$0.unwrap()"
                    let v310 : std_fs_File = Fable.Core.RustInterop.emitRustExpr v307 v309 
                    let _v308 = v310 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v311 : string = "$0.unwrap()"
                    let v312 : std_fs_File = Fable.Core.RustInterop.emitRustExpr v307 v311 
                    let _v308 = v312 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v313 : string = "$0.unwrap()"
                    let v314 : std_fs_File = Fable.Core.RustInterop.emitRustExpr v307 v313 
                    let _v308 = v314 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v315 : std_fs_File = match v307 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
                    let _v308 = v315 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v316 : std_fs_File = match v307 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
                    let _v308 = v316 
                    #endif
#else
                    let v317 : std_fs_File = match v307 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
                    let _v308 = v317 
                    #endif
                    let v318 : std_fs_File = _v308 
                    let v321 : string = "std::io::BufReader::new($0)"
                    let v322 : std_io_BufReader<std_fs_File> = Fable.Core.RustInterop.emitRustExpr v318 v321 
                    let v323 : string = "std::io::BufReader::new($0)"
                    let v324 : std_io_BufReader<std_io_BufReader<std_fs_File>> = Fable.Core.RustInterop.emitRustExpr v322 v323 
                    let v325 : string = "true; let mut v324 = v324"
                    let v326 : bool = Fable.Core.RustInterop.emitRustExpr () v325 
                    let v327 : string = "let result : sha2::Sha256 = sha2::Digest::new()"
                    Fable.Core.RustInterop.emitRustExpr () v327 
                    let v328 : string = "result"
                    let v329 : sha2_Sha256 = Fable.Core.RustInterop.emitRustExpr () v328 
                    let v330 : string = "true; let mut v329 = v329"
                    let v331 : bool = Fable.Core.RustInterop.emitRustExpr () v330 
                    let v332 : unativeint = 0 |> unativeint 
                    let v335 : string = "[$0; 1024]"
                    let v336 : Slice'<uint8> = Fable.Core.RustInterop.emitRustExpr 0uy v335 
                    let v337 : string = "true; loop { // rust.loop"
                    let v338 : bool = Fable.Core.RustInterop.emitRustExpr () v337 
                    let v339 : string = "true; let mut v336 = v336"
                    let v340 : bool = Fable.Core.RustInterop.emitRustExpr () v339 
                    let v341 : string = "std::io::Read::read(&mut v324, &mut v336)"
                    let v342 : Result<unativeint, std_io_Error> = Fable.Core.RustInterop.emitRustExpr () v341 
                    let v343 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v344 : string = "$0.unwrap()"
                    let v345 : unativeint = Fable.Core.RustInterop.emitRustExpr v342 v344 
                    let _v343 = v345 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v346 : string = "$0.unwrap()"
                    let v347 : unativeint = Fable.Core.RustInterop.emitRustExpr v342 v346 
                    let _v343 = v347 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v348 : string = "$0.unwrap()"
                    let v349 : unativeint = Fable.Core.RustInterop.emitRustExpr v342 v348 
                    let _v343 = v349 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v350 : unativeint = match v342 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
                    let _v343 = v350 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v351 : unativeint = match v342 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
                    let _v343 = v351 
                    #endif
#else
                    let v352 : unativeint = match v342 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
                    let _v343 = v352 
                    #endif
                    let v353 : unativeint = _v343 
                    let v356 : bool = v353 = v332 
                    if v356 then
                        let v359 : string = "true; break"
                        let v360 : bool = Fable.Core.RustInterop.emitRustExpr () v359 
                        ()
                    let v361 : string = "v336.len()"
                    let v362 : unativeint = Fable.Core.RustInterop.emitRustExpr () v361 
                    let v363 : uint8 = v362 |> uint8 
                    let v366 : unativeint = v353 |> unativeint 
                    let v369 : unativeint = v366 |> unbox<unativeint>
                    let v372 : bool = v369 = v362 
                    let v379 : Ref<Slice'<uint8>> =
                        if v372 then
                            let v375 : string = "&v336[v332..]"
                            let v376 : Ref<Slice'<uint8>> = Fable.Core.RustInterop.emitRustExpr () v375 
                            v376
                        else
                            let v377 : string = "&v336[$0..$1]"
                            let v378 : Ref<Slice'<uint8>> = Fable.Core.RustInterop.emitRustExpr struct (v332, v366) v377 
                            v378
                    let v380 : string = "sha2::Digest::update(&mut v329, v379)"
                    Fable.Core.RustInterop.emitRustExpr () v380 
                    let v381 : string = "true; } // rust.loop"
                    let v382 : bool = Fable.Core.RustInterop.emitRustExpr () v381 
                    let v383 : string = "true; } // rust.loop"
                    let v384 : bool = Fable.Core.RustInterop.emitRustExpr () v383 
                    let v385 : string = "true; } // rust.loop"
                    let v386 : bool = Fable.Core.RustInterop.emitRustExpr () v385 
                    let v387 : string = "true; { // rust.loop"
                    let v388 : bool = Fable.Core.RustInterop.emitRustExpr () v387 
                    let v389 : string = "true; { // rust.loop"
                    let v390 : bool = Fable.Core.RustInterop.emitRustExpr () v389 
                    let v391 : string = "&sha2::Digest::finalize(v329)"
                    let v392 : Ref<Slice<uint8>> = Fable.Core.RustInterop.emitRustExpr () v391 
                    let v393 : string = "$0.iter().map(|x| *x).collect::<Vec<_>>()"
                    let v394 : Vec<uint8> = Fable.Core.RustInterop.emitRustExpr v392 v393 
                    let v395 : string = "true; let _vec_map : Vec<_> = $0.into_iter().map(|x| { //"
                    let v396 : bool = Fable.Core.RustInterop.emitRustExpr v394 v395 
                    let v397 : string = "x"
                    let v398 : uint8 = Fable.Core.RustInterop.emitRustExpr () v397 
                    let v399 : string = "format!(\"{:02x}\", $0)"
                    let v400 : std_string_String = Fable.Core.RustInterop.emitRustExpr v398 v399 
                    let v401 : string = "fable_library_rust::String_::fromString($0)"
                    let v402 : string = Fable.Core.RustInterop.emitRustExpr v400 v401 
                    let v403 : string = "true; $0 }).collect::<Vec<_>>()"
                    let v404 : bool = Fable.Core.RustInterop.emitRustExpr v402 v403 
                    let v405 : string = "_vec_map"
                    let v406 : Vec<string> = Fable.Core.RustInterop.emitRustExpr () v405 
                    let v407 : string = "fable_library_rust::NativeArray_::array_from($0)"
                    let v408 : (string []) = Fable.Core.RustInterop.emitRustExpr v406 v407 
                    let v409 : string seq = seq { for i = 0 to v408.Length - 1 do yield v408.[i] }
                    let v412 : string = method130()
                    let v413 : (string -> (string seq -> string)) = String.concat
                    let v414 : (string seq -> string) = v413 v412
                    let v415 : string = v414 v409
                    let v418 : Result<string, std_io_Error> = Ok v415 
                    let v419 : (std_io_Error -> std_string_String) = method54()
                    let v420 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v421 : string = "$0.map_err(|x| $1(x))"
                    let v422 : Result<string, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v418, v419) v421 
                    let _v420 = v422 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v423 : string = "$0.map_err(|x| $1(x))"
                    let v424 : Result<string, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v418, v419) v423 
                    let _v420 = v424 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v425 : string = "$0.map_err(|x| $1(x))"
                    let v426 : Result<string, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v418, v419) v425 
                    let _v420 = v426 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v427 : Result<string, std_string_String> = match v418 with Ok x -> Ok x | Error x -> Error (v419 x)
                    let _v420 = v427 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v428 : Result<string, std_string_String> = match v418 with Ok x -> Ok x | Error x -> Error (v419 x)
                    let _v420 = v428 
                    #endif
#else
                    let v429 : Result<string, std_string_String> = match v418 with Ok x -> Ok x | Error x -> Error (v419 x)
                    let _v420 = v429 
                    #endif
                    let v430 : Result<string, std_string_String> = _v420 
                    let v433 : (string -> US33) = method131()
                    let v434 : (std_string_String -> US33) = method132()
                    let v435 : string = "match $2 { Ok(x) => $0(x), Err(e) => $1(e) }"
                    let v436 : US33 = Fable.Core.RustInterop.emitRustExpr struct (v433, v434, v430) v435 
                    match v436 with
                    | US33_1(v439) -> (* Error *)
                        US1_1
                    | US33_0(v437) -> (* Ok *)
                        US1_0(v437)
            match v443 with
            | US1_0(v444) -> (* Some *)
                let v445 : bool = v301 = v444
                if v445 then
                    UH4_0
                else
                    let v447 : unit = ()
                    let v448 : (unit -> unit) = closure68(v119, v120, v122, v134, v133, v136, v148, v147, v150, v301, v443)
                    let v449 : unit = (fun () -> v448 (); v447) ()
                    method136(v150, v136)
                    let v497 : (string -> (string -> US32)) = closure73(v4, v3, v1, v0)
                    let v498 : UH5 = UH5_0
                    let v499 : UH5 = UH5_1(v151, v136, v497, v498)
                    let v500 : string = "html"
                    let v501 : (string -> (string -> US32)) = closure78(v4, v3, v154)
                    let v502 : string = "pdf"
                    let v503 : (string -> (string -> US32)) = closure78(v4, v3, v155)
                    let v504 : string = "epub"
                    let v505 : (string -> (string -> US32)) = closure78(v4, v3, v156)
                    let v506 : (string -> (string -> US32)) = closure78(v4, v3, v157)
                    let v507 : (string -> (string -> US32)) = closure78(v4, v3, v158)
                    let v508 : (string -> (string -> US32)) = closure78(v4, v3, v159)
                    let v509 : UH5 = UH5_0
                    let v510 : UH5 = UH5_1(v504, v152, v508, v509)
                    let v511 : UH5 = UH5_1(v502, v152, v507, v510)
                    let v512 : UH5 = UH5_1(v500, v152, v506, v511)
                    let v513 : UH5 = UH5_1(v504, v136, v505, v512)
                    let v514 : UH5 = UH5_1(v502, v136, v503, v513)
                    let v515 : UH5 = UH5_1(v500, v136, v501, v514)
                    let v516 : UH4 = UH4_0
                    let v517 : UH4 = UH4_1(v515, v516)
                    UH4_1(v499, v517)
            | _ ->
                let v520 : unit = ()
                let v521 : (unit -> unit) = closure68(v119, v120, v122, v134, v133, v136, v148, v147, v150, v301, v443)
                let v522 : unit = (fun () -> v521 (); v520) ()
                method136(v150, v136)
                let v570 : (string -> (string -> US32)) = closure73(v4, v3, v1, v0)
                let v571 : UH5 = UH5_0
                let v572 : UH5 = UH5_1(v151, v136, v570, v571)
                let v573 : string = "html"
                let v574 : (string -> (string -> US32)) = closure78(v4, v3, v154)
                let v575 : string = "pdf"
                let v576 : (string -> (string -> US32)) = closure78(v4, v3, v155)
                let v577 : string = "epub"
                let v578 : (string -> (string -> US32)) = closure78(v4, v3, v156)
                let v579 : (string -> (string -> US32)) = closure78(v4, v3, v157)
                let v580 : (string -> (string -> US32)) = closure78(v4, v3, v158)
                let v581 : (string -> (string -> US32)) = closure78(v4, v3, v159)
                let v582 : UH5 = UH5_0
                let v583 : UH5 = UH5_1(v577, v152, v581, v582)
                let v584 : UH5 = UH5_1(v575, v152, v580, v583)
                let v585 : UH5 = UH5_1(v573, v152, v579, v584)
                let v586 : UH5 = UH5_1(v577, v136, v578, v585)
                let v587 : UH5 = UH5_1(v575, v136, v576, v586)
                let v588 : UH5 = UH5_1(v573, v136, v574, v587)
                let v589 : UH4 = UH4_0
                let v590 : UH4 = UH4_1(v588, v589)
                UH4_1(v572, v590)
    let v594 : bool =
        match v593 with
        | UH4_0 -> (* Nil *)
            true
        | _ ->
            false
    let v595 : bool = v594 <> true
    let v970 : UH4 =
        if v595 then
            v593
        else
            let v596 : string = "epub"
            let struct (v597 : string, v598 : string) = method129(v596, v152, v4)
            let v599 : bool = method133(v597)
            let v645 : bool =
                if v599 then
                    true
                else
                    let v600 : bool = method133(v598)
                    let v601 : bool = v600 = false
                    if v601 then
                        true
                    else
                        let v602 : unit = ()
                        let v603 : (unit -> unit) = closure81(v598, v597)
                        let v604 : unit = (fun () -> v603 (); v602) ()
                        method136(v597, v598)
                        false
            let v650 : UH5 =
                if v645 then
                    let v646 : (string -> (string -> US32)) = closure78(v4, v3, v159)
                    let v647 : UH5 = UH5_0
                    UH5_1(v596, v152, v646, v647)
                else
                    UH5_0
            let v651 : string = "pdf"
            let struct (v652 : string, v653 : string) = method129(v651, v152, v4)
            let v654 : bool = method133(v652)
            let v700 : bool =
                if v654 then
                    true
                else
                    let v655 : bool = method133(v653)
                    let v656 : bool = v655 = false
                    if v656 then
                        true
                    else
                        let v657 : unit = ()
                        let v658 : (unit -> unit) = closure81(v653, v652)
                        let v659 : unit = (fun () -> v658 (); v657) ()
                        method136(v652, v653)
                        false
            let v703 : UH5 =
                if v700 then
                    let v701 : (string -> (string -> US32)) = closure78(v4, v3, v158)
                    UH5_1(v651, v152, v701, v650)
                else
                    v650
            let v704 : string = "html"
            let struct (v705 : string, v706 : string) = method129(v704, v152, v4)
            let v707 : bool = method133(v705)
            let v753 : bool =
                if v707 then
                    true
                else
                    let v708 : bool = method133(v706)
                    let v709 : bool = v708 = false
                    if v709 then
                        true
                    else
                        let v710 : unit = ()
                        let v711 : (unit -> unit) = closure81(v706, v705)
                        let v712 : unit = (fun () -> v711 (); v710) ()
                        method136(v705, v706)
                        false
            let v756 : UH5 =
                if v753 then
                    let v754 : (string -> (string -> US32)) = closure78(v4, v3, v157)
                    UH5_1(v704, v152, v754, v703)
                else
                    v703
            let struct (v757 : string, v758 : string) = method129(v596, v136, v4)
            let v759 : bool = method133(v757)
            let v805 : bool =
                if v759 then
                    true
                else
                    let v760 : bool = method133(v758)
                    let v761 : bool = v760 = false
                    if v761 then
                        true
                    else
                        let v762 : unit = ()
                        let v763 : (unit -> unit) = closure81(v758, v757)
                        let v764 : unit = (fun () -> v763 (); v762) ()
                        method136(v757, v758)
                        false
            let v808 : UH5 =
                if v805 then
                    let v806 : (string -> (string -> US32)) = closure78(v4, v3, v156)
                    UH5_1(v596, v136, v806, v756)
                else
                    v756
            let struct (v809 : string, v810 : string) = method129(v651, v136, v4)
            let v811 : bool = method133(v809)
            let v857 : bool =
                if v811 then
                    true
                else
                    let v812 : bool = method133(v810)
                    let v813 : bool = v812 = false
                    if v813 then
                        true
                    else
                        let v814 : unit = ()
                        let v815 : (unit -> unit) = closure81(v810, v809)
                        let v816 : unit = (fun () -> v815 (); v814) ()
                        method136(v809, v810)
                        false
            let v860 : UH5 =
                if v857 then
                    let v858 : (string -> (string -> US32)) = closure78(v4, v3, v155)
                    UH5_1(v651, v136, v858, v808)
                else
                    v808
            let struct (v861 : string, v862 : string) = method129(v704, v136, v4)
            let v863 : bool = method133(v861)
            let v909 : bool =
                if v863 then
                    true
                else
                    let v864 : bool = method133(v862)
                    let v865 : bool = v864 = false
                    if v865 then
                        true
                    else
                        let v866 : unit = ()
                        let v867 : (unit -> unit) = closure81(v862, v861)
                        let v868 : unit = (fun () -> v867 (); v866) ()
                        method136(v861, v862)
                        false
            let v912 : UH5 =
                if v909 then
                    let v910 : (string -> (string -> US32)) = closure78(v4, v3, v154)
                    UH5_1(v704, v136, v910, v860)
                else
                    v860
            let struct (v913 : string, v914 : string) = method129(v151, v136, v4)
            let v915 : bool = method133(v913)
            let v961 : bool =
                if v915 then
                    true
                else
                    let v916 : bool = method133(v914)
                    let v917 : bool = v916 = false
                    if v917 then
                        true
                    else
                        let v918 : unit = ()
                        let v919 : (unit -> unit) = closure81(v914, v913)
                        let v920 : unit = (fun () -> v919 (); v918) ()
                        method136(v913, v914)
                        false
            let v966 : UH5 =
                if v961 then
                    let v962 : (string -> (string -> US32)) = closure73(v4, v3, v1, v0)
                    let v963 : UH5 = UH5_0
                    UH5_1(v151, v136, v962, v963)
                else
                    UH5_0
            let v967 : UH4 = UH4_0
            let v968 : UH4 = UH4_1(v912, v967)
            UH4_1(v966, v968)
    let v971 : UH5 list = []
    let v972 : UH5 list = method158(v970, v971)
    let v973 : (UH5 list -> (UH5 [])) = List.toArray
    let v974 : (UH5 []) = v973 v972
    let v977 : string = "$0.to_vec()"
    let v978 : Vec<UH5> = Fable.Core.RustInterop.emitRustExpr v974 v977 
    let v979 : (Result<string, (string * string)> option []) = [||]
    let v980 : string = "$0.to_vec()"
    let v981 : Vec<Result<string, (string * string)> option> = Fable.Core.RustInterop.emitRustExpr v979 v980 
    let v982 : string = "fable_library_rust::NativeArray_::array_from($0)"
    let v983 : (UH5 []) = Fable.Core.RustInterop.emitRustExpr v978 v982 
    let v984 : int32 = v983.Length
    let v985 : Mut9 = {l0 = 0; l1 = v981} : Mut9
    while method159(v984, v985) do
        let v987 : int32 = v985.l0
        let v988 : Vec<Result<string, (string * string)> option> = v985.l1
        let v989 : UH5 = v983.[int v987]
        let v990 : struct (string * string * (string -> (string -> US32))) list = []
        let v991 : struct (string * string * (string -> (string -> US32))) list = method160(v989, v990)
        let v992 : (struct (string * string * (string -> (string -> US32))) list -> (struct (string * string * (string -> (string -> US32))) [])) = List.toArray
        let v993 : (struct (string * string * (string -> (string -> US32))) []) = v992 v991
        let v996 : string = "$0.to_vec()"
        let v997 : Vec<struct (string * string * (string -> (string -> US32)))> = Fable.Core.RustInterop.emitRustExpr v993 v996 
        let v998 : string = "rayon::iter::IntoParallelIterator::into_par_iter($0)"
        let v999 : rayon_vec_IntoIter<struct (string * string * (string -> (string -> US32)))> = Fable.Core.RustInterop.emitRustExpr v997 v998 
        let v1000 : string = "rayon::iter::ParallelIterator::map($0, |x| $1(x))"
        let v1001 : (struct (string * string * (string -> (string -> US32))) -> Result<string, (string * string)> option) = closure82()
        let v1002 : rayon_iter_Map<rayon_vec_IntoIter<struct (string * string * (string -> (string -> US32)))>> = Fable.Core.RustInterop.emitRustExpr struct (v999, v1001) v1000 
        let v1003 : string = "rayon::iter::ParallelIterator::collect($0)"
        let v1004 : Vec<Result<string, (string * string)> option> = Fable.Core.RustInterop.emitRustExpr v1002 v1003 
        let v1005 : Vec<Result<string, (string * string)> option> = method161(v1004)
        let v1006 : Vec<Result<string, (string * string)> option> = method162(v988)
        let v1007 : string = "true; let mut v1006 = v1006"
        let v1008 : bool = Fable.Core.RustInterop.emitRustExpr () v1007 
        let v1009 : string = "true; v1006.extend(v1005)"
        let v1010 : bool = Fable.Core.RustInterop.emitRustExpr () v1009 
        let v1011 : string = "v1006"
        let v1012 : Vec<Result<string, (string * string)> option> = Fable.Core.RustInterop.emitRustExpr () v1011 
        let v1013 : int32 = v987 + 1
        v985.l0 <- v1013
        v985.l1 <- v1012
        ()
    let v1014 : Vec<Result<string, (string * string)> option> = v985.l1
    let v1015 : (string * Vec<Result<string, (string * string)> option>) = v120, v1014 
    let v1016 : Result<(string * Vec<Result<string, (string * string)> option>), std_string_String> = Ok v1015 
    v1016
and method163 (v0 : Result<Vec<Result<(string * Vec<Result<string, (string * string)> option>), std_string_String>>, std_string_String>) : Result<Vec<Result<(string * Vec<Result<string, (string * string)> option>), std_string_String>>, std_string_String> =
    v0
and method25 (v0 : string, v1 : string, v2 : string, v3 : string) : std_pin_Pin<Box<Dyn<std_future_Future<Result<Vec<Result<(string * Vec<Result<string, (string * string)> option>), std_string_String>>, std_string_String>>>>> =
    let v4 : string = __SOURCE_DIRECTORY__
    let v5 : string = "polyglot"
    let v6 : string = ".devcontainer"
    let v7 : string = method26(v5, v6)
    let v8 : US7 = method29(v7, v4)
    let v56 : US1 =
        match v8 with
        | US7_1(v11) -> (* Error *)
            let v12 : unit = ()
            let v13 : (unit -> unit) = closure14(v11)
            let v14 : unit = (fun () -> v13 (); v12) ()
            US1_1
        | US7_0(v9) -> (* Ok *)
            US1_0(v9)
    let v111 : US1 =
        match v56 with
        | US1_1 -> (* None *)
            let v59 : string = method38()
            let v60 : string = method26(v5, v6)
            let v61 : US7 = method29(v60, v59)
            match v61 with
            | US7_1(v64) -> (* Error *)
                let v65 : unit = ()
                let v66 : (unit -> unit) = closure14(v64)
                let v67 : unit = (fun () -> v66 (); v65) ()
                US1_1
            | US7_0(v62) -> (* Ok *)
                US1_0(v62)
        | US1_0(v57) -> (* Some *)
            US1_0(v57)
    let v115 : string =
        match v111 with
        | US1_1 -> (* None *)
            failwith<string> "Option does not have a value."
        | US1_0(v112) -> (* Some *)
            v112
    let v116 : string = method26(v115, v5)
    let v117 : string = method39(v3)
    let v118 : string = method39(v2)
    let v119 : string = method39(v1)
    let v120 : unit = ()
    let v121 : (unit -> unit) = closure19(v0, v117, v118, v119)
    let v122 : unit = (fun () -> v121 (); v120) ()
    let v162 : string = "true; let __future_init = Box::pin(async move { //"
    let v163 : bool = Fable.Core.RustInterop.emitRustExpr () v162 
    let v164 : string = "async_walkdir::WalkDir::new(&*$0)"
    let v165 : async_walkdir_WalkDir = Fable.Core.RustInterop.emitRustExpr v118 v164 
    let v166 : string = "async_walkdir::WalkDir::filter($0, |x| $1(x))"
    let v167 : (async_walkdir_DirEntry -> std_pin_Pin<Box<LifetimeJoin<Dyn<std_future_Future<async_walkdir_Filtering>>, Send<Dyn<std_future_Future<async_walkdir_Filtering>>>>>>) = closure20()
    let v168 : async_walkdir_WalkDir = Fable.Core.RustInterop.emitRustExpr struct (v165, v167) v166 
    let v169 : (Result<async_walkdir_DirEntry, async_walkdir_Error> -> string option) = method58()
    let v170 : string = "futures::stream::StreamExt::filter_map(v168, |x| async { v169(x) })"
    let v171 : _ = Fable.Core.RustInterop.emitRustExpr () v170 
    let v172 : string = "Box::pin(futures::stream::StreamExt::collect(v171))"
    let v173 : std_pin_Pin<Box<Dyn<std_future_Future<Vec<string>>>>> = Fable.Core.RustInterop.emitRustExpr () v172 
    let v174 : string = "v173.await"
    let v175 : Vec<string> = Fable.Core.RustInterop.emitRustExpr () v174 
    let v176 : unit = ()
    let v177 : (unit -> unit) = closure29(v175)
    let v178 : unit = (fun () -> v177 (); v176) ()
    let v220 : string = "rayon::iter::IntoParallelIterator::into_par_iter($0)"
    let v221 : rayon_vec_IntoIter<string> = Fable.Core.RustInterop.emitRustExpr v175 v220 
    let v222 : string = "rayon::iter::ParallelIterator::map($0, |x| $1(x))"
    let v223 : (string -> Result<(string * Vec<Result<string, (string * string)> option>), std_string_String>) = closure30(v0, v116, v117, v118, v119)
    let v224 : rayon_iter_Map<rayon_vec_IntoIter<string>> = Fable.Core.RustInterop.emitRustExpr struct (v221, v223) v222 
    let v225 : string = "rayon::iter::ParallelIterator::collect($0)"
    let v226 : Vec<Result<(string * Vec<Result<string, (string * string)> option>), std_string_String>> = Fable.Core.RustInterop.emitRustExpr v224 v225 
    let v227 : Result<Vec<Result<(string * Vec<Result<string, (string * string)> option>), std_string_String>>, std_string_String> = Ok v226 
    let v228 : Result<Vec<Result<(string * Vec<Result<string, (string * string)> option>), std_string_String>>, std_string_String> = method163(v227)
    let v229 : string = ""
    let v230 : string = "}"
    let v231 : string = v229 + v230 
    let v232 : _ = v228 
    let v233 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v234 : string = $"true; let v232 = $0"
    let v235 : bool = Fable.Core.RustInterop.emitRustExpr v232 v234 
    let _v233 = v235 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v236 : string = $"true; let v232 = $0"
    let v237 : bool = Fable.Core.RustInterop.emitRustExpr v232 v236 
    let _v233 = v237 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v238 : string = $"true; let v232 = $0"
    let v239 : bool = Fable.Core.RustInterop.emitRustExpr v232 v238 
    let _v233 = v239 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v240 : bool = true
    let _v233 = v240 
    #endif
#if FABLE_COMPILER_PYTHON
    let v241 : bool = true
    let _v233 = v241 
    #endif
#else
    let v242 : bool = true
    let _v233 = v242 
    #endif
    let v243 : bool = _v233 
    let v246 : string = $"true; v232 " + v231 + "); " + v229 + " // rust.fix_closure'"
    let v247 : bool = Fable.Core.RustInterop.emitRustExpr () v246 
    let v248 : string = "__future_init"
    let v249 : _ = Fable.Core.RustInterop.emitRustExpr () v248 
    let v250 : string = "v249"
    let v251 : std_pin_Pin<Box<Dyn<std_future_Future<Result<Vec<Result<(string * Vec<Result<string, (string * string)> option>), std_string_String>>, std_string_String>>>>> = Fable.Core.RustInterop.emitRustExpr () v250 
    v251
and closure83 () (v0 : Vec<Result<(string * Vec<Result<string, (string * string)> option>), std_string_String>>) : US36 =
    US36_0(v0)
and closure84 () (v0 : std_string_String) : US36 =
    US36_1(v0)
and method164 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : std_string_String) : string =
    let v9 : string = method62(v8)
    let v10 : int64 = v0.l0
    let v11 : string = "documents.main"
    let v12 : string = $"{v6} {v7} #{v10} %s{v11} / {v9}"
    method18(v12)
and closure85 (v0 : std_string_String) () : unit =
    let v1 : US0 = US0_4
    let v2 : bool = method7(v1)
    if v2 then
        let v3 : unit = ()
        let v4 : (unit -> unit) = closure6()
        let v5 : unit = (fun () -> v4 (); v3) ()
        let struct (v19 : Mut0, v20 : Mut1, v21 : Mut2, v22 : Mut3, v23 : Mut4, v24 : int64 option) = TraceState.trace_state.Value
        let v37 : string = method8(v19, v20, v21, v22, v23, v24)
        let v38 : string = method60()
        let v39 : string = method164(v19, v20, v21, v22, v23, v24, v37, v38, v0)
        method19(v39)
and method166 (v0 : unativeint) : string =
    let v1 : string = method14()
    let v2 : Mut3 = {l0 = v1} : Mut3
    let v3 : string = "{ "
    let v4 : string = $"{v3}"
    let v7 : unit = ()
    let v8 : (unit -> unit) = closure8(v2, v4)
    let v9 : unit = (fun () -> v8 (); v7) ()
    let v12 : string = "result_len"
    let v13 : string = $"{v12}"
    let v16 : unit = ()
    let v17 : (unit -> unit) = closure8(v2, v13)
    let v18 : unit = (fun () -> v17 (); v16) ()
    let v21 : string = " = "
    let v22 : string = $"{v21}"
    let v25 : unit = ()
    let v26 : (unit -> unit) = closure8(v2, v22)
    let v27 : unit = (fun () -> v26 (); v25) ()
    let v30 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v31 : string = "format!(\"{:#?}\", $0)"
    let v32 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v31 
    let v33 : string = "fable_library_rust::String_::fromString($0)"
    let v34 : string = Fable.Core.RustInterop.emitRustExpr v32 v33 
    let _v30 = v34 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v35 : string = "format!(\"{:#?}\", $0)"
    let v36 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v35 
    let v37 : string = "fable_library_rust::String_::fromString($0)"
    let v38 : string = Fable.Core.RustInterop.emitRustExpr v36 v37 
    let _v30 = v38 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v39 : string = "format!(\"{:#?}\", $0)"
    let v40 : std_string_String = Fable.Core.RustInterop.emitRustExpr v0 v39 
    let v41 : string = "fable_library_rust::String_::fromString($0)"
    let v42 : string = Fable.Core.RustInterop.emitRustExpr v40 v41 
    let _v30 = v42 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v43 : string = $"%A{v0}"
    let _v30 = v43 
    #endif
#if FABLE_COMPILER_PYTHON
    let v46 : string = $"%A{v0}"
    let _v30 = v46 
    #endif
#else
    let v49 : string = $"%A{v0}"
    let _v30 = v49 
    #endif
    let v52 : string = _v30 
    let v57 : string = $"{v52}"
    let v60 : unit = ()
    let v61 : (unit -> unit) = closure8(v2, v57)
    let v62 : unit = (fun () -> v61 (); v60) ()
    let v65 : string = " }"
    let v66 : string = $"{v65}"
    let v69 : unit = ()
    let v70 : (unit -> unit) = closure8(v2, v66)
    let v71 : unit = (fun () -> v70 (); v69) ()
    let v74 : string = v2.l0
    v74
and method165 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : unativeint) : string =
    let v9 : string = method166(v8)
    let v10 : int64 = v0.l0
    let v11 : string = "documents.main"
    let v12 : string = $"{v6} {v7} #{v10} %s{v11} / {v9}"
    method18(v12)
and closure86 (v0 : Vec<Result<(string * Vec<Result<string, (string * string)> option>), std_string_String>>) () : unit =
    let v1 : US0 = US0_2
    let v2 : bool = method7(v1)
    if v2 then
        let v3 : unit = ()
        let v4 : (unit -> unit) = closure6()
        let v5 : unit = (fun () -> v4 (); v3) ()
        let struct (v19 : Mut0, v20 : Mut1, v21 : Mut2, v22 : Mut3, v23 : Mut4, v24 : int64 option) = TraceState.trace_state.Value
        let v37 : string = method8(v19, v20, v21, v22, v23, v24)
        let v38 : string = method12()
        let v39 : string = "$0.len()"
        let v40 : unativeint = Fable.Core.RustInterop.emitRustExpr v0 v39 
        let v41 : string = method165(v19, v20, v21, v22, v23, v24, v37, v38, v40)
        method19(v41)
and closure1 () (v0 : (string [])) : int32 =
    let v1 : unit = ()
    let v2 : (unit -> unit) = closure2()
    let v3 : unit = (fun () -> v2 (); v1) ()
    let v17 : unit = ()
    let v18 : (unit -> unit) = closure5(v0)
    let v19 : unit = (fun () -> v18 (); v17) ()
    let v59 : clap_Command = method0()
    let v60 : string = "clap::Command::get_matches($0)"
    let v61 : clap_ArgMatches = Fable.Core.RustInterop.emitRustExpr v59 v60 
    let v62 : string = method20()
    let v63 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v64 : string = "&*$0"
    let v65 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v62 v64 
    let _v63 = v65 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v66 : string = "&*$0"
    let v67 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v62 v66 
    let _v63 = v67 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v68 : string = "&*$0"
    let v69 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v62 v68 
    let _v63 = v69 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v70 : Ref<Str> = v62 |> unbox<Ref<Str>>
    let _v63 = v70 
    #endif
#if FABLE_COMPILER_PYTHON
    let v73 : Ref<Str> = v62 |> unbox<Ref<Str>>
    let _v63 = v73 
    #endif
#else
    let v76 : Ref<Str> = v62 |> unbox<Ref<Str>>
    let _v63 = v76 
    #endif
    let v79 : Ref<Str> = _v63 
    let v84 : string = "clap::ArgMatches::get_one(&$0, $1).cloned()"
    let v85 : std_string_String option = Fable.Core.RustInterop.emitRustExpr struct (v61, v79) v84 
    let v86 : (std_string_String -> US4) = method21()
    let v87 : US4 option = v85 |> Option.map v86 
    let v98 : US4 = US4_1
    let v99 : US4 = v87 |> Option.defaultValue v98 
    let v106 : std_string_String =
        match v99 with
        | US4_1 -> (* None *)
            failwith<std_string_String> "Option does not have a value."
        | US4_0(v103) -> (* Some *)
            v103
    let v107 : string = "fable_library_rust::String_::fromString($0)"
    let v108 : string = Fable.Core.RustInterop.emitRustExpr v106 v107 
    let v109 : string = method22()
    let v110 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v111 : string = "&*$0"
    let v112 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v109 v111 
    let _v110 = v112 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v113 : string = "&*$0"
    let v114 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v109 v113 
    let _v110 = v114 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v115 : string = "&*$0"
    let v116 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v109 v115 
    let _v110 = v116 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v117 : Ref<Str> = v109 |> unbox<Ref<Str>>
    let _v110 = v117 
    #endif
#if FABLE_COMPILER_PYTHON
    let v120 : Ref<Str> = v109 |> unbox<Ref<Str>>
    let _v110 = v120 
    #endif
#else
    let v123 : Ref<Str> = v109 |> unbox<Ref<Str>>
    let _v110 = v123 
    #endif
    let v126 : Ref<Str> = _v110 
    let v131 : string = "clap::ArgMatches::get_one(&$0, $1).cloned()"
    let v132 : std_string_String option = Fable.Core.RustInterop.emitRustExpr struct (v61, v126) v131 
    let v133 : (std_string_String -> US4) = method21()
    let v134 : US4 option = v132 |> Option.map v133 
    let v145 : US4 = US4_1
    let v146 : US4 = v134 |> Option.defaultValue v145 
    let v153 : std_string_String =
        match v146 with
        | US4_1 -> (* None *)
            failwith<std_string_String> "Option does not have a value."
        | US4_0(v150) -> (* Some *)
            v150
    let v154 : string = "fable_library_rust::String_::fromString($0)"
    let v155 : string = Fable.Core.RustInterop.emitRustExpr v153 v154 
    let v156 : string = method23()
    let v157 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v158 : string = "&*$0"
    let v159 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v156 v158 
    let _v157 = v159 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v160 : string = "&*$0"
    let v161 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v156 v160 
    let _v157 = v161 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v162 : string = "&*$0"
    let v163 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v156 v162 
    let _v157 = v163 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v164 : Ref<Str> = v156 |> unbox<Ref<Str>>
    let _v157 = v164 
    #endif
#if FABLE_COMPILER_PYTHON
    let v167 : Ref<Str> = v156 |> unbox<Ref<Str>>
    let _v157 = v167 
    #endif
#else
    let v170 : Ref<Str> = v156 |> unbox<Ref<Str>>
    let _v157 = v170 
    #endif
    let v173 : Ref<Str> = _v157 
    let v178 : string = "clap::ArgMatches::get_one(&$0, $1).cloned()"
    let v179 : std_string_String option = Fable.Core.RustInterop.emitRustExpr struct (v61, v173) v178 
    let v180 : (std_string_String -> US4) = method21()
    let v181 : US4 option = v179 |> Option.map v180 
    let v192 : US4 = US4_1
    let v193 : US4 = v181 |> Option.defaultValue v192 
    let v200 : std_string_String =
        match v193 with
        | US4_1 -> (* None *)
            failwith<std_string_String> "Option does not have a value."
        | US4_0(v197) -> (* Some *)
            v197
    let v201 : string = "fable_library_rust::String_::fromString($0)"
    let v202 : string = Fable.Core.RustInterop.emitRustExpr v200 v201 
    let v203 : string = method24()
    let v204 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v205 : string = "&*$0"
    let v206 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v203 v205 
    let _v204 = v206 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v207 : string = "&*$0"
    let v208 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v203 v207 
    let _v204 = v208 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v209 : string = "&*$0"
    let v210 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v203 v209 
    let _v204 = v210 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v211 : Ref<Str> = v203 |> unbox<Ref<Str>>
    let _v204 = v211 
    #endif
#if FABLE_COMPILER_PYTHON
    let v214 : Ref<Str> = v203 |> unbox<Ref<Str>>
    let _v204 = v214 
    #endif
#else
    let v217 : Ref<Str> = v203 |> unbox<Ref<Str>>
    let _v204 = v217 
    #endif
    let v220 : Ref<Str> = _v204 
    let v225 : string = "clap::ArgMatches::get_one(&$0, $1).cloned()"
    let v226 : std_string_String option = Fable.Core.RustInterop.emitRustExpr struct (v61, v220) v225 
    let v227 : (std_string_String -> US4) = method21()
    let v228 : US4 option = v226 |> Option.map v227 
    let v239 : US4 = US4_1
    let v240 : US4 = v228 |> Option.defaultValue v239 
    let v247 : std_string_String =
        match v240 with
        | US4_1 -> (* None *)
            failwith<std_string_String> "Option does not have a value."
        | US4_0(v244) -> (* Some *)
            v244
    let v248 : string = "fable_library_rust::String_::fromString($0)"
    let v249 : string = Fable.Core.RustInterop.emitRustExpr v247 v248 
    let v250 : std_pin_Pin<Box<Dyn<std_future_Future<Result<Vec<Result<(string * Vec<Result<string, (string * string)> option>), std_string_String>>, std_string_String>>>>> = method25(v249, v202, v155, v108)
    let v251 : string = "futures::executor::block_on($0)"
    let v252 : Result<Vec<Result<(string * Vec<Result<string, (string * string)> option>), std_string_String>>, std_string_String> = Fable.Core.RustInterop.emitRustExpr v250 v251 
    let v253 : (Vec<Result<(string * Vec<Result<string, (string * string)> option>), std_string_String>> -> US36) = closure83()
    let v254 : (std_string_String -> US36) = closure84()
    let v255 : US36 = match v252 with Ok x -> v253 x | Error x -> v254 x
    match v255 with
    | US36_1(v301) -> (* Error *)
        let v302 : unit = ()
        let v303 : (unit -> unit) = closure85(v301)
        let v304 : unit = (fun () -> v303 (); v302) ()
        1
    | US36_0(v256) -> (* Ok *)
        let v257 : unit = ()
        let v258 : (unit -> unit) = closure86(v256)
        let v259 : unit = (fun () -> v258 (); v257) ()
        0
let v0 : (unit -> unit) = closure0()
let tests () = v0 ()
let v1 : ((string []) -> int32) = closure1()
let main args = v1 args
()
